@dxos/echo 0.8.4-main.69d29f4 → 0.8.4-main.6fa680abb7

package/dist/lib/{node-esm/chunk-5U5F4AWK.mjs → neutral/chunk-MFJPOZDU.mjs}

@@ -1,19 +1,20 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  CurrencyAnnotationId,
-  FormatAnnotation,
-  FormatAnnotationId,
-  TypeFormat
-} from "./chunk-TSTKBFST.mjs";
+  JsonSchemaFields,
+  JsonSchemaType,
+  toEffectSchema,
+  toJsonSchema
+} from "./chunk-2Z72D23W.mjs";
 import {
-  Service
-} from "./chunk-FWTSPIFF.mjs";
+  Ref,
+  refFromEncodedReference,
+  setRefResolver
+} from "./chunk-35FDO7WH.mjs";
 import {
+  ATTR_PARENT,
   ATTR_TYPE,
-  GeneratorAnnotationId,
-  LabelAnnotationId,
-  PropertyMetaAnnotationId,
-  ReferenceAnnotationId,
+  IconAnnotation,
+  LabelAnnotation,
+  ParentId,
   SchemaId,
   SchemaMetaSymbol,
   TypeAnnotationId,
@@ -21,9 +22,8 @@ import {
   TypeIdentifierAnnotationId,
   TypenameSchema,
   VersionSchema,
-  getDescriptionWithSchema,
   getEntityKind,
-  getLabelWithSchema,
+  getLabel,
   getSchema,
   getSchemaDXN,
   getSchemaTypename,
@@ -31,26 +31,21 @@ import {
   getTypeDXN,
   getTypeIdentifierAnnotation,
   getTypename,
-  setDescriptionWithSchema,
-  setLabelWithSchema,
   setSchema,
   setTypename
-} from "./chunk-YOLH5KS4.mjs";
+} from "./chunk-SEMVAGBM.mjs";
 import {
-  ANY_OBJECT_TYPENAME,
-  ANY_OBJECT_VERSION,
   EntityKind,
-  EntityKindSchema,
   KindId,
   SchemaKindId,
   SnapshotKindId,
   makeTypeJsonSchemaAnnotation
-} from "./chunk-XHJRMQZD.mjs";
+} from "./chunk-WYOKA6AE.mjs";
 
 // src/internal/index.ts
-import { JsonPath as JsonPath2, JsonProp, getValue, splitJsonPath } from "@dxos/effect";
+import { JsonPath, JsonProp, getValue, splitJsonPath } from "@dxos/effect";
 
-// src/internal/types/base.ts
+// src/internal/common/types/base.ts
 import * as Schema from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var RawObject = (schema) => {
@@ -59,14 +54,14 @@ var RawObject = (schema) => {
   ]));
 };
 
-// src/internal/types/meta.ts
+// src/internal/common/types/meta.ts
 import * as Schema2 from "effect/Schema";
 import { ForeignKey } from "@dxos/echo-protocol";
 import { invariant } from "@dxos/invariant";
 import { intersection } from "@dxos/util";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/types/meta.ts";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/types/meta.ts";
 var ATTR_META = "@meta";
-var MetaId = Symbol.for("@dxos/echo/Meta");
+var MetaId = /* @__PURE__ */ Symbol.for("@dxos/echo/Meta");
 var ObjectMetaSchema = Schema2.Struct({
   keys: Schema2.Array(ForeignKey),
   /**
@@ -76,13 +71,14 @@ var ObjectMetaSchema = Schema2.Struct({
   */
   // TODO(dmaretskyi): Has to be optional for compatibility with old data.
   // Defaulting to an empty array is possible but requires a bit more work.
+  // TODO(dmaretskyi): In automerge this should be a map of { [tag]: boolean } for uniqueness and conflict resolution.
   tags: Schema2.optional(Schema2.Array(Schema2.String))
 });
 var getMeta = (obj) => {
   const metadata = obj[MetaId];
   invariant(metadata, "ObjectMeta not found.", {
     F: __dxlog_file,
-    L: 52,
+    L: 55,
     S: void 0,
     A: [
       "metadata",
@@ -98,2766 +94,1631 @@ var foreignKey = (source, id) => ({
 var foreignKeyEquals = (a, b) => a.source === b.source && a.id === b.id;
 var compareForeignKeys = (a, b) => intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;
 
-// src/internal/types/version.ts
-var VersionTypeId = Symbol.for("@dxos/echo/VersionTypeId");
+// src/internal/common/types/model-symbols.ts
+var ATTR_SELF_DXN = "@dxn";
+var SelfDXNId = /* @__PURE__ */ Symbol.for("@dxos/echo/DXN");
+var ATTR_DELETED = "@deleted";
+var ObjectDeletedId = /* @__PURE__ */ Symbol.for("@dxos/echo/Deleted");
+var ObjectVersionId = /* @__PURE__ */ Symbol.for("@dxos/echo/Version");
+var ObjectDatabaseId = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
+var ATTR_RELATION_SOURCE = "@relationSource";
+var RelationSourceId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationSource");
+var RelationSourceDXNId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationSourceDXN");
+var ATTR_RELATION_TARGET = "@relationTarget";
+var RelationTargetId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationTarget");
+var RelationTargetDXNId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationTargetDXN");
+
+// src/internal/common/types/version.ts
+var VersionTypeId = "~@dxos/echo/VersionTypeId";
 
-// src/internal/api/annotations.ts
-var getLabel = (entity) => {
-  const schema = getSchema(entity);
-  if (schema != null) {
-    return getLabelWithSchema(schema, entity);
+// src/internal/Annotation/sorting.ts
+var compare = (a, b) => {
+  if (a == null) {
+    return b == null ? 0 : 1;
   }
-};
-var setLabel = (entity, label) => {
-  const schema = getSchema(entity);
-  if (schema != null) {
-    setLabelWithSchema(schema, entity, label);
+  if (b == null) {
+    return -1;
   }
+  return a.localeCompare(b);
 };
-var getDescription = (entity) => {
-  const schema = getSchema(entity);
-  if (schema != null) {
-    return getDescriptionWithSchema(schema, entity);
+var sortByLabel = (a, b) => compare(getLabel(a), getLabel(b));
+var sortByTypename = (a, b) => compare(getTypename(a), getTypename(b));
+var sort = (...comparators) => {
+  return (a, b) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  };
+};
+
+// src/internal/common/api/meta.ts
+import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/api/meta.ts";
+function getMetaChecked(entity) {
+  assertArgument(entity, "entity", "Should be an entity.");
+  const meta = getMeta(entity);
+  invariant2(meta != null, "Invalid entity.", {
+    F: __dxlog_file2,
+    L: 34,
+    S: this,
+    A: [
+      "meta != null",
+      "'Invalid entity.'"
+    ]
+  });
+  return meta;
+}
+var getKeys = (entity, source) => {
+  assertArgument(entity, "entity", "Should be an entity.");
+  const meta = getMetaChecked(entity);
+  invariant2(meta != null, "Invalid entity.", {
+    F: __dxlog_file2,
+    L: 45,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid entity.'"
+    ]
+  });
+  return meta.keys.filter((key) => key.source === source);
+};
+var deleteKeys = (entity, source) => {
+  const meta = getMetaChecked(entity);
+  for (let i = 0; i < meta.keys.length; i++) {
+    if (meta.keys[i].source === source) {
+      meta.keys.splice(i, 1);
+      i--;
+    }
   }
 };
-var setDescription = (entity, description) => {
-  const schema = getSchema(entity);
-  if (schema != null) {
-    setDescriptionWithSchema(schema, entity, description);
+var addTag = (entity, tag) => {
+  const meta = getMetaChecked(entity);
+  meta.tags ??= [];
+  meta.tags.push(tag);
+};
+var removeTag = (entity, tag) => {
+  const meta = getMetaChecked(entity);
+  if (!meta.tags) {
+    return;
+  }
+  for (let i = 0; i < meta.tags.length; i++) {
+    if (meta.tags[i] === tag) {
+      meta.tags.splice(i, 1);
+      i--;
+    }
   }
 };
 
-// src/internal/api/entity.ts
-import { invariant as invariant6 } from "@dxos/invariant";
-import { assumeType as assumeType3 } from "@dxos/util";
+// src/internal/common/proxy/symbols.ts
+var EventId = /* @__PURE__ */ Symbol.for("@dxos/live-object/EventId");
+var ChangeId = /* @__PURE__ */ Symbol.for("@dxos/live-object/ChangeId");
 
-// src/internal/entities/entity.ts
-import * as Schema3 from "effect/Schema";
-var makeEchoTypeSchema = (fields, ast, typename, version2, kind) => {
-  return class EchoObjectSchemaClass extends Schema3.make(ast) {
-    static typename = typename;
-    static version = version2;
-    static [SchemaKindId] = kind;
-    static fields = fields;
-    static annotations(annotations4) {
-      const schema = Schema3.make(ast).annotations(annotations4);
-      return makeEchoTypeSchema(fields, schema.ast, typename, version2, kind);
-    }
-    // static make(
-    //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
-    //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
-    //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
-    //   options?: MakeProps,
-    // ): Simplify<Schema.TypeLiteral.Type<Fields, []>> {
-    //   const propsWithDefaults: any = _lazilyMergeDefaults(fields, { ...(props as any) });
-    //   return _getDisableValidationMakeOption(options)
-    //     ? propsWithDefaults
-    //     : ParseResult.validateSync(this)(propsWithDefaults);
-    // }
-    static instanceOf(value2) {
-      return Schema3.is(this)(value2);
+// src/internal/common/proxy/event-batch.ts
+var eventBatchDepth = 0;
+var pendingEventTargets = /* @__PURE__ */ new Set();
+var batchEvents = (callback) => {
+  eventBatchDepth++;
+  try {
+    callback();
+  } finally {
+    eventBatchDepth--;
+    if (eventBatchDepth === 0) {
+      for (const target of pendingEventTargets) {
+        target[EventId]?.emit();
+      }
+      pendingEventTargets.clear();
     }
-  };
+  }
+};
+var emitEvent = (target) => {
+  if (eventBatchDepth > 0) {
+    pendingEventTargets.add(target);
+  } else {
+    target[EventId]?.emit();
+  }
 };
 
-// src/internal/entities/model.ts
-import { invariant as invariant3 } from "@dxos/invariant";
-import { DXN as DXN2, ObjectId } from "@dxos/keys";
-import { assumeType } from "@dxos/util";
-
-// src/internal/entities/relation.ts
-import * as Schema4 from "effect/Schema";
-import * as SchemaAST2 from "effect/SchemaAST";
-import { raise } from "@dxos/debug";
-import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
-import { DXN } from "@dxos/keys";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/entities/relation.ts";
-var ATTR_RELATION_SOURCE = "@relationSource";
-var RelationSourceId = Symbol.for("@dxos/echo/RelationSource");
-var RelationSourceDXNId = Symbol.for("@dxos/echo/RelationSourceDXN");
-var ATTR_RELATION_TARGET = "@relationTarget";
-var RelationTargetId = Symbol.for("@dxos/echo/RelationTarget");
-var RelationTargetDXNId = Symbol.for("@dxos/echo/RelationTargetDXN");
-var EchoRelationSchema = ({ source, target, typename, version: version2 }) => {
-  assertArgument(Schema4.isSchema(source), "source");
-  assertArgument(Schema4.isSchema(target), "target");
-  const sourceDXN = getDXNForRelationSchemaRef(source);
-  const targetDXN = getDXNForRelationSchemaRef(target);
-  if (getEntityKind(source) !== EntityKind.Object) {
-    raise(new Error("Source schema must be an echo object schema."));
+// src/internal/common/proxy/change-context.ts
+var currentChangeContext = null;
+var pendingNotificationKey = null;
+var pendingOwnerNotifications = /* @__PURE__ */ new Set();
+var enterChangeContext = (key) => {
+  currentChangeContext = key;
+  return () => {
+    currentChangeContext = null;
+  };
+};
+var isInChangeContext = (key) => {
+  return currentChangeContext === key;
+};
+var queueNotification = (key) => {
+  if (currentChangeContext === key) {
+    pendingNotificationKey = key;
   }
-  if (getEntityKind(target) !== EntityKind.Object) {
-    raise(new Error("Target schema must be an echo object schema."));
+};
+var queueOwnerNotification = (target) => {
+  if (currentChangeContext !== null && target !== currentChangeContext) {
+    pendingOwnerNotifications.add(target);
   }
-  return (self) => {
-    invariant2(SchemaAST2.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
-      F: __dxlog_file2,
-      L: 127,
-      S: void 0,
-      A: [
-        "SchemaAST.isTypeLiteral(self.ast)",
-        "'Schema must be a TypeLiteral.'"
-      ]
-    });
-    const fields = self.fields ?? {};
-    const schemaWithId = Schema4.extend(self, Schema4.Struct({
-      id: Schema4.String
-    }));
-    const ast = SchemaAST2.annotations(schemaWithId.ast, {
-      // TODO(dmaretskyi): `extend` kills the annotations.
-      ...self.ast.annotations,
-      [TypeAnnotationId]: {
-        kind: EntityKind.Relation,
-        typename,
-        version: version2,
-        sourceSchema: sourceDXN,
-        targetSchema: targetDXN
-      },
-      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
-      [SchemaAST2.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
-        kind: EntityKind.Relation,
-        typename,
-        version: version2,
-        relationSource: sourceDXN,
-        relationTarget: targetDXN
-      })
-    });
-    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Relation);
-  };
 };
-var getDXNForRelationSchemaRef = (schema) => {
-  assertArgument(Schema4.isSchema(schema), "schema");
-  const identifier = getTypeIdentifierAnnotation(schema);
-  if (identifier) {
-    return identifier;
+var hasPendingNotifications = (key) => {
+  return pendingNotificationKey === key;
+};
+var clearPendingNotifications = (key) => {
+  if (pendingNotificationKey === key) {
+    pendingNotificationKey = null;
   }
-  const typename = getSchemaTypename(schema);
-  if (!typename) {
-    throw new Error("Schema must have a typename");
+};
+var executeChange = (contextKey, eventTarget, proxy, callback) => {
+  const exitContext = enterChangeContext(contextKey);
+  try {
+    batchEvents(() => callback(proxy));
+  } finally {
+    exitContext();
+    if (hasPendingNotifications(contextKey)) {
+      clearPendingNotifications(contextKey);
+      eventTarget[EventId]?.emit();
+    }
+    for (const ownerTarget of pendingOwnerNotifications) {
+      ownerTarget[EventId]?.emit();
+    }
+    pendingOwnerNotifications.clear();
   }
-  return DXN.fromTypename(typename).toString();
 };
 
-// src/internal/entities/model.ts
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/entities/model.ts";
-var ATTR_SELF_DXN = "@dxn";
-var SelfDXNId = Symbol.for("@dxos/echo/DXN");
-var ATTR_DELETED = "@deleted";
-var ObjectDeletedId = Symbol.for("@dxos/echo/Deleted");
-var ObjectVersionId = Symbol.for("@dxos/echo/Version");
-var ObjectDatabaseId = Symbol.for("@dxos/echo/Database");
-function assertObjectModel(obj) {
-  invariant3(typeof obj === "object" && obj !== null, "Invalid object model: not an object", {
-    F: __dxlog_file3,
-    L: 119,
-    S: this,
-    A: [
-      "typeof obj === 'object' && obj !== null",
-      "'Invalid object model: not an object'"
-    ]
-  });
-  assumeType(obj);
-  invariant3(ObjectId.isValid(obj.id), "Invalid object model: invalid id", {
-    F: __dxlog_file3,
-    L: 121,
-    S: this,
-    A: [
-      "ObjectId.isValid(obj.id)",
-      "'Invalid object model: invalid id'"
-    ]
-  });
-  invariant3(obj[TypeId] === void 0 || obj[TypeId] instanceof DXN2, "Invalid object model: invalid type", {
-    F: __dxlog_file3,
-    L: 122,
-    S: this,
-    A: [
-      "obj[TypeId] === undefined || obj[TypeId] instanceof DXN",
-      "'Invalid object model: invalid type'"
-    ]
-  });
-  invariant3(obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation, "Invalid object model: invalid entity kind", {
-    F: __dxlog_file3,
-    L: 123,
-    S: this,
-    A: [
-      "obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation",
-      "'Invalid object model: invalid entity kind'"
-    ]
+// src/internal/common/proxy/define-hidden-property.ts
+var defineHiddenProperty = (object, key, value2) => {
+  Object.defineProperty(object, key, {
+    enumerable: false,
+    configurable: true,
+    value: value2
   });
-  if (obj[KindId] === EntityKind.Relation) {
-    invariant3(obj[RelationSourceDXNId] instanceof DXN2, "Invalid object model: invalid relation source", {
-      F: __dxlog_file3,
-      L: 129,
-      S: this,
-      A: [
-        "obj[RelationSourceDXNId] instanceof DXN",
-        "'Invalid object model: invalid relation source'"
-      ]
-    });
-    invariant3(obj[RelationTargetDXNId] instanceof DXN2, "Invalid object model: invalid relation target", {
-      F: __dxlog_file3,
-      L: 130,
-      S: this,
-      A: [
-        "obj[RelationTargetDXNId] instanceof DXN",
-        "'Invalid object model: invalid relation target'"
-      ]
-    });
-    invariant3(!(obj[RelationSourceId] instanceof DXN2), "Invalid object model: source pointer is a DXN", {
+};
+
+// src/internal/common/proxy/errors.ts
+var MutationOutsideChangeContextError = class extends Error {
+  constructor(operation, suggestion) {
+    super(`Cannot ${operation} outside of Obj.change(). Use Obj.change(obj, (mutableObj) => { ${suggestion} }) instead.`);
+    this.name = "MutationOutsideChangeContextError";
+  }
+};
+var createPropertySetError = (prop) => {
+  return new MutationOutsideChangeContextError(`modify object property "${String(prop)}"`, `mutableObj.${String(prop)} = value;`);
+};
+var createPropertyDeleteError = (prop) => {
+  return new MutationOutsideChangeContextError(`delete object property "${String(prop)}"`, `delete mutableObj.${String(prop)};`);
+};
+var createArrayMethodError = (method) => {
+  return new MutationOutsideChangeContextError(`call array.${method}()`, `mutableObj.array.${method}(...);`);
+};
+
+// src/internal/common/proxy/json-serializer.ts
+import { invariant as invariant3 } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+import { deepMapValues } from "@dxos/util";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/json-serializer.ts";
+var attachTypedJsonSerializer = (obj) => {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, "toJSON");
+  if (descriptor) {
+    return;
+  }
+  Object.defineProperty(obj, "toJSON", {
+    value: typedJsonSerializer,
+    writable: false,
+    enumerable: false,
+    // Setting `configurable` to false breaks proxy invariants, should be fixable.
+    configurable: true
+  });
+};
+var typedJsonSerializer = function() {
+  const { id, ...rest } = this;
+  const result = {
+    id
+  };
+  if (this[TypeId]) {
+    result[ATTR_TYPE] = this[TypeId].toString();
+  }
+  if (this[MetaId]) {
+    result[ATTR_META] = serializeMeta(this[MetaId]);
+  }
+  if (this[SelfDXNId]) {
+    result[ATTR_SELF_DXN] = this[SelfDXNId].toString();
+  }
+  if (this[RelationSourceDXNId]) {
+    const sourceDXN = this[RelationSourceDXNId];
+    invariant3(sourceDXN instanceof DXN, void 0, {
       F: __dxlog_file3,
-      L: 131,
+      L: 64,
       S: this,
       A: [
-        "!(obj[RelationSourceId] instanceof DXN)",
-        "'Invalid object model: source pointer is a DXN'"
+        "sourceDXN instanceof DXN",
+        ""
       ]
     });
-    invariant3(!(obj[RelationTargetId] instanceof DXN2), "Invalid object model: target pointer is a DXN", {
+    result[ATTR_RELATION_SOURCE] = sourceDXN.toString();
+  }
+  if (this[RelationTargetDXNId]) {
+    const targetDXN = this[RelationTargetDXNId];
+    invariant3(targetDXN instanceof DXN, void 0, {
       F: __dxlog_file3,
-      L: 132,
+      L: 69,
       S: this,
       A: [
-        "!(obj[RelationTargetId] instanceof DXN)",
-        "'Invalid object model: target pointer is a DXN'"
+        "targetDXN instanceof DXN",
+        ""
       ]
     });
+    result[ATTR_RELATION_TARGET] = targetDXN.toString();
   }
-}
-
-// src/internal/entities/object.ts
-import * as Schema5 from "effect/Schema";
-import * as SchemaAST3 from "effect/SchemaAST";
-import { invariant as invariant4 } from "@dxos/invariant";
-var __dxlog_file4 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/entities/object.ts";
-var EchoObjectSchema = ({ typename, version: version2 }) => {
-  return (self) => {
-    invariant4(typeof TypeAnnotationId === "symbol", "Sanity.", {
-      F: __dxlog_file4,
-      L: 37,
-      S: void 0,
-      A: [
-        "typeof TypeAnnotationId === 'symbol'",
-        "'Sanity.'"
-      ]
-    });
-    invariant4(SchemaAST3.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
-      F: __dxlog_file4,
-      L: 38,
-      S: void 0,
-      A: [
-        "SchemaAST.isTypeLiteral(self.ast)",
-        "'Schema must be a TypeLiteral.'"
-      ]
-    });
-    const fields = self.fields ?? {};
-    const schemaWithId = Schema5.extend(self, Schema5.Struct({
-      id: Schema5.String
-    }));
-    const ast = SchemaAST3.annotations(schemaWithId.ast, {
-      // TODO(dmaretskyi): `extend` kills the annotations.
-      ...self.ast.annotations,
-      [TypeAnnotationId]: {
-        kind: EntityKind.Object,
-        typename,
-        version: version2
-      },
-      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
-      [SchemaAST3.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
-        kind: EntityKind.Object,
-        typename,
-        version: version2
-      })
-    });
-    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Object);
-  };
+  Object.assign(result, serializeData(rest));
+  return result;
 };
-
-// src/internal/entities/util.ts
-import * as Schema6 from "effect/Schema";
-import { assertArgument as assertArgument2, invariant as invariant5 } from "@dxos/invariant";
-import { DXN as DXN3, ObjectId as ObjectId2 } from "@dxos/keys";
-import { assumeType as assumeType2 } from "@dxos/util";
-var __dxlog_file5 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/entities/util.ts";
-var getObjectDXN = (object) => {
-  invariant5(!Schema6.isSchema(object), "schema not allowed in this function", {
-    F: __dxlog_file5,
-    L: 19,
-    S: void 0,
-    A: [
-      "!Schema.isSchema(object)",
-      "'schema not allowed in this function'"
-    ]
+var serializeData = (data) => {
+  return deepMapValues(data, (value2, recurse) => {
+    if (Ref.isRef(value2)) {
+      return value2.noInline().encode();
+    }
+    return recurse(value2);
   });
-  assertArgument2(typeof object === "object" && object != null, "object", "expected object");
-  assumeType2(object);
-  if (object[SelfDXNId]) {
-    invariant5(object[SelfDXNId] instanceof DXN3, "Invalid object model: invalid self dxn", {
-      F: __dxlog_file5,
-      L: 24,
-      S: void 0,
-      A: [
-        "object[SelfDXNId] instanceof DXN",
-        "'Invalid object model: invalid self dxn'"
-      ]
-    });
-    return object[SelfDXNId];
+};
+var serializeMeta = (meta) => {
+  return deepMapValues(meta, (value2, recurse) => recurse(value2));
+};
+
+// src/internal/common/proxy/make-object.ts
+import { ObjectId } from "@dxos/keys";
+
+// src/internal/common/proxy/proxy-utils.ts
+import { invariant as invariant4 } from "@dxos/invariant";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/proxy-utils.ts";
+var symbolIsProxy = /* @__PURE__ */ Symbol.for("@dxos/schema/Proxy");
+var isProxy = (value2) => !!value2?.[symbolIsProxy];
+var isValidProxyTarget = (value2) => {
+  if (value2 == null || value2[symbolIsProxy]) {
+    return false;
   }
-  if (!ObjectId2.isValid(object.id)) {
-    throw new TypeError("Object id is not valid.");
+  if (Array.isArray(value2)) {
+    return true;
   }
-  return DXN3.fromLocalObjectId(object.id);
+  return typeof value2 === "object" && Object.getPrototypeOf(value2) === Object.prototype;
 };
-
-// src/internal/api/entity.ts
-var __dxlog_file6 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/api/entity.ts";
-var getDXN = (entity) => {
-  const dxn = getObjectDXN(entity);
-  invariant6(dxn != null, "Invalid entity.", {
-    F: __dxlog_file6,
-    L: 18,
+var getProxySlot = (proxy) => {
+  const value2 = proxy[symbolIsProxy];
+  invariant4(value2 instanceof ProxyHandlerSlot, void 0, {
+    F: __dxlog_file4,
+    L: 32,
     S: void 0,
     A: [
-      "dxn != null",
-      "'Invalid entity.'"
+      "value instanceof ProxyHandlerSlot",
+      ""
     ]
   });
-  return dxn;
-};
-var getDatabase = (entity) => {
-  assumeType3(entity);
-  return entity[ObjectDatabaseId];
+  return value2;
 };
-
-// src/internal/api/meta.ts
-import { assertArgument as assertArgument3, invariant as invariant7 } from "@dxos/invariant";
-var __dxlog_file7 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/api/meta.ts";
-function getMetaChecked(entity) {
-  assertArgument3(entity, "entity", "Should be an entity.");
-  const meta = getMeta(entity);
-  invariant7(meta != null, "Invalid entity.", {
-    F: __dxlog_file7,
-    L: 34,
-    S: this,
-    A: [
-      "meta != null",
-      "'Invalid entity.'"
-    ]
-  });
-  return meta;
-}
-var getKeys = (entity, source) => {
-  assertArgument3(entity, "entity", "Should be an entity.");
-  const meta = getMetaChecked(entity);
-  invariant7(meta != null, "Invalid entity.", {
-    F: __dxlog_file7,
-    L: 45,
-    S: void 0,
-    A: [
-      "meta != null",
-      "'Invalid entity.'"
-    ]
-  });
-  return meta.keys.filter((key) => key.source === source);
+var getProxyTarget = (proxy) => {
+  return getProxySlot(proxy).target;
 };
-var deleteKeys = (entity, source) => {
-  const meta = getMetaChecked(entity);
-  for (let i = 0; i < meta.keys.length; i++) {
-    if (meta.keys[i].source === source) {
-      meta.keys.splice(i, 1);
-      i--;
-    }
-  }
+var getProxyHandler = (proxy) => {
+  return getProxySlot(proxy).handler;
 };
-var addTag = (entity, tag) => {
-  const meta = getMetaChecked(entity);
-  meta.tags ??= [];
-  meta.tags.push(tag);
+var dangerouslySetProxyId = (obj, id) => {
+  getProxySlot(obj).target.id = id;
 };
-var removeTag = (entity, tag) => {
-  const meta = getMetaChecked(entity);
-  if (!meta.tags) {
-    return;
-  }
-  for (let i = 0; i < meta.tags.length; i++) {
-    if (meta.tags[i] === tag) {
-      meta.tags.splice(i, 1);
-      i--;
-    }
+var createProxy = (target, handler) => {
+  const existingProxy = handler._proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
   }
+  const proxy = new Proxy(target, new ProxyHandlerSlot(target, handler));
+  handler.init(target);
+  handler._proxyMap.set(target, proxy);
+  return proxy;
 };
-
-// src/internal/api/sorting.ts
-var compare = (a, b) => {
-  if (a == null) {
-    return b == null ? 0 : 1;
-  }
-  if (b == null) {
-    return -1;
+var ProxyHandlerSlot = class {
+  target;
+  _handler;
+  /**
+  * @param target Original object.
+  * @param _handler Handles intercepted operations.
+  */
+  constructor(target, _handler) {
+    this.target = target;
+    this._handler = _handler;
   }
-  return a.localeCompare(b);
-};
-var sortByLabel = (a, b) => compare(getLabel(a), getLabel(b));
-var sortByTypename = (a, b) => compare(getTypename(a), getTypename(b));
-var sort = (...comparators) => {
-  return (a, b) => {
-    for (const comparator of comparators) {
-      const result = comparator(a, b);
-      if (result !== 0) {
-        return result;
+  get handler() {
+    invariant4(this._handler, void 0, {
+      F: __dxlog_file4,
+      L: 91,
+      S: this,
+      A: [
+        "this._handler",
+        ""
+      ]
+    });
+    return this._handler;
+  }
+  // TODO(burdon): Requires comment.
+  setHandler(handler) {
+    this._handler = handler;
+  }
+  /**
+  * Get value.
+  */
+  get(target, prop, receiver) {
+    if (prop === symbolIsProxy) {
+      return this;
+    }
+    if (!this._handler || !this._handler.get) {
+      return Reflect.get(target, prop, receiver);
+    }
+    return this._handler.get(target, prop, receiver);
+  }
+  static {
+    const TRAPS = [
+      "apply",
+      "construct",
+      "defineProperty",
+      "deleteProperty",
+      "get",
+      "getOwnPropertyDescriptor",
+      "getPrototypeOf",
+      "has",
+      "isExtensible",
+      "ownKeys",
+      "preventExtensions",
+      "set",
+      "setPrototypeOf"
+    ];
+    for (const trap of TRAPS) {
+      if (trap === "get") {
+        continue;
       }
+      Object.defineProperty(this.prototype, trap, {
+        enumerable: false,
+        value: function(...args) {
+          if (!this._handler || !this._handler[trap]) {
+            return Reflect[trap](...args);
+          }
+          return this._handler[trap].apply(this._handler, args);
+        }
+      });
     }
-    return 0;
-  };
+  }
 };
 
-// src/internal/api/version.ts
-import { assertArgument as assertArgument4 } from "@dxos/invariant";
-var unversioned = {
-  [VersionTypeId]: {},
-  versioned: false
-};
-var isVersion = (entity) => {
-  return entity != null && typeof entity === "object" && VersionTypeId in entity;
+// src/internal/common/proxy/typed-handler.ts
+import * as Schema4 from "effect/Schema";
+import * as SchemaAST3 from "effect/SchemaAST";
+import { Event } from "@dxos/async";
+import { inspectCustom } from "@dxos/debug";
+import { invariant as invariant7 } from "@dxos/invariant";
+
+// src/internal/common/proxy/ownership.ts
+import { invariant as invariant5 } from "@dxos/invariant";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/ownership.ts";
+var EchoOwner = /* @__PURE__ */ Symbol.for("@dxos/echo/Owner");
+var getRawTarget = (value2) => {
+  return isProxy(value2) ? getProxyTarget(value2) : value2;
 };
-var version = (entity) => {
-  const ver = entity[ObjectVersionId];
-  if (ver === void 0) {
-    return unversioned;
-  }
-  return ver;
+var getOwner = (value2) => {
+  return value2?.[EchoOwner];
 };
-var versionValid = (ver) => {
-  assertArgument4(isVersion(ver), "version", "Invalid version object");
-  return !!ver.versioned;
+var setMetaOwner = (metaTarget, parent) => {
+  defineHiddenProperty(metaTarget, EchoOwner, parent);
 };
-var compareVersions = (version1, version2) => {
-  assertArgument4(isVersion(version1), "version1", "Invalid version object");
-  assertArgument4(isVersion(version2), "version2", "Invalid version object");
-  if (!versionValid(version1) || !versionValid(version2)) {
-    return "unversioned";
+var setOwnerRecursive = (value2, owner, options = {}) => {
+  const { visited = /* @__PURE__ */ new Set(), depth = 0, allowedPreviousOwner } = options;
+  if (value2 == null || typeof value2 !== "object") {
+    return;
   }
-  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
-    return "different";
+  const actualValue = getRawTarget(value2);
+  if (visited.has(actualValue)) {
+    return;
   }
-  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
-    return "different";
+  visited.add(actualValue);
+  const existingOwner = getOwner(actualValue);
+  const isRootEchoObject = EventId in actualValue;
+  let newAllowedPreviousOwner = allowedPreviousOwner;
+  if (isRootEchoObject && depth === 0) {
+    newAllowedPreviousOwner = actualValue;
   }
-  return "equal";
-};
-var encodeVersion = (ver) => {
-  return JSON.stringify(ver);
-};
-var decodeVersion = (ver) => {
-  const parsed = JSON.parse(ver);
-  parsed[VersionTypeId] = {};
-  return parsed;
-};
-
-// src/internal/json-schema/annotations.ts
-import * as SchemaAST4 from "effect/SchemaAST";
-var CustomAnnotations = {
-  format: FormatAnnotationId,
-  currency: CurrencyAnnotationId
-};
-var DecodedAnnotations = {
-  title: SchemaAST4.TitleAnnotationId,
-  description: SchemaAST4.DescriptionAnnotationId
-};
-var EchoAnnotations = {
-  // TODO(dmaretskyi): `FieldLookupAnnotationId` might go here, but lets remove it entirely and use LabelAnnotation instead.
-  meta: PropertyMetaAnnotationId,
-  generator: GeneratorAnnotationId,
-  labelProp: LabelAnnotationId
-};
-
-// src/internal/json-schema/json-schema-type.ts
-import * as Schema7 from "effect/Schema";
-import { JsonPath } from "@dxos/effect";
-var SimpleTypes = Schema7.Literal("array", "boolean", "integer", "null", "number", "object", "string");
-var NonNegativeInteger = Schema7.Number.pipe(Schema7.greaterThanOrEqualTo(0));
-var StringArray = Schema7.Array(Schema7.String);
-var JsonSchemaOrBoolean = Schema7.Union(Schema7.suspend(() => JsonSchemaType), Schema7.Boolean);
-var JsonSchemaEchoAnnotations = Schema7.Struct({
-  /**
-  * Label for this schema.
-  * Mapped from {@link LabelAnnotationId}.
-  */
-  labelProp: Schema7.optional(Schema7.Union(JsonPath, Schema7.Array(JsonPath))),
-  /**
-  * Generator function for this schema.
-  * Mapped from {@link GeneratorAnnotationId}.
-  */
-  generator: Schema7.optional(Schema7.Union(Schema7.String, Schema7.Tuple(Schema7.String, Schema7.Number))),
-  /**
-  * {@link PropertyMeta} annotations get serialized here.
-  */
-  meta: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.Any
-  })),
-  /**
-  * @deprecated
-  */
-  // TODO(dmaretskyi): We risk old schema not passing validation due to the extra fields. Remove when we are sure this is safe.
-  type: Schema7.optional(Schema7.Struct({
-    typename: Schema7.String,
-    version: Schema7.String,
-    // Not used.
-    schemaId: Schema7.optional(Schema7.String)
-  })),
-  /**
-  * @deprecated Superseded by `meta`.
-  */
-  annotations: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.Any
-  }))
-});
-var _JsonSchemaType = Schema7.Struct({
-  /**
-  * Identifier for this schema.
-  * This schema might be referenced by $ref clause in other schemas.
-  */
-  // TODO(dmaretskyi): Specify how the ids are generated.
-  // TODO(dmaretskyi): For type dxns, should this include the version?
-  $id: Schema7.optional(Schema7.String),
-  /**
-  * Schema of this schema.
-  * Set to "https://json-schema.org/draft-07/schema".
-  */
-  $schema: Schema7.optional(Schema7.String),
-  /**
-  * Reference to another schema.
-  */
-  $ref: Schema7.optional(Schema7.String),
-  /**
-  * Comments are ignored when interpreting the schema.
-  */
-  $comment: Schema7.optional(Schema7.String),
-  /**
-  * Defines whether this schema is an object schema or a relation schema.
-  */
-  entityKind: Schema7.optional(EntityKindSchema),
-  /**
-  * Typename of this schema.
-  * Only on schema representing an ECHO object.
-  *
-  * @example 'example.com/type/MyType'
-  */
-  typename: Schema7.optional(Schema7.String),
-  /**
-  * Version of this schema.
-  * Custom dialect for ECHO.
-  */
-  version: Schema7.optional(Schema7.String),
-  /**
-  * Target of this relation.
-  * Only for relation schemas.
-  * The referenced schema must be an object schema.
-  */
-  relationTarget: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  /**
-  * Source of this relation.
-  * Only for relation schemas.
-  * The referenced schema must be an object schema.
-  */
-  relationSource: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  /**
-  * Title of this schema.
-  */
-  title: Schema7.optional(Schema7.String),
-  /**
-  * Description of this schema.
-  */
-  description: Schema7.optional(Schema7.String),
-  /**
-  * Whether this schema is read-only.
-  */
-  readOnly: Schema7.optional(Schema7.Boolean),
-  /**
-  * Whether this schema is write-only.
-  */
-  writeOnly: Schema7.optional(Schema7.Boolean),
-  /**
-  * Examples of instances of this schema.
-  */
-  examples: Schema7.optional(Schema7.Array(Schema7.Any)),
-  /**
-  * Default value for this schema.
-  */
-  default: Schema7.optional(Schema7.Any),
-  /**
-  * This schema only matches values that are equal to this value.
-  */
-  const: Schema7.optional(Schema7.Any),
-  /**
-  * This schema only matches one of the values in this array.
-  */
-  enum: Schema7.optional(Schema7.Array(Schema7.Any)),
-  /**
-  * Base type of the schema.
-  */
-  type: Schema7.optional(Schema7.Union(SimpleTypes, Schema7.Array(SimpleTypes))),
-  //
-  // Numbers.
-  //
-  multipleOf: Schema7.optional(Schema7.Number.pipe(Schema7.greaterThan(0))),
-  maximum: Schema7.optional(Schema7.Number),
-  exclusiveMaximum: Schema7.optional(Schema7.Number),
-  minimum: Schema7.optional(Schema7.Number),
-  exclusiveMinimum: Schema7.optional(Schema7.Number),
-  //
-  // Strings.
-  //
-  maxLength: Schema7.optional(NonNegativeInteger),
-  /**
-  * Regex pattern for strings.
-  */
-  pattern: Schema7.optional(Schema7.String.pipe(FormatAnnotation.set(TypeFormat.Regex))),
-  /**
-  * Serialized from {@link FormatAnnotationId}.
-  */
-  format: Schema7.optional(Schema7.String),
-  //
-  // Arrays
-  //
-  minLength: Schema7.optional(NonNegativeInteger),
-  items: Schema7.optional(Schema7.Union(Schema7.suspend(() => JsonSchemaType), Schema7.Array(Schema7.suspend(() => JsonSchemaType)))),
-  additionalItems: Schema7.optional(Schema7.Union(Schema7.suspend(() => JsonSchemaType), Schema7.Boolean)),
-  maxItems: Schema7.optional(NonNegativeInteger),
-  minItems: Schema7.optional(NonNegativeInteger),
-  uniqueItems: Schema7.optional(Schema7.Boolean),
-  contains: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  //
-  // Objects
-  //
-  maxProperties: Schema7.optional(NonNegativeInteger),
-  minProperties: Schema7.optional(NonNegativeInteger),
-  required: Schema7.optional(StringArray),
-  /**
-  * Non-standard JSON Schema extension.
-  * Defines the order of properties in the object.
-  * The unmentioned properties are placed at the end.
-  *
-  * Related: https://github.com/json-schema/json-schema/issues/119
-  */
-  propertyOrder: Schema7.optional(StringArray),
-  additionalProperties: Schema7.optional(JsonSchemaOrBoolean),
-  properties: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.suspend(() => JsonSchemaType)
-  })),
-  patternProperties: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.suspend(() => JsonSchemaType)
-  })),
-  propertyNames: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  definitions: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.suspend(() => JsonSchemaType)
-  })),
-  dependencies: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.suspend(() => Schema7.Union(Schema7.String, StringArray, JsonSchemaType)).annotations({
-      identifier: "dependency",
-      description: "Dependency"
-    })
-  })),
-  contentMediaType: Schema7.optional(Schema7.String),
-  contentEncoding: Schema7.optional(Schema7.String),
-  if: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  then: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  else: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  allOf: Schema7.optional(Schema7.Array(Schema7.suspend(() => JsonSchemaType))),
-  anyOf: Schema7.optional(Schema7.Array(Schema7.suspend(() => JsonSchemaType))),
-  oneOf: Schema7.optional(Schema7.Array(Schema7.suspend(() => JsonSchemaType))),
-  not: Schema7.optional(Schema7.suspend(() => JsonSchemaType)),
-  $defs: Schema7.optional(Schema7.Record({
-    key: Schema7.String,
-    value: Schema7.suspend(() => JsonSchemaType)
-  })),
-  //
-  // ECHO extensions.
-  //
-  currency: Schema7.optional(Schema7.String),
-  reference: Schema7.optional(Schema7.Struct({
-    schema: Schema7.suspend(() => JsonSchemaType),
-    schemaVersion: Schema7.optional(Schema7.String),
-    schemaObject: Schema7.optional(Schema7.String)
-  })),
-  /**
-  * ECHO-specific annotations.
-  */
-  // TODO(dmaretskyi): Since we are adding a lot of new extensions to the JSON Schema, it is safer to namespace them here.
-  annotations: Schema7.optional(JsonSchemaEchoAnnotations),
-  /**
-  * @deprecated Use `annotations` instead.
-  */
-  echo: Schema7.optional(JsonSchemaEchoAnnotations)
-}).annotations({
-  identifier: "jsonSchema",
-  description: "JSON Schema"
-});
-var JsonSchemaFields = Object.keys(_JsonSchemaType.fields);
-var JsonSchemaType = _JsonSchemaType;
-var getSchemaProperty = (schema, property) => {
-  return schema.properties?.[property];
-};
-var setSchemaProperty = (schema, property, value2) => {
-  schema.properties ??= {};
-  schema.properties[property] = value2;
-  return schema;
-};
-var ECHO_ANNOTATIONS_NS_DEPRECATED_KEY = "echo";
-var ECHO_ANNOTATIONS_NS_KEY = "annotations";
-var getNormalizedEchoAnnotations = (obj) => {
-  if (obj[ECHO_ANNOTATIONS_NS_KEY] != null && obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {
-    return normalizeEchoAnnotations({
-      ...obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY],
-      ...obj[ECHO_ANNOTATIONS_NS_KEY]
+  if (!isRootEchoObject) {
+    const ownershipAllowed = existingOwner == null || existingOwner === owner || existingOwner === newAllowedPreviousOwner;
+    invariant5(ownershipAllowed, "Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.", {
+      F: __dxlog_file5,
+      L: 102,
+      S: void 0,
+      A: [
+        "ownershipAllowed",
+        "'Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.'"
+      ]
     });
-  } else if (obj[ECHO_ANNOTATIONS_NS_KEY] != null) {
-    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_KEY]);
-  } else if (obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {
-    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY]);
-  } else {
-    return void 0;
   }
-};
-var normalizeEchoAnnotations = (obj) => {
-  if (!obj.annotations) {
-    return obj;
+  defineHiddenProperty(actualValue, EchoOwner, owner);
+  const recursiveOptions = {
+    visited,
+    depth: depth + 1,
+    allowedPreviousOwner: newAllowedPreviousOwner
+  };
+  if (Array.isArray(actualValue)) {
+    for (const item of actualValue) {
+      if (isValidProxyTarget(item) || isProxy(item)) {
+        setOwnerRecursive(item, owner, recursiveOptions);
+      }
+    }
   } else {
-    const res = {
-      ...obj,
-      meta: {
-        ...obj.annotations,
-        ...obj.meta ?? {}
+    for (const key in actualValue) {
+      if (Object.prototype.hasOwnProperty.call(actualValue, key)) {
+        const nested = actualValue[key];
+        if (isValidProxyTarget(nested) || isProxy(nested)) {
+          setOwnerRecursive(nested, owner, recursiveOptions);
+        }
       }
-    };
-    delete res.annotations;
-    return res;
+    }
   }
 };
-
-// src/internal/json-schema/json-schema-normalize.ts
-var normalizeSchema = (schema) => {
-  const copy = structuredClone(schema);
-  go(copy);
-  return copy;
-};
-var go = (schema) => {
-  if (typeof schema !== "object" || schema === null) {
-    return;
+var traverseObjectGraph = (value2, visitor, visited = /* @__PURE__ */ new Set()) => {
+  if (value2 == null || typeof value2 !== "object") {
+    return false;
   }
-  if (schema.exclusiveMaximum === true) {
-    schema.exclusiveMaximum = schema.maximum;
-    delete schema.exclusiveMaximum;
-  } else if (schema.exclusiveMaximum === false) {
-    delete schema.exclusiveMaximum;
+  const actualValue = getRawTarget(value2);
+  if (visited.has(actualValue)) {
+    return false;
   }
-  if (schema.exclusiveMinimum === true) {
-    schema.exclusiveMinimum = schema.minimum;
-    delete schema.exclusiveMinimum;
-  } else if (schema.exclusiveMinimum === false) {
-    delete schema.exclusiveMinimum;
+  visited.add(actualValue);
+  if (visitor(actualValue)) {
+    return true;
   }
-  for (const key of Object.keys(schema)) {
-    if (!JsonSchemaFields.includes(key)) {
-      delete schema[key];
+  if (Array.isArray(actualValue)) {
+    for (const item of actualValue) {
+      if (traverseObjectGraph(item, visitor, visited)) {
+        return true;
+      }
+    }
+  } else {
+    for (const key in actualValue) {
+      if (Object.prototype.hasOwnProperty.call(actualValue, key)) {
+        if (traverseObjectGraph(actualValue[key], visitor, visited)) {
+          return true;
+        }
+      }
     }
   }
-  if (schema.properties) {
-    goOnRecord(schema.properties);
-  }
-  if (schema.patternProperties) {
-    goOnRecord(schema.patternProperties);
-  }
-  if (schema.propertyNames) {
-    go(schema.propertyNames);
-  }
-  if (schema.definitions) {
-    goOnRecord(schema.definitions);
-  }
-  if (schema.items) {
-    maybeGoOnArray(schema.items);
-  }
-  if (schema.additionalItems) {
-    maybeGoOnArray(schema.additionalItems);
-  }
-  if (schema.contains) {
-    go(schema.contains);
-  }
-  if (schema.if) {
-    go(schema.if);
-  }
-  if (schema.then) {
-    go(schema.then);
-  }
-  if (schema.else) {
-    go(schema.else);
-  }
-  if (schema.allOf) {
-    maybeGoOnArray(schema.allOf);
-  }
-  if (schema.anyOf) {
-    maybeGoOnArray(schema.anyOf);
-  }
-  if (schema.oneOf) {
-    maybeGoOnArray(schema.oneOf);
-  }
-  if (schema.not) {
-    go(schema.not);
+  return false;
+};
+var wouldCreateCycle = (targetRoot, value2) => traverseObjectGraph(value2, (v) => v === targetRoot);
+var hasForeignOwner = (value2, target) => traverseObjectGraph(value2, (v) => {
+  const owner = getOwner(v);
+  if (owner != null && owner !== target) {
+    return true;
   }
-  if (schema.$defs) {
-    goOnRecord(schema.$defs);
+  if (EventId in v && v !== target) {
+    return true;
   }
-  if (schema.reference) {
-    go(schema.reference.schema);
+  return false;
+});
+var MAX_OWNER_DEPTH = 100;
+var getEchoRoot = (target, depth = 0) => {
+  invariant5(depth < MAX_OWNER_DEPTH, "Owner chain too deep - possible circular ownership", {
+    F: __dxlog_file5,
+    L: 221,
+    S: void 0,
+    A: [
+      "depth < MAX_OWNER_DEPTH",
+      "'Owner chain too deep - possible circular ownership'"
+    ]
+  });
+  if (KindId in target) {
+    return target;
   }
-};
-var maybeGoOnArray = (value2) => {
-  if (Array.isArray(value2)) {
-    for (const item of value2) {
-      go(item);
-    }
-  } else if (typeof value2 === "object" && value2 !== null) {
-    go(value2);
+  const owner = getOwner(target);
+  if (owner) {
+    return getEchoRoot(owner, depth + 1);
   }
+  return target;
 };
-var goOnRecord = (record) => {
-  for (const key of Object.keys(record)) {
-    go(record[key]);
+var notifyOwnerChain = (target) => {
+  const owner = getOwner(target);
+  if (owner) {
+    queueOwnerNotification(getEchoRoot(owner));
+    notifyOwnerChain(owner);
   }
 };
 
-// src/internal/json-schema/json-schema.ts
-import * as Array4 from "effect/Array";
-import * as Function from "effect/Function";
-import * as JSONSchema from "effect/JSONSchema";
-import * as Option2 from "effect/Option";
-import * as Schema9 from "effect/Schema";
-import * as SchemaAST6 from "effect/SchemaAST";
-import { raise as raise2 } from "@dxos/debug";
-import { mapAst } from "@dxos/effect";
-import { assertArgument as assertArgument6, invariant as invariant9 } from "@dxos/invariant";
-import { DXN as DXN5, ObjectId as ObjectId4 } from "@dxos/keys";
-import { log } from "@dxos/log";
-import { clearUndefined, orderKeys, removeProperties } from "@dxos/util";
+// src/internal/common/proxy/proxy-types.ts
+var objectData = /* @__PURE__ */ Symbol.for("@dxos/live-object/objectData");
 
-// src/internal/ref/ref.ts
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as ParseResult from "effect/ParseResult";
-import * as Schema8 from "effect/Schema";
-import * as SchemaAST5 from "effect/SchemaAST";
-import { Event } from "@dxos/async";
-import { inspectCustom } from "@dxos/debug";
-import { EncodedReference } from "@dxos/echo-protocol";
-import { assertArgument as assertArgument5, invariant as invariant8 } from "@dxos/invariant";
-import { DXN as DXN4, ObjectId as ObjectId3 } from "@dxos/keys";
-var __dxlog_file8 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/ref/ref.ts";
-var JSON_SCHEMA_ECHO_REF_ID = "/schemas/echo/ref";
-var getSchemaReference = (property) => {
-  const { $id, reference: { schema: { $ref } = {} } = {} } = property;
-  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {
-    return {
-      typename: DXN4.parse($ref).typename
-    };
-  }
-};
-var createSchemaReference = (typename) => {
-  return {
-    $id: JSON_SCHEMA_ECHO_REF_ID,
-    reference: {
-      schema: {
-        $ref: DXN4.fromTypename(typename).toString()
-      }
-    }
-  };
-};
-var getReferenceAst = (ast) => {
-  if (ast._tag !== "Declaration" || !ast.annotations[ReferenceAnnotationId]) {
-    return void 0;
-  }
-  return {
-    typename: ast.annotations[ReferenceAnnotationId].typename,
-    version: ast.annotations[ReferenceAnnotationId].version
-  };
-};
-var RefTypeId = Symbol("@dxos/echo/internal/Ref");
-var Ref = (schema) => {
-  assertArgument5(Schema8.isSchema(schema), "schema", "Must call with an instance of effect-schema");
-  const annotation = getTypeAnnotation(schema);
-  if (annotation == null) {
-    throw new Error("Reference target must be an ECHO schema.");
+// src/internal/common/proxy/reactive-array.ts
+var checkArrayMutationAllowed = (arr, method) => {
+  const target = isProxy(arr) ? getProxyTarget(arr) : arr;
+  const echoRoot = getEchoRoot(target);
+  const isInitialized = echoRoot[ChangeId] === true || EventId in echoRoot;
+  if (!isInitialized) {
+    return;
   }
-  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);
-};
-Ref.isRef = (obj) => {
-  return obj && typeof obj === "object" && RefTypeId in obj;
-};
-Ref.hasObjectId = (id) => (ref) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;
-Ref.isRefSchema = (schema) => {
-  return Ref.isRefSchemaAST(schema.ast);
-};
-Ref.isRefSchemaAST = (ast) => {
-  return SchemaAST5.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);
-};
-Ref.make = (obj) => {
-  if (typeof obj !== "object" || obj === null) {
-    throw new TypeError("Expected: ECHO object.");
+  if (!isInChangeContext(echoRoot)) {
+    throw createArrayMethodError(method);
   }
-  const id = obj.id;
-  invariant8(ObjectId3.isValid(id), "Invalid object ID", {
-    F: __dxlog_file8,
-    L: 222,
-    S: void 0,
-    A: [
-      "ObjectId.isValid(id)",
-      "'Invalid object ID'"
-    ]
-  });
-  const dxn = DXN4.fromLocalObjectId(id);
-  return new RefImpl(dxn, obj);
 };
-Ref.fromDXN = (dxn) => {
-  assertArgument5(dxn instanceof DXN4, "dxn", "Expected DXN");
-  return new RefImpl(dxn);
-};
-var createEchoReferenceSchema = (echoId, typename, version2) => {
-  if (!echoId && !typename) {
-    throw new TypeError("Either echoId or typename must be provided.");
+var ReactiveArray = class extends Array {
+  static get [Symbol.species]() {
+    return Array;
   }
-  const referenceInfo = {
-    schema: {
-      // TODO(dmaretskyi): Include version?
-      $ref: echoId ?? DXN4.fromTypename(typename).toString()
-    },
-    schemaVersion: version2
-  };
-  const refSchema = Schema8.declare([], {
-    encode: () => {
-      return (value2) => Effect.gen(function* () {
-        if (Ref.isRef(value2)) {
-          return EncodedReference.fromDXN(value2.dxn);
-        } else if (EncodedReference.isEncodedReference(value2)) {
-          return value2;
-        }
-        throw new Error("Invalid reference");
-      });
-    },
-    decode: () => {
-      return (value2) => Effect.gen(function* () {
-        const dbService = yield* Effect.serviceOption(Service);
-        if (Ref.isRef(value2)) {
-          if (Option.isSome(dbService)) {
-            return dbService.value.db.makeRef(value2.dxn);
-          } else {
-            return value2;
-          }
-        }
-        if (!EncodedReference.isEncodedReference(value2)) {
-          return yield* Effect.fail(new ParseResult.Unexpected(value2, "reference"));
-        }
-        if (Option.isSome(dbService)) {
-          return dbService.value.db.makeRef(EncodedReference.toDXN(value2));
-        } else {
-          return Ref.fromDXN(EncodedReference.toDXN(value2));
+  static {
+    const BATCHED_METHODS = [
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "splice",
+      "sort",
+      "reverse"
+    ];
+    for (const method of BATCHED_METHODS) {
+      Object.defineProperty(this.prototype, method, {
+        enumerable: false,
+        value: function(...args) {
+          checkArrayMutationAllowed(this, method);
+          let result;
+          batchEvents(() => {
+            result = Array.prototype[method].apply(this, args);
+          });
+          return result;
         }
       });
     }
-  }, {
-    jsonSchema: {
-      // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.
-      $id: JSON_SCHEMA_ECHO_REF_ID,
-      $ref: JSON_SCHEMA_ECHO_REF_ID,
-      reference: referenceInfo
-    },
-    [ReferenceAnnotationId]: {
-      typename: typename ?? "",
-      version: version2
-    }
-  });
-  return refSchema;
-};
-var RefImpl = class _RefImpl {
-  #dxn;
-  #resolver = void 0;
-  #resolved = new Event();
-  /**
-  * Target is set when the reference is created from a specific object.
-  * In this case, the target might not be in the database.
-  */
-  #target = void 0;
-  /**
-  * Callback to issue a reactive notification when object is resolved.
-  */
-  #resolverCallback = () => {
-    this.#resolved.emit();
-  };
-  constructor(dxn, target) {
-    this.#dxn = dxn;
-    this.#target = target;
   }
+};
+
+// src/internal/common/proxy/schema-validator.ts
+import * as Schema3 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+import { invariant as invariant6 } from "@dxos/invariant";
+import { log } from "@dxos/log";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/schema-validator.ts";
+var SchemaValidator = class {
   /**
-  * @inheritdoc
+  * Recursively check that schema specifies constructions we can handle.
+  * Validates there are no ambiguous discriminated union types.
   */
-  get dxn() {
-    return this.#dxn;
+  static validateSchema(schema) {
+    const visitAll = (nodes) => nodes.forEach((node) => this.validateSchema(Schema3.make(node)));
+    if (SchemaAST2.isUnion(schema.ast)) {
+      const typeAstList = schema.ast.types.filter((type) => SchemaAST2.isTypeLiteral(type));
+      if (typeAstList.length > 1) {
+        getTypeDiscriminators(typeAstList);
+      }
+      visitAll(typeAstList);
+    } else if (SchemaAST2.isTupleType(schema.ast)) {
+      const positionalTypes = schema.ast.elements.map((t) => t.type);
+      const allTypes = positionalTypes.concat(schema.ast.rest.map((t) => t.type));
+      visitAll(allTypes);
+    } else if (SchemaAST2.isTypeLiteral(schema.ast)) {
+      visitAll(SchemaAST2.getPropertySignatures(schema.ast).map((p) => p.type));
+    }
   }
-  /**
-  * @inheritdoc
-  */
-  get isAvailable() {
-    return this.#target !== void 0 || this.#resolver !== void 0;
+  static hasTypeAnnotation(rootObjectSchema, property, annotation) {
+    try {
+      let type = this.getPropertySchema(rootObjectSchema, [
+        property
+      ]);
+      if (SchemaAST2.isTupleType(type.ast)) {
+        type = this.getPropertySchema(rootObjectSchema, [
+          property,
+          "0"
+        ]);
+      }
+      return type.ast.annotations[annotation] != null;
+    } catch {
+      return false;
+    }
   }
-  /**
-  * @inheritdoc
-  */
-  get target() {
-    if (this.#target) {
-      return this.#target;
+  static getPropertySchema(rootObjectSchema, propertyPath, getProperty = () => null) {
+    let schema = rootObjectSchema;
+    for (let i = 0; i < propertyPath.length; i++) {
+      const propertyName = propertyPath[i];
+      const tupleAst = unwrapArray(schema.ast);
+      if (tupleAst != null) {
+        schema = getArrayElementSchema(tupleAst, propertyName);
+      } else {
+        const propertyType = getPropertyType(schema.ast, propertyName.toString(), (propertyName2) => getProperty([
+          ...propertyPath.slice(0, i),
+          propertyName2
+        ]));
+        if (propertyType == null) {
+          log.warn("unknown property", {
+            path: propertyPath,
+            property: propertyName
+          }, {
+            F: __dxlog_file6,
+            L: 71,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          continue;
+        }
+        schema = Schema3.make(propertyType).annotations(propertyType.annotations);
+      }
     }
-    invariant8(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file8,
-      L: 390,
+    return schema;
+  }
+  static getTargetPropertySchema(target, prop) {
+    const schema = target[SchemaId];
+    invariant6(schema, "target has no schema", {
+      F: __dxlog_file6,
+      L: 84,
       S: this,
       A: [
-        "this.#resolver",
-        "'Resolver is not set'"
+        "schema",
+        "'target has no schema'"
       ]
     });
-    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback);
-  }
-  /**
-  * @inheritdoc
-  */
-  async load() {
-    if (this.#target) {
-      return this.#target;
+    const arrayAst = unwrapArray(schema.ast);
+    if (arrayAst != null) {
+      return getArrayElementSchema(arrayAst, prop);
     }
-    invariant8(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file8,
-      L: 401,
+    const propertyType = getPropertyType(schema.ast, prop.toString(), (prop2) => target[prop2]);
+    if (propertyType == null) {
+      return Schema3.Any;
+    }
+    invariant6(propertyType, `invalid property: ${prop.toString()}`, {
+      F: __dxlog_file6,
+      L: 95,
       S: this,
       A: [
-        "this.#resolver",
-        "'Resolver is not set'"
+        "propertyType",
+        "`invalid property: ${prop.toString()}`"
       ]
     });
-    const obj = await this.#resolver.resolve(this.#dxn);
-    if (obj == null) {
-      throw new Error("Object not found");
-    }
-    return obj;
+    return Schema3.make(propertyType);
   }
-  /**
-  * @inheritdoc
-  */
-  async tryLoad() {
-    if (this.#target) {
-      return this.#target;
-    }
-    invariant8(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file8,
-      L: 416,
-      S: this,
+};
+var getArrayElementSchema = (tupleAst, property) => {
+  const elementIndex = typeof property === "string" ? parseInt(property, 10) : Number.NaN;
+  if (Number.isNaN(elementIndex)) {
+    invariant6(property === "length", `invalid array property: ${String(property)}`, {
+      F: __dxlog_file6,
+      L: 111,
+      S: void 0,
       A: [
-        "this.#resolver",
-        "'Resolver is not set'"
+        "property === 'length'",
+        "`invalid array property: ${String(property)}`"
       ]
     });
-    return await this.#resolver.resolve(this.#dxn);
-  }
-  /**
-  * Do not inline the target object in the reference.
-  * Makes .target unavailable unless the reference is connected to a database context.
-  * Clones the reference object.
-  */
-  noInline() {
-    const ref = new _RefImpl(this.#dxn, void 0);
-    ref.#resolver = this.#resolver;
-    return ref;
-  }
-  encode() {
-    return {
-      "/": this.#dxn.toString(),
-      ...this.#target ? {
-        target: this.#target
-      } : {}
-    };
-  }
-  /**
-  * Serializes the reference to a JSON object.
-  * The serialization format is compatible with the IPLD-style encoded references.
-  * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),
-  * the target is included in the serialized object.
-  */
-  toJSON() {
-    return this.encode();
+    return Schema3.Number;
   }
-  toString() {
-    if (this.#target) {
-      return `Ref(${this.#target.toString()})`;
-    }
-    return `Ref(${this.#dxn.toString()})`;
+  if (elementIndex < tupleAst.elements.length) {
+    const elementType = tupleAst.elements[elementIndex].type;
+    return Schema3.make(elementType).annotations(elementType.annotations);
   }
-  [inspectCustom] = (depth, options, inspect) => {
-    return this.toString();
-  };
-  [RefTypeId] = refVariance;
-  /**
-  * Internal method to set the resolver.
-  *
-  * @internal
-  */
-  _setResolver(resolver) {
-    this.#resolver = resolver;
+  const restType = tupleAst.rest;
+  return Schema3.make(restType[0].type).annotations(restType[0].annotations);
+};
+var flattenUnion = (typeAst) => SchemaAST2.isUnion(typeAst) ? typeAst.types.flatMap(flattenUnion) : [
+  typeAst
+];
+var getProperties = (typeAst, getTargetPropertyFn) => {
+  const astCandidates = flattenUnion(typeAst);
+  const typeAstList = astCandidates.filter((type) => SchemaAST2.isTypeLiteral(type));
+  if (typeAstList.length === 0) {
+    return [];
   }
-  /**
-  * @internal
-  */
-  _getSavedTarget() {
-    return this.#target;
+  if (typeAstList.length === 1) {
+    return SchemaAST2.getPropertySignatures(typeAstList[0]);
   }
-};
-var setRefResolver = (ref, resolver) => {
-  invariant8(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
-    F: __dxlog_file8,
-    L: 483,
-    S: void 0,
-    A: [
-      "ref instanceof RefImpl",
-      "'Ref is not an instance of RefImpl'"
-    ]
-  });
-  ref._setResolver(resolver);
-};
-var getRefSavedTarget = (ref) => {
-  invariant8(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
-    F: __dxlog_file8,
-    L: 491,
+  const typeDiscriminators = getTypeDiscriminators(typeAstList);
+  const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
+  const typeIndex = typeDiscriminators.findIndex((p) => targetPropertyValue === p.type.literal);
+  invariant6(typeIndex !== -1, "discriminator field not set on target", {
+    F: __dxlog_file6,
+    L: 142,
     S: void 0,
     A: [
-      "ref instanceof RefImpl",
-      "'Ref is not an instance of RefImpl'"
+      "typeIndex !== -1",
+      "'discriminator field not set on target'"
     ]
   });
-  return ref._getSavedTarget();
-};
-var refVariance = {
-  _T: null
-};
-var refFromEncodedReference = (encodedReference, resolver) => {
-  const dxn = DXN4.parse(encodedReference["/"]);
-  const ref = new RefImpl(dxn);
-  if (resolver) {
-    setRefResolver(ref, resolver);
-  }
-  return ref;
-};
-var StaticRefResolver = class {
-  objects = /* @__PURE__ */ new Map();
-  schemas = /* @__PURE__ */ new Map();
-  addObject(obj) {
-    this.objects.set(obj.id, obj);
-    return this;
-  }
-  addSchema(schema) {
-    const dxn = getSchemaDXN(schema);
-    invariant8(dxn, "Schema has no DXN", {
-      F: __dxlog_file8,
-      L: 523,
-      S: this,
-      A: [
-        "dxn",
-        "'Schema has no DXN'"
-      ]
-    });
-    this.schemas.set(dxn.toString(), schema);
-    return this;
-  }
-  resolveSync(dxn, _load, _onLoad) {
-    const id = dxn?.asEchoDXN()?.echoId;
-    if (id == null) {
-      return void 0;
-    }
-    return this.objects.get(id);
-  }
-  async resolve(dxn) {
-    const id = dxn?.asEchoDXN()?.echoId;
-    if (id == null) {
-      return void 0;
-    }
-    return this.objects.get(id);
-  }
-  async resolveSchema(dxn) {
-    return this.schemas.get(dxn.toString());
-  }
+  return SchemaAST2.getPropertySignatures(typeAstList[typeIndex]);
 };
-
-// src/internal/ref/ref-array.ts
-import { isNonNullable } from "@dxos/util";
-var RefArray = Object.freeze({
-  /**
-  * @returns all resolved targets.
-  */
-  targets: (refs) => {
-    return refs.map((ref) => ref.target).filter(isNonNullable);
-  },
-  /**
-  * Load all referenced objects.
-  */
-  loadAll: (refs) => {
-    return Promise.all(refs.map((ref) => ref.load()));
-  },
-  /**
-  * Removes the ref with the given id.
-  */
-  removeById: (refs, id) => {
-    const index = refs.findIndex(Ref.hasObjectId(id));
-    if (index >= 0) {
-      refs.splice(index, 1);
-    }
-  }
-});
-
-// src/internal/json-schema/json-schema.ts
-var __dxlog_file9 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/json-schema/json-schema.ts";
-var PropType = /* @__PURE__ */ (function(PropType2) {
-  PropType2[PropType2["NONE"] = 0] = "NONE";
-  PropType2[PropType2["STRING"] = 1] = "STRING";
-  PropType2[PropType2["NUMBER"] = 2] = "NUMBER";
-  PropType2[PropType2["BOOLEAN"] = 3] = "BOOLEAN";
-  PropType2[PropType2["DATE"] = 4] = "DATE";
-  PropType2[PropType2["REF"] = 5] = "REF";
-  PropType2[PropType2["RECORD"] = 6] = "RECORD";
-  PropType2[PropType2["ENUM"] = 7] = "ENUM";
-  return PropType2;
-})({});
-var toPropType = (type) => {
-  switch (type) {
-    case 1:
-      return "string";
-    case 2:
-      return "number";
-    case 3:
-      return "boolean";
-    case 4:
-      return "date";
-    case 5:
-      return "ref";
-    case 6:
-      return "object";
-    default:
-      throw new Error(`Invalid type: ${type}`);
-  }
-};
-var JSON_SCHEMA_URL = "http://json-schema.org/draft-07/schema#";
-var toJsonSchema = (schema, options = {}) => {
-  assertArgument6(Schema9.isSchema(schema), "schema");
-  let jsonSchema = _toJsonSchemaAST(schema.ast);
-  if (options.strict) {
-    jsonSchema = removeProperties(jsonSchema, (key, value2) => {
-      if (key === "$id" && value2 === "/schemas/any") {
-        return true;
-      }
-      if (key === "$ref" && value2 === "#/$defs/dependency") {
-        return true;
-      }
-      if (key === "$ref" && value2 === "#/$defs/jsonSchema") {
-        return true;
-      }
-      return false;
-    });
+var getPropertyType = (ast, propertyName, getTargetPropertyFn) => {
+  const anyOrObject = unwrapAst(ast, (candidate) => SchemaAST2.isAnyKeyword(candidate) || SchemaAST2.isObjectKeyword(candidate));
+  if (anyOrObject != null) {
+    return ast;
   }
-  return jsonSchema;
-};
-var _toJsonSchemaAST = (ast) => {
-  const withRefinements = withEchoRefinements(ast, "#");
-  const jsonSchema = JSONSchema.fromAST(withRefinements, {
-    definitions: {}
+  const typeOrDiscriminatedUnion = unwrapAst(ast, (t) => {
+    return SchemaAST2.isTypeLiteral(t) || SchemaAST2.isUnion(t) && t.types.some((t2) => SchemaAST2.isTypeLiteral(t2));
   });
-  return normalizeJsonSchema(jsonSchema);
-};
-var withEchoRefinements = (ast, path, suspendCache = /* @__PURE__ */ new Map()) => {
-  if (path) {
-    suspendCache.set(ast, path);
-  }
-  let recursiveResult;
-  if (SchemaAST6.isSuspend(ast)) {
-    const suspendedAst = ast.f();
-    const cachedPath = suspendCache.get(suspendedAst);
-    if (cachedPath) {
-      recursiveResult = new SchemaAST6.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
-        [SchemaAST6.JSONSchemaAnnotationId]: {
-          $ref: cachedPath
-        }
-      });
-    } else {
-      const jsonSchema = _toJsonSchemaAST(suspendedAst);
-      recursiveResult = new SchemaAST6.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
-        [SchemaAST6.JSONSchemaAnnotationId]: jsonSchema
-      });
-    }
-  } else if (SchemaAST6.isTypeLiteral(ast)) {
-    recursiveResult = mapAst(ast, (ast2, key) => withEchoRefinements(ast2, path && typeof key === "string" ? `${path}/${key}` : void 0, suspendCache));
-    recursiveResult = addJsonSchemaFields(recursiveResult, {
-      propertyOrder: [
-        ...ast.propertySignatures.map((p) => p.name)
-      ]
-    });
-  } else if (SchemaAST6.isUndefinedKeyword(ast)) {
-    return ast;
-  } else {
-    recursiveResult = mapAst(ast, (ast2, key) => withEchoRefinements(ast2, path && (typeof key === "string" || typeof key === "number") ? `${path}/${key}` : void 0, suspendCache));
+  if (typeOrDiscriminatedUnion == null) {
+    return null;
   }
-  const annotationFields = annotations_toJsonSchemaFields(ast.annotations);
-  if (Object.keys(annotationFields).length === 0) {
-    return recursiveResult;
-  } else {
-    return addJsonSchemaFields(recursiveResult, annotationFields);
-  }
-};
-var toEffectSchema = (root, _defs) => {
-  const defs = root.$defs ? {
-    ..._defs,
-    ...root.$defs
-  } : _defs ?? {};
-  if ("type" in root && root.type === "object") {
-    return objectToEffectSchema(root, defs);
-  }
-  let result = Schema9.Unknown;
-  if ("$ref" in root) {
-    switch (root.$ref) {
-      case "/schemas/echo/ref": {
-        result = refToEffectSchema(root);
-        break;
-      }
-    }
-  } else if ("$id" in root) {
-    switch (root.$id) {
-      case "/schemas/any": {
-        result = anyToEffectSchema(root);
-        break;
-      }
-      case "/schemas/unknown": {
-        result = Schema9.Unknown;
-        break;
-      }
-      case "/schemas/{}":
-      case "/schemas/object": {
-        result = Schema9.Object;
-        break;
-      }
-      // Custom ECHO object reference.
-      case "/schemas/echo/ref": {
-        result = refToEffectSchema(root);
-        break;
-      }
-    }
-  } else if ("enum" in root) {
-    result = Schema9.Union(...root.enum.map((e) => Schema9.Literal(e)));
-  } else if ("oneOf" in root) {
-    result = Schema9.Union(...root.oneOf.map((v) => toEffectSchema(v, defs)));
-  } else if ("anyOf" in root) {
-    result = Schema9.Union(...root.anyOf.map((v) => toEffectSchema(v, defs)));
-  } else if ("allOf" in root) {
-    if (root.allOf.length === 1) {
-      result = toEffectSchema(root.allOf[0], defs);
-    } else {
-      log.warn("allOf with multiple schemas is not supported", void 0, {
-        F: __dxlog_file9,
-        L: 224,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      result = Schema9.Unknown;
-    }
-  } else if ("type" in root) {
-    switch (root.type) {
-      case "string": {
-        result = Schema9.String;
-        if (root.pattern) {
-          result = result.pipe(Schema9.pattern(new RegExp(root.pattern)));
-        }
-        break;
-      }
-      case "number": {
-        result = Schema9.Number;
-        break;
-      }
-      case "integer": {
-        result = Schema9.Number.pipe(Schema9.int());
-        break;
-      }
-      case "boolean": {
-        result = Schema9.Boolean;
-        break;
-      }
-      case "array": {
-        if (Array4.isArray(root.items)) {
-          const [required, optional5] = Function.pipe(root.items, Array4.map((v) => toEffectSchema(v, defs)), Array4.splitAt(root.minItems ?? root.items.length));
-          result = Schema9.Tuple(...required, ...optional5.map(Schema9.optionalElement));
-        } else {
-          invariant9(root.items, void 0, {
-            F: __dxlog_file9,
-            L: 257,
-            S: void 0,
-            A: [
-              "root.items",
-              ""
-            ]
-          });
-          const items = root.items;
-          result = Array4.isArray(items) ? Schema9.Tuple(...items.map((v) => toEffectSchema(v, defs))) : Schema9.Array(toEffectSchema(items, defs));
-        }
-        break;
-      }
-      case "null": {
-        result = Schema9.Null;
-        break;
-      }
-    }
-  } else if ("$ref" in root) {
-    const refSegments = root.$ref.split("/");
-    const jsonSchema = defs[refSegments[refSegments.length - 1]];
-    invariant9(jsonSchema, `missing definition for ${root.$ref}`, {
-      F: __dxlog_file9,
-      L: 273,
-      S: void 0,
-      A: [
-        "jsonSchema",
-        "`missing definition for ${root.$ref}`"
-      ]
-    });
-    result = toEffectSchema(jsonSchema, defs).pipe(Schema9.annotations({
-      identifier: refSegments[refSegments.length - 1]
-    }));
+  const targetProperty = getProperties(typeOrDiscriminatedUnion, getTargetPropertyFn).find((p) => p.name === propertyName);
+  if (targetProperty != null) {
+    return unwrapAst(targetProperty.type);
   }
-  const annotations4 = jsonSchemaFieldsToAnnotations(root);
-  result = result.annotations(annotations4);
-  return result;
+  const indexSignatureType = unwrapAst(ast, SchemaAST2.isTypeLiteral);
+  if (indexSignatureType && SchemaAST2.isTypeLiteral(indexSignatureType) && indexSignatureType.indexSignatures.length > 0) {
+    return unwrapAst(indexSignatureType.indexSignatures[0].type);
+  }
+  return null;
 };
-var objectToEffectSchema = (root, defs) => {
-  invariant9("type" in root && root.type === "object", `not an object: ${root}`, {
-    F: __dxlog_file9,
-    L: 288,
+var getTypeDiscriminators = (typeAstList) => {
+  const discriminatorPropCandidates = typeAstList.flatMap(SchemaAST2.getPropertySignatures).filter((p) => SchemaAST2.isLiteral(p.type));
+  const propertyName = discriminatorPropCandidates[0].name;
+  const isValidDiscriminator = discriminatorPropCandidates.every((p) => p.name === propertyName && !p.isOptional);
+  const everyTypeHasDiscriminator = discriminatorPropCandidates.length === typeAstList.length;
+  const isDiscriminatedUnion = isValidDiscriminator && everyTypeHasDiscriminator;
+  invariant6(isDiscriminatedUnion, "type ambiguity: every type in a union must have a single unique-literal field", {
+    F: __dxlog_file6,
+    L: 193,
     S: void 0,
     A: [
-      "'type' in root && root.type === 'object'",
-      "`not an object: ${root}`"
+      "isDiscriminatedUnion",
+      "'type ambiguity: every type in a union must have a single unique-literal field'"
     ]
   });
-  const echoRefinement = root[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
-  const isEchoObject = echoRefinement != null || "$id" in root && typeof root.$id === "string" && root.$id.startsWith("dxn:");
-  let fields = {};
-  const propertyList = Object.entries(root.properties ?? {});
-  let immutableIdField;
-  for (const [key, value2] of propertyList) {
-    if (isEchoObject && key === "id") {
-      immutableIdField = toEffectSchema(value2, defs);
-    } else {
-      fields[key] = root.required?.includes(key) ? toEffectSchema(value2, defs) : Schema9.optional(toEffectSchema(value2, defs));
+  return discriminatorPropCandidates;
+};
+var unwrapAst = (rootAst, predicate) => {
+  let ast = rootAst;
+  while (ast != null) {
+    if (predicate?.(ast)) {
+      return ast;
     }
-  }
-  if (root.propertyOrder) {
-    fields = orderKeys(fields, root.propertyOrder);
-  }
-  let schema;
-  if (root.patternProperties) {
-    invariant9(propertyList.length === 0, "pattern properties mixed with regular properties are not supported", {
-      F: __dxlog_file9,
-      L: 314,
-      S: void 0,
-      A: [
-        "propertyList.length === 0",
-        "'pattern properties mixed with regular properties are not supported'"
-      ]
-    });
-    invariant9(Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === "", "only one pattern property is supported", {
-      F: __dxlog_file9,
-      L: 315,
-      S: void 0,
-      A: [
-        "Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === ''",
-        "'only one pattern property is supported'"
-      ]
-    });
-    schema = Schema9.Record({
-      key: Schema9.String,
-      value: toEffectSchema(root.patternProperties[""], defs)
-    });
-  } else if (typeof root.additionalProperties !== "object") {
-    schema = Schema9.Struct(fields);
-  } else {
-    const indexValue = toEffectSchema(root.additionalProperties, defs);
-    if (propertyList.length > 0) {
-      schema = Schema9.Struct(fields, {
-        key: Schema9.String,
-        value: indexValue
-      });
+    if (SchemaAST2.isUnion(ast)) {
+      const next = ast.types.find((t) => predicate != null && predicate(t) || SchemaAST2.isSuspend(t));
+      if (next != null) {
+        ast = next;
+        continue;
+      }
+    }
+    if (SchemaAST2.isSuspend(ast)) {
+      ast = ast.f();
     } else {
-      schema = Schema9.Record({
-        key: Schema9.String,
-        value: indexValue
-      });
+      return predicate == null ? ast : null;
     }
   }
-  if (immutableIdField) {
-    schema = Schema9.extend(schema, Schema9.Struct({
-      id: immutableIdField
-    }));
-  }
-  const annotations4 = jsonSchemaFieldsToAnnotations(root);
-  return schema.annotations(annotations4);
-};
-var anyToEffectSchema = (root) => {
-  const echoRefinement = root[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
-  if (echoRefinement?.reference != null) {
-    const echoId = root.$id.startsWith("dxn:echo:") ? root.$id : void 0;
-    return createEchoReferenceSchema(echoId, echoRefinement.reference.typename, echoRefinement.reference.version);
-  }
-  return Schema9.Any;
+  return null;
 };
-var refToEffectSchema = (root) => {
-  if (!("reference" in root)) {
-    return createEchoReferenceSchema(void 0, ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION);
-  }
-  const reference = root.reference;
-  if (typeof reference !== "object") {
-    throw new Error("Invalid reference field in ref schema");
-  }
-  const targetSchemaDXN = DXN5.parse(reference.schema.$ref);
-  invariant9(targetSchemaDXN.kind === DXN5.kind.TYPE, void 0, {
-    F: __dxlog_file9,
-    L: 368,
+var unwrapArray = (ast) => unwrapAst(ast, SchemaAST2.isTupleType);
+var checkIdNotPresentOnSchema = (schema) => {
+  invariant6(SchemaAST2.isTypeLiteral(schema.ast), void 0, {
+    F: __dxlog_file6,
+    L: 236,
     S: void 0,
     A: [
-      "targetSchemaDXN.kind === DXN.kind.TYPE",
+      "SchemaAST.isTypeLiteral(schema.ast)",
       ""
     ]
   });
-  return createEchoReferenceSchema(targetSchemaDXN.toString(), targetSchemaDXN.kind === DXN5.kind.TYPE ? targetSchemaDXN.parts[0] : void 0, reference.schemaVersion);
-};
-var annotations_toJsonSchemaFields = (annotations4) => {
-  const schemaFields = {};
-  const echoAnnotations = {};
-  for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
-    if (annotations4[annotationId] != null) {
-      echoAnnotations[key] = annotations4[annotationId];
-    }
+  const idProperty = SchemaAST2.getPropertySignatures(schema.ast).find((prop) => prop.name === "id");
+  if (idProperty != null) {
+    throw new Error('"id" property name is reserved');
   }
-  if (Object.keys(echoAnnotations).length > 0) {
-    schemaFields[ECHO_ANNOTATIONS_NS_KEY] = echoAnnotations;
+};
+
+// src/internal/common/proxy/typed-handler.ts
+var __dxlog_file7 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/typed-handler.ts";
+var deepCopy = (value2, visited = /* @__PURE__ */ new Map()) => {
+  if (value2 == null || typeof value2 !== "object") {
+    return value2;
   }
-  const echoIdentifier = annotations4[TypeIdentifierAnnotationId];
-  if (echoIdentifier) {
-    schemaFields[ECHO_ANNOTATIONS_NS_KEY] ??= {};
-    schemaFields[ECHO_ANNOTATIONS_NS_KEY].schemaId = echoIdentifier;
+  const actualValue = getRawTarget(value2);
+  if (visited.has(actualValue)) {
+    return visited.get(actualValue);
   }
-  for (const [key, annotationId] of Object.entries(CustomAnnotations)) {
-    const value2 = annotations4[annotationId];
-    if (value2 != null) {
-      schemaFields[key] = value2;
+  if (actualValue instanceof ReactiveArray) {
+    const copy2 = new ReactiveArray();
+    visited.set(actualValue, copy2);
+    for (const item of actualValue) {
+      copy2.push(deepCopy(item, visited));
     }
+    copyHiddenProperties(actualValue, copy2);
+    return copy2;
   }
-  return schemaFields;
-};
-var decodeTypeIdentifierAnnotation = (schema) => {
-  if (schema.$id && schema.$id.startsWith("dxn:echo:")) {
-    return schema.$id;
-  } else if (schema.$id && schema.$id.startsWith("dxn:type:") && schema?.echo?.type?.schemaId) {
-    const id = schema?.echo?.type?.schemaId;
-    if (ObjectId4.isValid(id)) {
-      return DXN5.fromLocalObjectId(id).toString();
-    }
+  const proto = Object.getPrototypeOf(actualValue);
+  if (proto !== Object.prototype && proto !== Array.prototype && proto !== null) {
+    return value2;
   }
-  return void 0;
-};
-var decodeTypeAnnotation = (schema) => {
-  if (schema.typename) {
-    const annotation = {
-      // TODO(dmaretskyi): Decoding default.
-      kind: schema.entityKind ? Schema9.decodeSync(EntityKindSchema)(schema.entityKind) : EntityKind.Object,
-      typename: schema.typename,
-      version: schema.version ?? "0.1.0"
-    };
-    if (annotation.kind === EntityKind.Relation) {
-      const source = schema.relationSource?.$ref ?? raise2(new Error("Relation source not set"));
-      const target = schema.relationTarget?.$ref ?? raise2(new Error("Relation target not set"));
-      annotation.sourceSchema = DXN5.parse(source).toString();
-      annotation.targetSchema = DXN5.parse(target).toString();
+  if (Array.isArray(actualValue)) {
+    const copy2 = new ReactiveArray();
+    visited.set(actualValue, copy2);
+    for (const item of actualValue) {
+      copy2.push(deepCopy(item, visited));
     }
-    return annotation;
+    return copy2;
   }
-  if (!schema.typename && schema?.echo?.type) {
-    return {
-      kind: EntityKind.Object,
-      typename: schema.echo.type.typename,
-      version: schema.echo.type.version
-    };
+  const copy = {};
+  visited.set(actualValue, copy);
+  for (const key of Object.keys(actualValue)) {
+    copy[key] = deepCopy(actualValue[key], visited);
   }
-  return void 0;
+  copyHiddenProperties(actualValue, copy);
+  return copy;
 };
-var jsonSchemaFieldsToAnnotations = (schema) => {
-  const annotations4 = {};
-  const echoAnnotations = getNormalizedEchoAnnotations(schema) ?? {};
-  if (echoAnnotations) {
-    for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
-      if (echoAnnotations[key]) {
-        annotations4[annotationId] = echoAnnotations[key];
-      }
-    }
+var copyHiddenProperties = (source, target) => {
+  if (SchemaId in source) {
+    defineHiddenProperty(target, SchemaId, source[SchemaId]);
   }
-  annotations4[TypeIdentifierAnnotationId] = decodeTypeIdentifierAnnotation(schema);
-  const typeAnnotation = decodeTypeAnnotation(schema);
-  if (typeAnnotation) {
-    annotations4[TypeAnnotationId] = typeAnnotation;
-    annotations4[SchemaAST6.JSONSchemaAnnotationId] = makeTypeJsonSchemaAnnotation({
-      kind: typeAnnotation.kind,
-      typename: typeAnnotation.typename,
-      version: typeAnnotation.version,
-      relationSource: typeAnnotation.sourceSchema,
-      relationTarget: typeAnnotation.targetSchema
-    });
+  if (TypeId in source) {
+    defineHiddenProperty(target, TypeId, source[TypeId]);
   }
-  for (const [key, annotationId] of Object.entries({
-    ...CustomAnnotations,
-    ...DecodedAnnotations
-  })) {
-    if (key in schema) {
-      annotations4[annotationId] = schema[key];
-    }
-  }
-  return clearUndefined(annotations4);
-};
-var makeAnnotatedRefinement = (ast, annotations4) => {
-  return new SchemaAST6.Refinement(ast, () => Option2.none(), annotations4);
-};
-var addJsonSchemaFields = (ast, schema) => makeAnnotatedRefinement(ast, {
-  [SchemaAST6.JSONSchemaAnnotationId]: schema
-});
-var normalizeJsonSchema = (jsonSchema) => {
-  if (jsonSchema.properties && "id" in jsonSchema.properties) {
-    jsonSchema.properties = orderKeys(jsonSchema.properties, [
-      "id"
-    ]);
-  }
-  jsonSchema.$schema = JSON_SCHEMA_URL;
-  jsonSchema = orderKeys(jsonSchema, [
-    "$schema",
-    "$id",
-    "entityKind",
-    "typename",
-    "version",
-    "relationTarget",
-    "relationSource",
-    "type",
-    "enum",
-    "properties",
-    "required",
-    "propertyOrder",
-    "items",
-    "additionalProperties",
-    "anyOf",
-    "oneOf"
-  ]);
-  return jsonSchema;
-};
-
-// src/internal/object/common.ts
-import * as Schema10 from "effect/Schema";
-var makeTypedEntityClass = (typename, version2, baseSchema) => {
-  return class {
-    // Implement TypedObject properties.
-    static typename = typename;
-    static version = version2;
-    // Implement Schema.Schema properties.
-    // TODO(burdon): Comment required.
-    static [Schema10.TypeId] = schemaVariance;
-    static ast = baseSchema.ast;
-    static annotations = baseSchema.annotations.bind(baseSchema);
-    static pipe = baseSchema.pipe.bind(baseSchema);
-    // TODO(burdon): Comment required.
-    static [Symbol.hasInstance](obj) {
-      return obj != null && getTypename(obj) === typename;
-    }
-    // TODO(burdon): Throw APIError.
-    constructor() {
-      throw new Error("Use live(Typename, { ...fields }) to instantiate an object.");
-    }
-  };
-};
-var schemaVariance = {
-  _A: (_) => _,
-  _I: (_) => _,
-  _R: (_) => _
-};
-
-// src/internal/object/create-object.ts
-import { raise as raise4 } from "@dxos/debug";
-import { assertArgument as assertArgument8, failedInvariant } from "@dxos/invariant";
-import { ObjectId as ObjectId7 } from "@dxos/keys";
-
-// src/internal/proxy/symbols.ts
-var EventId = Symbol.for("@dxos/live-object/EventId");
-var ChangeId = Symbol.for("@dxos/live-object/ChangeId");
-
-// src/internal/proxy/event-batch.ts
-var eventBatchDepth = 0;
-var pendingEventTargets = /* @__PURE__ */ new Set();
-var batchEvents = (callback) => {
-  eventBatchDepth++;
-  try {
-    callback();
-  } finally {
-    eventBatchDepth--;
-    if (eventBatchDepth === 0) {
-      for (const target of pendingEventTargets) {
-        target[EventId]?.emit();
-      }
-      pendingEventTargets.clear();
-    }
-  }
-};
-var emitEvent = (target) => {
-  if (eventBatchDepth > 0) {
-    pendingEventTargets.add(target);
-  } else {
-    target[EventId]?.emit();
-  }
-};
-
-// src/internal/proxy/change-context.ts
-var currentChangeContext = null;
-var pendingNotificationKey = null;
-var pendingOwnerNotifications = /* @__PURE__ */ new Set();
-var enterChangeContext = (key) => {
-  currentChangeContext = key;
-  return () => {
-    currentChangeContext = null;
-  };
 };
-var isInChangeContext = (key) => {
-  return currentChangeContext === key;
-};
-var queueNotification = (key) => {
-  if (currentChangeContext === key) {
-    pendingNotificationKey = key;
-  }
-};
-var queueOwnerNotification = (target) => {
-  if (currentChangeContext !== null && target !== currentChangeContext) {
-    pendingOwnerNotifications.add(target);
-  }
-};
-var hasPendingNotifications = (key) => {
-  return pendingNotificationKey === key;
-};
-var clearPendingNotifications = (key) => {
-  if (pendingNotificationKey === key) {
-    pendingNotificationKey = null;
-  }
-};
-var executeChange = (contextKey, eventTarget, proxy, callback) => {
-  const exitContext = enterChangeContext(contextKey);
-  try {
-    batchEvents(() => callback(proxy));
-  } finally {
-    exitContext();
-    if (hasPendingNotifications(contextKey)) {
-      clearPendingNotifications(contextKey);
-      eventTarget[EventId]?.emit();
-    }
-    for (const ownerTarget of pendingOwnerNotifications) {
-      ownerTarget[EventId]?.emit();
-    }
-    pendingOwnerNotifications.clear();
-  }
-};
-
-// src/internal/proxy/define-hidden-property.ts
-var defineHiddenProperty = (object, key, value2) => {
-  Object.defineProperty(object, key, {
-    enumerable: false,
-    configurable: true,
-    value: value2
-  });
-};
-
-// src/internal/proxy/errors.ts
-var MutationOutsideChangeContextError = class extends Error {
-  constructor(operation, suggestion) {
-    super(`Cannot ${operation} outside of Obj.change(). Use Obj.change(obj, (mutableObj) => { ${suggestion} }) instead.`);
-    this.name = "MutationOutsideChangeContextError";
-  }
-};
-var createPropertySetError = (prop) => {
-  return new MutationOutsideChangeContextError(`modify object property "${String(prop)}"`, `mutableObj.${String(prop)} = value;`);
-};
-var createPropertyDeleteError = (prop) => {
-  return new MutationOutsideChangeContextError(`delete object property "${String(prop)}"`, `delete mutableObj.${String(prop)};`);
-};
-var createArrayMethodError = (method) => {
-  return new MutationOutsideChangeContextError(`call array.${method}()`, `mutableObj.array.${method}(...);`);
-};
-
-// src/internal/proxy/json-serializer.ts
-import { invariant as invariant10 } from "@dxos/invariant";
-import { DXN as DXN6 } from "@dxos/keys";
-import { deepMapValues } from "@dxos/util";
-var __dxlog_file10 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/proxy/json-serializer.ts";
-var attachTypedJsonSerializer = (obj) => {
-  const descriptor = Object.getOwnPropertyDescriptor(obj, "toJSON");
-  if (descriptor) {
-    return;
-  }
-  Object.defineProperty(obj, "toJSON", {
-    value: typedJsonSerializer,
-    writable: false,
-    enumerable: false,
-    // Setting `configurable` to false breaks proxy invariants, should be fixable.
-    configurable: true
-  });
-};
-var typedJsonSerializer = function() {
-  const { id, ...rest } = this;
-  const result = {
-    id
-  };
-  if (this[TypeId]) {
-    result[ATTR_TYPE] = this[TypeId].toString();
-  }
-  if (this[MetaId]) {
-    result[ATTR_META] = serializeMeta(this[MetaId]);
-  }
-  if (this[SelfDXNId]) {
-    result[ATTR_SELF_DXN] = this[SelfDXNId].toString();
+var TypedReactiveHandler = class _TypedReactiveHandler {
+  static instance = new _TypedReactiveHandler();
+  _proxyMap = /* @__PURE__ */ new WeakMap();
+  _inSet = false;
+  constructor() {
   }
-  if (this[RelationSourceDXNId]) {
-    const sourceDXN = this[RelationSourceDXNId];
-    invariant10(sourceDXN instanceof DXN6, void 0, {
-      F: __dxlog_file10,
-      L: 61,
+  init(target) {
+    invariant7(typeof target === "object" && target !== null, void 0, {
+      F: __dxlog_file7,
+      L: 147,
       S: this,
       A: [
-        "sourceDXN instanceof DXN",
+        "typeof target === 'object' && target !== null",
         ""
       ]
     });
-    result[ATTR_RELATION_SOURCE] = sourceDXN.toString();
-  }
-  if (this[RelationTargetDXNId]) {
-    const targetDXN = this[RelationTargetDXNId];
-    invariant10(targetDXN instanceof DXN6, void 0, {
-      F: __dxlog_file10,
-      L: 66,
+    invariant7(SchemaId in target, "Schema is not defined for the target", {
+      F: __dxlog_file7,
+      L: 148,
       S: this,
       A: [
-        "targetDXN instanceof DXN",
-        ""
+        "SchemaId in target",
+        "'Schema is not defined for the target'"
       ]
     });
-    result[ATTR_RELATION_TARGET] = targetDXN.toString();
-  }
-  Object.assign(result, serializeData(rest));
-  return result;
-};
-var serializeData = (data) => {
-  return deepMapValues(data, (value2, recurse) => {
-    if (Ref.isRef(value2)) {
-      return value2.noInline().encode();
+    const hasOwner = !!getOwner(target);
+    if (!(EventId in target) && !hasOwner) {
+      defineHiddenProperty(target, EventId, new Event());
     }
-    return recurse(value2);
-  });
-};
-var serializeMeta = (meta) => {
-  return deepMapValues(meta, (value2, recurse) => recurse(value2));
-};
-
-// src/internal/proxy/make-object.ts
-import { ObjectId as ObjectId5 } from "@dxos/keys";
-
-// src/internal/proxy/proxy-utils.ts
-import { invariant as invariant11 } from "@dxos/invariant";
-var __dxlog_file11 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/proxy/proxy-utils.ts";
-var symbolIsProxy = Symbol.for("@dxos/schema/Proxy");
-var isProxy = (value2) => !!value2?.[symbolIsProxy];
-var isValidProxyTarget = (value2) => {
-  if (value2 == null || value2[symbolIsProxy]) {
-    return false;
-  }
-  if (Array.isArray(value2)) {
-    return true;
-  }
-  return typeof value2 === "object" && Object.getPrototypeOf(value2) === Object.prototype;
-};
-var getProxySlot = (proxy) => {
-  const value2 = proxy[symbolIsProxy];
-  invariant11(value2 instanceof ProxyHandlerSlot, void 0, {
-    F: __dxlog_file11,
-    L: 32,
-    S: void 0,
-    A: [
-      "value instanceof ProxyHandlerSlot",
-      ""
-    ]
-  });
-  return value2;
-};
-var getProxyTarget = (proxy) => {
-  return getProxySlot(proxy).target;
-};
-var getProxyHandler = (proxy) => {
-  return getProxySlot(proxy).handler;
-};
-var dangerouslySetProxyId = (obj, id) => {
-  getProxySlot(obj).target.id = id;
-};
-var createProxy = (target, handler) => {
-  const existingProxy = handler._proxyMap.get(target);
-  if (existingProxy) {
-    return existingProxy;
-  }
-  const proxy = new Proxy(target, new ProxyHandlerSlot(target, handler));
-  handler.init(target);
-  handler._proxyMap.set(target, proxy);
-  return proxy;
-};
-var ProxyHandlerSlot = class {
-  target;
-  _handler;
-  /**
-  * @param target Original object.
-  * @param _handler Handles intercepted operations.
-  */
-  constructor(target, _handler) {
-    this.target = target;
-    this._handler = _handler;
-  }
-  get handler() {
-    invariant11(this._handler, void 0, {
-      F: __dxlog_file11,
-      L: 91,
-      S: this,
-      A: [
-        "this._handler",
-        ""
-      ]
+    defineHiddenProperty(target, ObjectDeletedId, false);
+    if (!hasOwner && !(ChangeId in target)) {
+      defineHiddenProperty(target, ChangeId, true);
+    }
+    if (!hasOwner) {
+      for (const key in target) {
+        if (target[symbolIsProxy]) {
+          continue;
+        }
+        let value2 = target[key];
+        if (isValidProxyTarget(value2) || isProxy(value2)) {
+          if (hasForeignOwner(value2, target)) {
+            value2 = deepCopy(value2);
+            target[key] = value2;
+          }
+          setOwnerRecursive(value2, target);
+        }
+      }
+    }
+    Object.defineProperty(target, inspectCustom, {
+      enumerable: false,
+      configurable: true,
+      value: this._inspect.bind(target)
     });
-    return this._handler;
-  }
-  // TODO(burdon): Requires comment.
-  setHandler(handler) {
-    this._handler = handler;
   }
-  /**
-  * Get value.
-  */
   get(target, prop, receiver) {
-    if (prop === symbolIsProxy) {
-      return this;
+    switch (prop) {
+      // TODO(burdon): Remove?
+      case objectData: {
+        return toJSON(target);
+      }
+      case ChangeId: {
+        if (target[ChangeId] !== true) {
+          return void 0;
+        }
+        return (callback) => executeChange(target, target, receiver, callback);
+      }
     }
-    if (!this._handler || !this._handler.get) {
+    if (Object.getOwnPropertyDescriptor(target, prop)?.get) {
       return Reflect.get(target, prop, receiver);
     }
-    return this._handler.get(target, prop, receiver);
+    const value2 = Reflect.get(target, prop, receiver);
+    if (isValidProxyTarget(value2)) {
+      return createProxy(value2, this);
+    }
+    return value2;
   }
-  static {
-    const TRAPS = [
-      "apply",
-      "construct",
-      "defineProperty",
-      "deleteProperty",
-      "get",
-      "getOwnPropertyDescriptor",
-      "getPrototypeOf",
-      "has",
-      "isExtensible",
-      "ownKeys",
-      "preventExtensions",
-      "set",
-      "setPrototypeOf"
-    ];
-    for (const trap of TRAPS) {
-      if (trap === "get") {
-        continue;
-      }
-      Object.defineProperty(this.prototype, trap, {
-        enumerable: false,
-        value: function(...args) {
-          if (!this._handler || !this._handler[trap]) {
-            return Reflect[trap](...args);
-          }
-          return this._handler[trap].apply(this._handler, args);
+  set(target, prop, value2, receiver) {
+    const echoRoot = getEchoRoot(target);
+    const isInitialized = ChangeId in echoRoot || EventId in echoRoot;
+    const isSymbolProp = typeof prop === "symbol";
+    if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
+      throw new Error(`Cannot modify object property "${String(prop)}" outside of Obj.change(). Use Obj.change(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
+    }
+    let result = false;
+    this._inSet = true;
+    try {
+      batchEvents(() => {
+        const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, prop, value2);
+        result = Reflect.set(target, prop, preparedValue, receiver);
+        if (isInitialized) {
+          queueNotification(echoRoot);
+          notifyOwnerChain(target);
         }
       });
+    } finally {
+      this._inSet = false;
     }
+    return result;
   }
-};
-
-// src/internal/proxy/typed-handler.ts
-import * as Schema12 from "effect/Schema";
-import * as SchemaAST8 from "effect/SchemaAST";
-import { Event as Event2 } from "@dxos/async";
-import { inspectCustom as inspectCustom2 } from "@dxos/debug";
-import { invariant as invariant14 } from "@dxos/invariant";
-
-// src/internal/proxy/ownership.ts
-import { invariant as invariant12 } from "@dxos/invariant";
-var __dxlog_file12 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/proxy/ownership.ts";
-var EchoOwner = Symbol.for("@dxos/echo/Owner");
-var getRawTarget = (value2) => {
-  return isProxy(value2) ? getProxyTarget(value2) : value2;
-};
-var getOwner = (value2) => {
-  return value2?.[EchoOwner];
-};
-var setMetaOwner = (metaTarget, parent) => {
-  defineHiddenProperty(metaTarget, EchoOwner, parent);
-};
-var setOwnerRecursive = (value2, owner, options = {}) => {
-  const { visited = /* @__PURE__ */ new Set(), depth = 0, allowedPreviousOwner } = options;
-  if (value2 == null || typeof value2 !== "object") {
-    return;
-  }
-  const actualValue = getRawTarget(value2);
-  if (visited.has(actualValue)) {
-    return;
+  ownKeys(target) {
+    return Reflect.ownKeys(target);
   }
-  visited.add(actualValue);
-  const existingOwner = getOwner(actualValue);
-  const isRootEchoObject = EventId in actualValue;
-  let newAllowedPreviousOwner = allowedPreviousOwner;
-  if (isRootEchoObject && depth === 0) {
-    newAllowedPreviousOwner = actualValue;
+  deleteProperty(target, property) {
+    const echoRoot = getEchoRoot(target);
+    const isInitialized = echoRoot[ChangeId] === true || EventId in echoRoot;
+    const isSymbolProp = typeof property === "symbol";
+    if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
+      throw createPropertyDeleteError(property);
+    }
+    const result = Reflect.deleteProperty(target, property);
+    if (isInitialized) {
+      queueNotification(echoRoot);
+    }
+    return result;
   }
-  if (!isRootEchoObject) {
-    const ownershipAllowed = existingOwner == null || existingOwner === owner || existingOwner === newAllowedPreviousOwner;
-    invariant12(ownershipAllowed, "Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.", {
-      F: __dxlog_file12,
-      L: 102,
-      S: void 0,
-      A: [
-        "ownershipAllowed",
-        "'Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.'"
-      ]
+  defineProperty(target, property, attributes) {
+    const echoRoot = getEchoRoot(target);
+    const isInitialized = ChangeId in echoRoot || EventId in echoRoot;
+    const isSymbolProp = typeof property === "symbol";
+    if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
+      throw new Error(`Cannot modify object property "${String(property)}" outside of Obj.change(). Use Obj.change(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
+    }
+    const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, property, attributes.value);
+    const result = Reflect.defineProperty(target, property, {
+      ...attributes,
+      value: preparedValue
     });
+    if (!this._inSet && isInitialized) {
+      queueNotification(echoRoot);
+    }
+    return result;
   }
-  defineHiddenProperty(actualValue, EchoOwner, owner);
-  const recursiveOptions = {
-    visited,
-    depth: depth + 1,
-    allowedPreviousOwner: newAllowedPreviousOwner
-  };
-  if (Array.isArray(actualValue)) {
-    for (const item of actualValue) {
-      if (isValidProxyTarget(item) || isProxy(item)) {
-        setOwnerRecursive(item, owner, recursiveOptions);
+  /**
+  * Prepare a value for assignment to a typed object property.
+  * Handles cycle detection, copy-on-assign, array conversion, validation, and ownership.
+  */
+  _prepareValueForAssignment(target, prop, value2) {
+    const echoRoot = getEchoRoot(target);
+    if (prop === ParentId) {
+      return {
+        echoRoot,
+        preparedValue: value2
+      };
+    }
+    if (isValidProxyTarget(value2) || isProxy(value2)) {
+      if (wouldCreateCycle(echoRoot, value2)) {
+        throw new Error("Cannot create cycles in typed object graph. Consider using Ref for circular references.");
       }
     }
-  } else {
-    for (const key in actualValue) {
-      if (Object.prototype.hasOwnProperty.call(actualValue, key)) {
-        const nested = actualValue[key];
-        if (isValidProxyTarget(nested) || isProxy(nested)) {
-          setOwnerRecursive(nested, owner, recursiveOptions);
-        }
+    if (isValidProxyTarget(value2) || isProxy(value2)) {
+      const actualValue = getRawTarget(value2);
+      const isRootEchoObject = EventId in actualValue;
+      if (isRootEchoObject) {
+        throw new Error("Object references must be wrapped with `Ref.make`");
       }
     }
+    if (isValidProxyTarget(value2) || isProxy(value2)) {
+      const actualValue = getRawTarget(value2);
+      const existingOwner = getOwner(actualValue);
+      if (existingOwner != null && existingOwner !== echoRoot) {
+        value2 = deepCopy(value2);
+      }
+    }
+    if (Array.isArray(value2) && !(value2 instanceof ReactiveArray)) {
+      value2 = ReactiveArray.from(value2);
+    }
+    const validatedValue = this._validateValue(target, prop, value2);
+    if (isValidProxyTarget(validatedValue) || isProxy(validatedValue)) {
+      setOwnerRecursive(validatedValue, echoRoot);
+    }
+    return {
+      echoRoot,
+      preparedValue: validatedValue
+    };
   }
-};
-var traverseObjectGraph = (value2, visitor, visited = /* @__PURE__ */ new Set()) => {
-  if (value2 == null || typeof value2 !== "object") {
-    return false;
-  }
-  const actualValue = getRawTarget(value2);
-  if (visited.has(actualValue)) {
-    return false;
+  _validateValue(target, prop, value2) {
+    if (prop === ParentId) {
+      return value2;
+    }
+    const schema = SchemaValidator.getTargetPropertySchema(target, prop);
+    const _ = Schema4.asserts(schema)(value2);
+    if (isValidProxyTarget(value2)) {
+      setSchemaProperties(value2, schema);
+    }
+    return value2;
   }
-  visited.add(actualValue);
-  if (visitor(actualValue)) {
-    return true;
+  _inspect(_, options, inspectFn) {
+    const inspected = inspectFn(this, {
+      ...options,
+      showHidden: false,
+      customInspect: false
+    });
+    return `Typed ${inspected}`;
   }
-  if (Array.isArray(actualValue)) {
-    for (const item of actualValue) {
-      if (traverseObjectGraph(item, visitor, visited)) {
-        return true;
-      }
-    }
-  } else {
-    for (const key in actualValue) {
-      if (Object.prototype.hasOwnProperty.call(actualValue, key)) {
-        if (traverseObjectGraph(actualValue[key], visitor, visited)) {
-          return true;
-        }
+};
+var toJSON = (target) => {
+  return {
+    "@type": "TypedReactiveObject",
+    ...target
+  };
+};
+var setSchemaProperties = (obj, schema) => {
+  const schemaType = getSchemaDXN(schema);
+  if (schemaType != null) {
+    defineHiddenProperty(obj, TypeId, schemaType);
+  }
+  defineHiddenProperty(obj, SchemaId, schema);
+  for (const key in obj) {
+    if (isValidProxyTarget(obj[key])) {
+      const elementSchema = SchemaValidator.getTargetPropertySchema(obj, key);
+      if (elementSchema != null) {
+        setSchemaProperties(obj[key], elementSchema);
       }
     }
   }
-  return false;
 };
-var wouldCreateCycle = (targetRoot, value2) => traverseObjectGraph(value2, (v) => v === targetRoot);
-var hasForeignOwner = (value2, target) => traverseObjectGraph(value2, (v) => {
-  const owner = getOwner(v);
-  if (owner != null && owner !== target) {
-    return true;
-  }
-  if (EventId in v && v !== target) {
-    return true;
-  }
-  return false;
-});
-var MAX_OWNER_DEPTH = 100;
-var getEchoRoot = (target, depth = 0) => {
-  invariant12(depth < MAX_OWNER_DEPTH, "Owner chain too deep - possible circular ownership", {
-    F: __dxlog_file12,
-    L: 221,
-    S: void 0,
-    A: [
-      "depth < MAX_OWNER_DEPTH",
-      "'Owner chain too deep - possible circular ownership'"
-    ]
-  });
-  if (KindId in target) {
-    return target;
-  }
-  const owner = getOwner(target);
-  if (owner) {
-    return getEchoRoot(owner, depth + 1);
+var prepareTypedTarget = (target, schema) => {
+  if (!SchemaAST3.isTypeLiteral(schema.ast)) {
+    throw new Error("schema has to describe an object type");
   }
-  return target;
+  SchemaValidator.validateSchema(schema);
+  const _ = Schema4.asserts(schema)(target);
+  makeArraysReactive(target);
+  setSchemaProperties(target, schema);
 };
-var notifyOwnerChain = (target) => {
-  const owner = getOwner(target);
-  if (owner) {
-    queueOwnerNotification(getEchoRoot(owner));
-    notifyOwnerChain(owner);
+var makeArraysReactive = (target) => {
+  for (const key in target) {
+    if (target[symbolIsProxy]) {
+      continue;
+    }
+    if (Array.isArray(target[key])) {
+      target[key] = ReactiveArray.from(target[key]);
+    }
+    if (typeof target[key] === "object") {
+      makeArraysReactive(target[key]);
+    }
   }
 };
 
-// src/internal/proxy/proxy-types.ts
-var objectData = Symbol.for("@dxos/live-object/objectData");
-
-// src/internal/proxy/reactive-array.ts
-var checkArrayMutationAllowed = (arr, method) => {
-  const target = isProxy(arr) ? getProxyTarget(arr) : arr;
-  const echoRoot = getEchoRoot(target);
-  const isInitialized = echoRoot[ChangeId] === true || EventId in echoRoot;
-  if (!isInitialized) {
-    return;
+// src/internal/common/proxy/make-object.ts
+var makeObject = (schema, obj, meta) => {
+  return createReactiveObject(Object.assign({}, obj), meta, schema);
+};
+var createReactiveObject = (obj, meta, schema) => {
+  if (!isValidProxyTarget(obj)) {
+    throw new Error("Value cannot be made into a reactive object.");
   }
-  if (!isInChangeContext(echoRoot)) {
-    throw createArrayMethodError(method);
+  if (!schema) {
+    throw new Error("Schema is required for reactive objects. Use Atom for untyped reactive state.");
   }
-};
-var ReactiveArray = class extends Array {
-  static get [Symbol.species]() {
-    return Array;
+  const parent = obj[ParentId];
+  if (parent !== void 0) {
+    delete obj[ParentId];
   }
-  static {
-    const BATCHED_METHODS = [
-      "push",
-      "pop",
-      "shift",
-      "unshift",
-      "splice",
-      "sort",
-      "reverse"
-    ];
-    for (const method of BATCHED_METHODS) {
-      Object.defineProperty(this.prototype, method, {
-        enumerable: false,
-        value: function(...args) {
-          checkArrayMutationAllowed(this, method);
-          let result;
-          batchEvents(() => {
-            result = Array.prototype[method].apply(this, args);
-          });
-          return result;
-        }
-      });
+  const annotation = getTypeAnnotation(schema);
+  if (annotation) {
+    setIdOnTarget(obj);
+    defineHiddenProperty(obj, KindId, annotation.kind);
+  }
+  initMeta(obj, meta);
+  if (parent !== void 0) {
+    defineHiddenProperty(obj, ParentId, parent);
+  }
+  prepareTypedTarget(obj, schema);
+  attachTypedJsonSerializer(obj);
+  const proxy = createProxy(obj, TypedReactiveHandler.instance);
+  const metaProxy = obj[MetaId];
+  if (metaProxy) {
+    const metaTarget = getProxyTarget(metaProxy);
+    if (metaTarget) {
+      setMetaOwner(metaTarget, obj);
     }
   }
+  return proxy;
 };
-
-// src/internal/proxy/schema-validator.ts
-import * as Schema11 from "effect/Schema";
-import * as SchemaAST7 from "effect/SchemaAST";
-import { invariant as invariant13 } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file13 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/proxy/schema-validator.ts";
-var SchemaValidator = class {
-  /**
-  * Recursively check that schema specifies constructions we can handle.
-  * Validates there are no ambiguous discriminated union types.
-  */
-  static validateSchema(schema) {
-    const visitAll = (nodes) => nodes.forEach((node) => this.validateSchema(Schema11.make(node)));
-    if (SchemaAST7.isUnion(schema.ast)) {
-      const typeAstList = schema.ast.types.filter((type) => SchemaAST7.isTypeLiteral(type));
-      if (typeAstList.length > 1) {
-        getTypeDiscriminators(typeAstList);
-      }
-      visitAll(typeAstList);
-    } else if (SchemaAST7.isTupleType(schema.ast)) {
-      const positionalTypes = schema.ast.elements.map((t) => t.type);
-      const allTypes = positionalTypes.concat(schema.ast.rest.map((t) => t.type));
-      visitAll(allTypes);
-    } else if (SchemaAST7.isTypeLiteral(schema.ast)) {
-      visitAll(SchemaAST7.getPropertySignatures(schema.ast).map((p) => p.type));
+var setIdOnTarget = (target) => {
+  if ("id" in target && target.id !== void 0 && target.id !== null) {
+    if (!ObjectId.isValid(target.id)) {
+      throw new Error("Invalid object id format.");
     }
+  } else {
+    target.id = ObjectId.random();
   }
-  static hasTypeAnnotation(rootObjectSchema, property, annotation) {
-    try {
-      let type = this.getPropertySchema(rootObjectSchema, [
-        property
-      ]);
-      if (SchemaAST7.isTupleType(type.ast)) {
-        type = this.getPropertySchema(rootObjectSchema, [
-          property,
-          "0"
-        ]);
-      }
-      return type.ast.annotations[annotation] != null;
-    } catch {
-      return false;
-    }
+};
+var initMeta = (obj, meta = {
+  keys: []
+}) => {
+  prepareTypedTarget(meta, ObjectMetaSchema);
+  defineHiddenProperty(obj, MetaId, createProxy(meta, TypedReactiveHandler.instance));
+};
+
+// src/internal/common/proxy/reactive.ts
+var subscribe = (obj, callback) => {
+  const target = getProxyTarget(obj);
+  if (target && EventId in target) {
+    return target[EventId].on(callback);
   }
-  static getPropertySchema(rootObjectSchema, propertyPath, getProperty = () => null) {
-    let schema = rootObjectSchema;
-    for (let i = 0; i < propertyPath.length; i++) {
-      const propertyName = propertyPath[i];
-      const tupleAst = unwrapArray(schema.ast);
-      if (tupleAst != null) {
-        schema = getArrayElementSchema(tupleAst, propertyName);
-      } else {
-        const propertyType = getPropertyType(schema.ast, propertyName.toString(), (propertyName2) => getProperty([
-          ...propertyPath.slice(0, i),
-          propertyName2
-        ]));
-        if (propertyType == null) {
-          log2.warn("unknown property", {
-            path: propertyPath,
-            property: propertyName
-          }, {
-            F: __dxlog_file13,
-            L: 71,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          continue;
-        }
-        schema = Schema11.make(propertyType).annotations(propertyType.annotations);
-      }
-    }
-    return schema;
+  return () => {
+  };
+};
+var change = (obj, callback) => {
+  const changeFn = obj[ChangeId];
+  if (changeFn) {
+    changeFn(callback);
+  } else {
+    callback(obj);
   }
-  static getTargetPropertySchema(target, prop) {
-    const schema = target[SchemaId];
-    invariant13(schema, "target has no schema", {
-      F: __dxlog_file13,
-      L: 84,
+};
+
+// src/internal/Entity/api.ts
+import { invariant as invariant10 } from "@dxos/invariant";
+import { assumeType as assumeType3 } from "@dxos/util";
+
+// src/internal/Entity/model.ts
+import { invariant as invariant8 } from "@dxos/invariant";
+import { DXN as DXN2, ObjectId as ObjectId2 } from "@dxos/keys";
+import { assumeType } from "@dxos/util";
+var __dxlog_file8 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/model.ts";
+function assertObjectModel(obj) {
+  invariant8(typeof obj === "object" && obj !== null, "Invalid object model: not an object", {
+    F: __dxlog_file8,
+    L: 94,
+    S: this,
+    A: [
+      "typeof obj === 'object' && obj !== null",
+      "'Invalid object model: not an object'"
+    ]
+  });
+  assumeType(obj);
+  invariant8(ObjectId2.isValid(obj.id), "Invalid object model: invalid id", {
+    F: __dxlog_file8,
+    L: 96,
+    S: this,
+    A: [
+      "ObjectId.isValid(obj.id)",
+      "'Invalid object model: invalid id'"
+    ]
+  });
+  invariant8(obj[TypeId] === void 0 || obj[TypeId] instanceof DXN2, "Invalid object model: invalid type", {
+    F: __dxlog_file8,
+    L: 97,
+    S: this,
+    A: [
+      "obj[TypeId] === undefined || obj[TypeId] instanceof DXN",
+      "'Invalid object model: invalid type'"
+    ]
+  });
+  invariant8(obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation, "Invalid object model: invalid entity kind", {
+    F: __dxlog_file8,
+    L: 98,
+    S: this,
+    A: [
+      "obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation",
+      "'Invalid object model: invalid entity kind'"
+    ]
+  });
+  if (obj[KindId] === EntityKind.Relation) {
+    invariant8(obj[RelationSourceDXNId] instanceof DXN2, "Invalid object model: invalid relation source", {
+      F: __dxlog_file8,
+      L: 104,
+      S: this,
+      A: [
+        "obj[RelationSourceDXNId] instanceof DXN",
+        "'Invalid object model: invalid relation source'"
+      ]
+    });
+    invariant8(obj[RelationTargetDXNId] instanceof DXN2, "Invalid object model: invalid relation target", {
+      F: __dxlog_file8,
+      L: 105,
+      S: this,
+      A: [
+        "obj[RelationTargetDXNId] instanceof DXN",
+        "'Invalid object model: invalid relation target'"
+      ]
+    });
+    invariant8(!(obj[RelationSourceId] instanceof DXN2), "Invalid object model: source pointer is a DXN", {
+      F: __dxlog_file8,
+      L: 106,
       S: this,
       A: [
-        "schema",
-        "'target has no schema'"
+        "!(obj[RelationSourceId] instanceof DXN)",
+        "'Invalid object model: source pointer is a DXN'"
       ]
     });
-    const arrayAst = unwrapArray(schema.ast);
-    if (arrayAst != null) {
-      return getArrayElementSchema(arrayAst, prop);
-    }
-    const propertyType = getPropertyType(schema.ast, prop.toString(), (prop2) => target[prop2]);
-    if (propertyType == null) {
-      return Schema11.Any;
-    }
-    invariant13(propertyType, `invalid property: ${prop.toString()}`, {
-      F: __dxlog_file13,
-      L: 95,
+    invariant8(!(obj[RelationTargetId] instanceof DXN2), "Invalid object model: target pointer is a DXN", {
+      F: __dxlog_file8,
+      L: 107,
       S: this,
       A: [
-        "propertyType",
-        "`invalid property: ${prop.toString()}`"
+        "!(obj[RelationTargetId] instanceof DXN)",
+        "'Invalid object model: target pointer is a DXN'"
       ]
     });
-    return Schema11.make(propertyType);
   }
-};
-var getArrayElementSchema = (tupleAst, property) => {
-  const elementIndex = typeof property === "string" ? parseInt(property, 10) : Number.NaN;
-  if (Number.isNaN(elementIndex)) {
-    invariant13(property === "length", `invalid array property: ${String(property)}`, {
-      F: __dxlog_file13,
-      L: 111,
+}
+
+// src/internal/Entity/util.ts
+import * as Schema5 from "effect/Schema";
+import { assertArgument as assertArgument2, invariant as invariant9 } from "@dxos/invariant";
+import { DXN as DXN3, ObjectId as ObjectId3 } from "@dxos/keys";
+import { assumeType as assumeType2 } from "@dxos/util";
+var __dxlog_file9 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/util.ts";
+var getObjectDXN = (object) => {
+  invariant9(!Schema5.isSchema(object), "schema not allowed in this function", {
+    F: __dxlog_file9,
+    L: 19,
+    S: void 0,
+    A: [
+      "!Schema.isSchema(object)",
+      "'schema not allowed in this function'"
+    ]
+  });
+  assertArgument2(typeof object === "object" && object != null, "object", "expected object");
+  assumeType2(object);
+  if (object[SelfDXNId]) {
+    invariant9(object[SelfDXNId] instanceof DXN3, "Invalid object model: invalid self dxn", {
+      F: __dxlog_file9,
+      L: 24,
       S: void 0,
       A: [
-        "property === 'length'",
-        "`invalid array property: ${String(property)}`"
+        "object[SelfDXNId] instanceof DXN",
+        "'Invalid object model: invalid self dxn'"
       ]
     });
-    return Schema11.Number;
+    return object[SelfDXNId];
   }
-  if (elementIndex < tupleAst.elements.length) {
-    const elementType = tupleAst.elements[elementIndex].type;
-    return Schema11.make(elementType).annotations(elementType.annotations);
+  if (!ObjectId3.isValid(object.id)) {
+    throw new TypeError("Object id is not valid.");
   }
-  const restType = tupleAst.rest;
-  return Schema11.make(restType[0].type).annotations(restType[0].annotations);
+  return DXN3.fromLocalObjectId(object.id);
 };
-var flattenUnion = (typeAst) => SchemaAST7.isUnion(typeAst) ? typeAst.types.flatMap(flattenUnion) : [
-  typeAst
-];
-var getProperties = (typeAst, getTargetPropertyFn) => {
-  const astCandidates = flattenUnion(typeAst);
-  const typeAstList = astCandidates.filter((type) => SchemaAST7.isTypeLiteral(type));
-  if (typeAstList.length === 0) {
-    return [];
-  }
-  if (typeAstList.length === 1) {
-    return SchemaAST7.getPropertySignatures(typeAstList[0]);
-  }
-  const typeDiscriminators = getTypeDiscriminators(typeAstList);
-  const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
-  const typeIndex = typeDiscriminators.findIndex((p) => targetPropertyValue === p.type.literal);
-  invariant13(typeIndex !== -1, "discriminator field not set on target", {
-    F: __dxlog_file13,
-    L: 142,
+
+// src/internal/Entity/api.ts
+var __dxlog_file10 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/api.ts";
+var getDXN = (entity) => {
+  const dxn = getObjectDXN(entity);
+  invariant10(dxn != null, "Invalid entity.", {
+    F: __dxlog_file10,
+    L: 20,
     S: void 0,
     A: [
-      "typeIndex !== -1",
-      "'discriminator field not set on target'"
+      "dxn != null",
+      "'Invalid entity.'"
     ]
   });
-  return SchemaAST7.getPropertySignatures(typeAstList[typeIndex]);
+  return dxn;
 };
-var getPropertyType = (ast, propertyName, getTargetPropertyFn) => {
-  const anyOrObject = unwrapAst(ast, (candidate) => SchemaAST7.isAnyKeyword(candidate) || SchemaAST7.isObjectKeyword(candidate));
-  if (anyOrObject != null) {
-    return ast;
+var getDatabase = (entity) => {
+  assumeType3(entity);
+  return entity[ObjectDatabaseId];
+};
+
+// src/internal/Entity/entity.ts
+import * as Schema6 from "effect/Schema";
+var makeEchoTypeSchema = (fields, ast, typename, version2, kind) => {
+  return class EchoObjectSchemaClass extends Schema6.make(ast) {
+    static typename = typename;
+    static version = version2;
+    static [SchemaKindId] = kind;
+    static fields = fields;
+    static annotations(annotations3) {
+      const schema = Schema6.make(ast).annotations(annotations3);
+      return makeEchoTypeSchema(fields, schema.ast, typename, version2, kind);
+    }
+    // static make(
+    //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
+    //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
+    //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
+    //   options?: MakeProps,
+    // ): Simplify<Schema.TypeLiteral.Type<Fields, []>> {
+    //   const propsWithDefaults: any = _lazilyMergeDefaults(fields, { ...(props as any) });
+    //   return _getDisableValidationMakeOption(options)
+    //     ? propsWithDefaults
+    //     : ParseResult.validateSync(this)(propsWithDefaults);
+    // }
+    static instanceOf(value2) {
+      return Schema6.is(this)(value2);
+    }
+  };
+};
+
+// src/internal/Entity/object.ts
+import * as Schema7 from "effect/Schema";
+import * as SchemaAST4 from "effect/SchemaAST";
+import { invariant as invariant11 } from "@dxos/invariant";
+var __dxlog_file11 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/object.ts";
+var EchoObjectSchema = ({ typename, version: version2 }) => {
+  return (self) => {
+    invariant11(typeof TypeAnnotationId === "symbol", "Sanity.", {
+      F: __dxlog_file11,
+      L: 37,
+      S: void 0,
+      A: [
+        "typeof TypeAnnotationId === 'symbol'",
+        "'Sanity.'"
+      ]
+    });
+    invariant11(SchemaAST4.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+      F: __dxlog_file11,
+      L: 38,
+      S: void 0,
+      A: [
+        "SchemaAST.isTypeLiteral(self.ast)",
+        "'Schema must be a TypeLiteral.'"
+      ]
+    });
+    const fields = self.fields ?? {};
+    const schemaWithId = Schema7.extend(self, Schema7.Struct({
+      id: Schema7.String
+    }));
+    const ast = SchemaAST4.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Object,
+        typename,
+        version: version2
+      },
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST4.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version: version2
+      })
+    });
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Object);
+  };
+};
+
+// src/internal/Entity/relation.ts
+import * as Schema8 from "effect/Schema";
+import * as SchemaAST5 from "effect/SchemaAST";
+import { raise } from "@dxos/debug";
+import { assertArgument as assertArgument3, invariant as invariant12 } from "@dxos/invariant";
+import { DXN as DXN4 } from "@dxos/keys";
+var __dxlog_file12 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/relation.ts";
+var EchoRelationSchema = ({ source, target, typename, version: version2 }) => {
+  assertArgument3(Schema8.isSchema(source), "source");
+  assertArgument3(Schema8.isSchema(target), "target");
+  const sourceDXN = getDXNForRelationSchemaRef(source);
+  const targetDXN = getDXNForRelationSchemaRef(target);
+  if (getEntityKind(source) !== EntityKind.Object) {
+    raise(new Error("Source schema must be an echo object schema."));
   }
-  const typeOrDiscriminatedUnion = unwrapAst(ast, (t) => {
-    return SchemaAST7.isTypeLiteral(t) || SchemaAST7.isUnion(t) && t.types.some((t2) => SchemaAST7.isTypeLiteral(t2));
-  });
-  if (typeOrDiscriminatedUnion == null) {
-    return null;
+  if (getEntityKind(target) !== EntityKind.Object) {
+    raise(new Error("Target schema must be an echo object schema."));
   }
-  const targetProperty = getProperties(typeOrDiscriminatedUnion, getTargetPropertyFn).find((p) => p.name === propertyName);
-  if (targetProperty != null) {
-    return unwrapAst(targetProperty.type);
+  return (self) => {
+    invariant12(SchemaAST5.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+      F: __dxlog_file12,
+      L: 110,
+      S: void 0,
+      A: [
+        "SchemaAST.isTypeLiteral(self.ast)",
+        "'Schema must be a TypeLiteral.'"
+      ]
+    });
+    const fields = self.fields ?? {};
+    const schemaWithId = Schema8.extend(self, Schema8.Struct({
+      id: Schema8.String
+    }));
+    const ast = SchemaAST5.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Relation,
+        typename,
+        version: version2,
+        sourceSchema: sourceDXN,
+        targetSchema: targetDXN
+      },
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST5.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Relation,
+        typename,
+        version: version2,
+        relationSource: sourceDXN,
+        relationTarget: targetDXN
+      })
+    });
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Relation);
+  };
+};
+var getDXNForRelationSchemaRef = (schema) => {
+  assertArgument3(Schema8.isSchema(schema), "schema");
+  const identifier = getTypeIdentifierAnnotation(schema);
+  if (identifier) {
+    return identifier;
   }
-  const indexSignatureType = unwrapAst(ast, SchemaAST7.isTypeLiteral);
-  if (indexSignatureType && SchemaAST7.isTypeLiteral(indexSignatureType) && indexSignatureType.indexSignatures.length > 0) {
-    return unwrapAst(indexSignatureType.indexSignatures[0].type);
+  const typename = getSchemaTypename(schema);
+  if (!typename) {
+    throw new Error("Schema must have a typename");
   }
-  return null;
+  return DXN4.fromTypename(typename).toString();
 };
-var getTypeDiscriminators = (typeAstList) => {
-  const discriminatorPropCandidates = typeAstList.flatMap(SchemaAST7.getPropertySignatures).filter((p) => SchemaAST7.isLiteral(p.type));
-  const propertyName = discriminatorPropCandidates[0].name;
-  const isValidDiscriminator = discriminatorPropCandidates.every((p) => p.name === propertyName && !p.isOptional);
-  const everyTypeHasDiscriminator = discriminatorPropCandidates.length === typeAstList.length;
-  const isDiscriminatedUnion = isValidDiscriminator && everyTypeHasDiscriminator;
-  invariant13(isDiscriminatedUnion, "type ambiguity: every type in a union must have a single unique-literal field", {
-    F: __dxlog_file13,
-    L: 193,
-    S: void 0,
-    A: [
-      "isDiscriminatedUnion",
-      "'type ambiguity: every type in a union must have a single unique-literal field'"
-    ]
-  });
-  return discriminatorPropCandidates;
+
+// src/internal/Entity/version.ts
+import { assertArgument as assertArgument4 } from "@dxos/invariant";
+var unversioned = {
+  [VersionTypeId]: {},
+  versioned: false
 };
-var unwrapAst = (rootAst, predicate) => {
-  let ast = rootAst;
-  while (ast != null) {
-    if (predicate?.(ast)) {
-      return ast;
-    }
-    if (SchemaAST7.isUnion(ast)) {
-      const next = ast.types.find((t) => predicate != null && predicate(t) || SchemaAST7.isSuspend(t));
-      if (next != null) {
-        ast = next;
-        continue;
-      }
-    }
-    if (SchemaAST7.isSuspend(ast)) {
-      ast = ast.f();
-    } else {
-      return predicate == null ? ast : null;
-    }
-  }
-  return null;
+var isVersion = (entity) => {
+  return entity != null && typeof entity === "object" && VersionTypeId in entity;
 };
-var unwrapArray = (ast) => unwrapAst(ast, SchemaAST7.isTupleType);
-var checkIdNotPresentOnSchema = (schema) => {
-  invariant13(SchemaAST7.isTypeLiteral(schema.ast), void 0, {
-    F: __dxlog_file13,
-    L: 236,
-    S: void 0,
-    A: [
-      "SchemaAST.isTypeLiteral(schema.ast)",
-      ""
-    ]
-  });
-  const idProperty = SchemaAST7.getPropertySignatures(schema.ast).find((prop) => prop.name === "id");
-  if (idProperty != null) {
-    throw new Error('"id" property name is reserved');
+var version = (entity) => {
+  const ver = entity[ObjectVersionId];
+  if (ver === void 0) {
+    return unversioned;
   }
+  return ver;
 };
-
-// src/internal/proxy/typed-handler.ts
-var __dxlog_file14 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/proxy/typed-handler.ts";
-var deepCopy = (value2, visited = /* @__PURE__ */ new Map()) => {
-  if (value2 == null || typeof value2 !== "object") {
-    return value2;
-  }
-  const actualValue = getRawTarget(value2);
-  if (visited.has(actualValue)) {
-    return visited.get(actualValue);
-  }
-  if (actualValue instanceof ReactiveArray) {
-    const copy2 = new ReactiveArray();
-    visited.set(actualValue, copy2);
-    for (const item of actualValue) {
-      copy2.push(deepCopy(item, visited));
-    }
-    copyHiddenProperties(actualValue, copy2);
-    return copy2;
-  }
-  const proto = Object.getPrototypeOf(actualValue);
-  if (proto !== Object.prototype && proto !== Array.prototype && proto !== null) {
-    return value2;
+var versionValid = (ver) => {
+  assertArgument4(isVersion(ver), "version", "Invalid version object");
+  return !!ver.versioned;
+};
+var compareVersions = (version1, version2) => {
+  assertArgument4(isVersion(version1), "version1", "Invalid version object");
+  assertArgument4(isVersion(version2), "version2", "Invalid version object");
+  if (!versionValid(version1) || !versionValid(version2)) {
+    return "unversioned";
   }
-  if (Array.isArray(actualValue)) {
-    const copy2 = new ReactiveArray();
-    visited.set(actualValue, copy2);
-    for (const item of actualValue) {
-      copy2.push(deepCopy(item, visited));
-    }
-    return copy2;
+  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return "different";
   }
-  const copy = {};
-  visited.set(actualValue, copy);
-  for (const key of Object.keys(actualValue)) {
-    copy[key] = deepCopy(actualValue[key], visited);
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return "different";
   }
-  copyHiddenProperties(actualValue, copy);
+  return "equal";
+};
+var encodeVersion = (ver) => {
+  return JSON.stringify(ver);
+};
+var decodeVersion = (ver) => {
+  const parsed = JSON.parse(ver);
+  parsed[VersionTypeId] = {};
+  return parsed;
+};
+
+// src/internal/JsonSchema/json-schema-normalize.ts
+var normalizeSchema = (schema) => {
+  const copy = structuredClone(schema);
+  go(copy);
   return copy;
 };
-var copyHiddenProperties = (source, target) => {
-  if (SchemaId in source) {
-    defineHiddenProperty(target, SchemaId, source[SchemaId]);
+var go = (schema) => {
+  if (typeof schema !== "object" || schema === null) {
+    return;
   }
-  if (TypeId in source) {
-    defineHiddenProperty(target, TypeId, source[TypeId]);
+  if (schema.exclusiveMaximum === true) {
+    schema.exclusiveMaximum = schema.maximum;
+    delete schema.exclusiveMaximum;
+  } else if (schema.exclusiveMaximum === false) {
+    delete schema.exclusiveMaximum;
   }
-};
-var TypedReactiveHandler = class _TypedReactiveHandler {
-  static instance = new _TypedReactiveHandler();
-  _proxyMap = /* @__PURE__ */ new WeakMap();
-  _inSet = false;
-  constructor() {
+  if (schema.exclusiveMinimum === true) {
+    schema.exclusiveMinimum = schema.minimum;
+    delete schema.exclusiveMinimum;
+  } else if (schema.exclusiveMinimum === false) {
+    delete schema.exclusiveMinimum;
   }
-  init(target) {
-    invariant14(typeof target === "object" && target !== null, void 0, {
-      F: __dxlog_file14,
-      L: 147,
-      S: this,
-      A: [
-        "typeof target === 'object' && target !== null",
-        ""
-      ]
-    });
-    invariant14(SchemaId in target, "Schema is not defined for the target", {
-      F: __dxlog_file14,
-      L: 148,
-      S: this,
-      A: [
-        "SchemaId in target",
-        "'Schema is not defined for the target'"
-      ]
-    });
-    const hasOwner = !!getOwner(target);
-    if (!(EventId in target) && !hasOwner) {
-      defineHiddenProperty(target, EventId, new Event2());
-    }
-    defineHiddenProperty(target, ObjectDeletedId, false);
-    if (!hasOwner && !(ChangeId in target)) {
-      defineHiddenProperty(target, ChangeId, true);
-    }
-    if (!hasOwner) {
-      for (const key in target) {
-        if (target[symbolIsProxy]) {
-          continue;
-        }
-        let value2 = target[key];
-        if (isValidProxyTarget(value2) || isProxy(value2)) {
-          if (hasForeignOwner(value2, target)) {
-            value2 = deepCopy(value2);
-            target[key] = value2;
-          }
-          setOwnerRecursive(value2, target);
-        }
-      }
+  for (const key of Object.keys(schema)) {
+    if (!JsonSchemaFields.includes(key)) {
+      delete schema[key];
     }
-    Object.defineProperty(target, inspectCustom2, {
-      enumerable: false,
-      configurable: true,
-      value: this._inspect.bind(target)
-    });
   }
-  get(target, prop, receiver) {
-    switch (prop) {
-      // TODO(burdon): Remove?
-      case objectData: {
-        return toJSON(target);
-      }
-      case ChangeId: {
-        if (target[ChangeId] !== true) {
-          return void 0;
-        }
-        return (callback) => executeChange(target, target, receiver, callback);
-      }
-    }
-    if (Object.getOwnPropertyDescriptor(target, prop)?.get) {
-      return Reflect.get(target, prop, receiver);
-    }
-    const value2 = Reflect.get(target, prop, receiver);
-    if (isValidProxyTarget(value2)) {
-      return createProxy(value2, this);
-    }
-    return value2;
+  if (schema.properties) {
+    goOnRecord(schema.properties);
   }
-  set(target, prop, value2, receiver) {
-    const echoRoot = getEchoRoot(target);
-    const isInitialized = ChangeId in echoRoot || EventId in echoRoot;
-    const isSymbolProp = typeof prop === "symbol";
-    if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
-      throw new Error(`Cannot modify object property "${String(prop)}" outside of Obj.change(). Use Obj.change(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
-    }
-    let result = false;
-    this._inSet = true;
-    try {
-      batchEvents(() => {
-        const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, prop, value2);
-        result = Reflect.set(target, prop, preparedValue, receiver);
-        if (isInitialized) {
-          queueNotification(echoRoot);
-          notifyOwnerChain(target);
-        }
-      });
-    } finally {
-      this._inSet = false;
-    }
-    return result;
+  if (schema.patternProperties) {
+    goOnRecord(schema.patternProperties);
   }
-  ownKeys(target) {
-    return Reflect.ownKeys(target);
+  if (schema.propertyNames) {
+    go(schema.propertyNames);
   }
-  deleteProperty(target, property) {
-    const echoRoot = getEchoRoot(target);
-    const isInitialized = echoRoot[ChangeId] === true || EventId in echoRoot;
-    const isSymbolProp = typeof property === "symbol";
-    if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
-      throw createPropertyDeleteError(property);
-    }
-    const result = Reflect.deleteProperty(target, property);
-    if (isInitialized) {
-      queueNotification(echoRoot);
-    }
-    return result;
+  if (schema.definitions) {
+    goOnRecord(schema.definitions);
   }
-  defineProperty(target, property, attributes) {
-    const echoRoot = getEchoRoot(target);
-    const isInitialized = ChangeId in echoRoot || EventId in echoRoot;
-    const isSymbolProp = typeof property === "symbol";
-    if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
-      throw new Error(`Cannot modify object property "${String(property)}" outside of Obj.change(). Use Obj.change(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
-    }
-    const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, property, attributes.value);
-    const result = Reflect.defineProperty(target, property, {
-      ...attributes,
-      value: preparedValue
-    });
-    if (!this._inSet && isInitialized) {
-      queueNotification(echoRoot);
-    }
-    return result;
+  if (schema.items) {
+    maybeGoOnArray(schema.items);
   }
-  /**
-  * Prepare a value for assignment to a typed object property.
-  * Handles cycle detection, copy-on-assign, array conversion, validation, and ownership.
-  */
-  _prepareValueForAssignment(target, prop, value2) {
-    const echoRoot = getEchoRoot(target);
-    if (isValidProxyTarget(value2) || isProxy(value2)) {
-      if (wouldCreateCycle(echoRoot, value2)) {
-        throw new Error("Cannot create cycles in typed object graph. Consider using Ref for circular references.");
-      }
-    }
-    if (isValidProxyTarget(value2) || isProxy(value2)) {
-      const actualValue = getRawTarget(value2);
-      const isRootEchoObject = EventId in actualValue;
-      if (isRootEchoObject) {
-        throw new Error("Object references must be wrapped with `Ref.make`");
-      }
-    }
-    if (isValidProxyTarget(value2) || isProxy(value2)) {
-      const actualValue = getRawTarget(value2);
-      const existingOwner = getOwner(actualValue);
-      if (existingOwner != null && existingOwner !== echoRoot) {
-        value2 = deepCopy(value2);
-      }
-    }
-    if (Array.isArray(value2) && !(value2 instanceof ReactiveArray)) {
-      value2 = ReactiveArray.from(value2);
-    }
-    const validatedValue = this._validateValue(target, prop, value2);
-    if (isValidProxyTarget(validatedValue) || isProxy(validatedValue)) {
-      setOwnerRecursive(validatedValue, echoRoot);
-    }
-    return {
-      echoRoot,
-      preparedValue: validatedValue
-    };
+  if (schema.additionalItems) {
+    maybeGoOnArray(schema.additionalItems);
   }
-  _validateValue(target, prop, value2) {
-    const schema = SchemaValidator.getTargetPropertySchema(target, prop);
-    const _ = Schema12.asserts(schema)(value2);
-    if (isValidProxyTarget(value2)) {
-      setSchemaProperties(value2, schema);
-    }
-    return value2;
+  if (schema.contains) {
+    go(schema.contains);
   }
-  _inspect(_, options, inspectFn) {
-    const inspected = inspectFn(this, {
-      ...options,
-      showHidden: false,
-      customInspect: false
-    });
-    return `Typed ${inspected}`;
+  if (schema.if) {
+    go(schema.if);
   }
-};
-var toJSON = (target) => {
-  return {
-    "@type": "TypedReactiveObject",
-    ...target
-  };
-};
-var setSchemaProperties = (obj, schema) => {
-  const schemaType = getSchemaDXN(schema);
-  if (schemaType != null) {
-    defineHiddenProperty(obj, TypeId, schemaType);
+  if (schema.then) {
+    go(schema.then);
   }
-  defineHiddenProperty(obj, SchemaId, schema);
-  for (const key in obj) {
-    if (isValidProxyTarget(obj[key])) {
-      const elementSchema = SchemaValidator.getTargetPropertySchema(obj, key);
-      if (elementSchema != null) {
-        setSchemaProperties(obj[key], elementSchema);
-      }
-    }
+  if (schema.else) {
+    go(schema.else);
   }
-};
-var prepareTypedTarget = (target, schema) => {
-  if (!SchemaAST8.isTypeLiteral(schema.ast)) {
-    throw new Error("schema has to describe an object type");
+  if (schema.allOf) {
+    maybeGoOnArray(schema.allOf);
   }
-  SchemaValidator.validateSchema(schema);
-  const _ = Schema12.asserts(schema)(target);
-  makeArraysReactive(target);
-  setSchemaProperties(target, schema);
-};
-var makeArraysReactive = (target) => {
-  for (const key in target) {
-    if (target[symbolIsProxy]) {
-      continue;
-    }
-    if (Array.isArray(target[key])) {
-      target[key] = ReactiveArray.from(target[key]);
-    }
-    if (typeof target[key] === "object") {
-      makeArraysReactive(target[key]);
-    }
+  if (schema.anyOf) {
+    maybeGoOnArray(schema.anyOf);
   }
-};
-
-// src/internal/proxy/make-object.ts
-var makeObject = (schema, obj, meta) => {
-  return createReactiveObject({
-    ...obj
-  }, meta, schema);
-};
-var createReactiveObject = (obj, meta, schema) => {
-  if (!isValidProxyTarget(obj)) {
-    throw new Error("Value cannot be made into a reactive object.");
+  if (schema.oneOf) {
+    maybeGoOnArray(schema.oneOf);
   }
-  if (!schema) {
-    throw new Error("Schema is required for reactive objects. Use Atom for untyped reactive state.");
+  if (schema.not) {
+    go(schema.not);
   }
-  const annotation = getTypeAnnotation(schema);
-  if (annotation) {
-    setIdOnTarget(obj);
-    defineHiddenProperty(obj, KindId, annotation.kind);
+  if (schema.$defs) {
+    goOnRecord(schema.$defs);
   }
-  initMeta(obj, meta);
-  prepareTypedTarget(obj, schema);
-  attachTypedJsonSerializer(obj);
-  const proxy = createProxy(obj, TypedReactiveHandler.instance);
-  const metaProxy = obj[MetaId];
-  if (metaProxy) {
-    const metaTarget = getProxyTarget(metaProxy);
-    if (metaTarget) {
-      setMetaOwner(metaTarget, obj);
-    }
+  if (schema.reference) {
+    go(schema.reference.schema);
   }
-  return proxy;
 };
-var setIdOnTarget = (target) => {
-  if ("id" in target && target.id !== void 0 && target.id !== null) {
-    if (!ObjectId5.isValid(target.id)) {
-      throw new Error("Invalid object id format.");
+var maybeGoOnArray = (value2) => {
+  if (Array.isArray(value2)) {
+    for (const item of value2) {
+      go(item);
     }
-  } else {
-    target.id = ObjectId5.random();
+  } else if (typeof value2 === "object" && value2 !== null) {
+    go(value2);
   }
 };
-var initMeta = (obj, meta = {
-  keys: []
-}) => {
-  prepareTypedTarget(meta, ObjectMetaSchema);
-  defineHiddenProperty(obj, MetaId, createProxy(meta, TypedReactiveHandler.instance));
+var goOnRecord = (record) => {
+  for (const key of Object.keys(record)) {
+    go(record[key]);
+  }
 };
 
-// src/internal/proxy/reactive.ts
-var subscribe = (obj, callback) => {
-  const target = getProxyTarget(obj);
-  if (target && EventId in target) {
-    return target[EventId].on(callback);
-  }
-  return () => {
+// src/internal/Obj/common.ts
+import * as Schema9 from "effect/Schema";
+var makeTypedEntityClass = (typename, version2, baseSchema) => {
+  return class {
+    // Implement TypedObject properties.
+    static typename = typename;
+    static version = version2;
+    // Implement Schema.Schema properties.
+    // TODO(burdon): Comment required.
+    static [Schema9.TypeId] = schemaVariance;
+    static ast = baseSchema.ast;
+    static annotations = baseSchema.annotations.bind(baseSchema);
+    static pipe = baseSchema.pipe.bind(baseSchema);
+    // TODO(burdon): Comment required.
+    static [Symbol.hasInstance](obj) {
+      return obj != null && getTypename(obj) === typename;
+    }
+    // TODO(burdon): Throw APIError.
+    constructor() {
+      throw new Error("Use live(Typename, { ...fields }) to instantiate an object.");
+    }
   };
 };
-var change = (obj, callback) => {
-  const changeFn = obj[ChangeId];
-  if (changeFn) {
-    changeFn(callback);
-  } else {
-    callback(obj);
-  }
+var schemaVariance = {
+  _A: (_) => _,
+  _I: (_) => _,
+  _R: (_) => _
 };
 
-// src/internal/object/inspect.ts
-import { inspectCustom as inspectCustom3 } from "@dxos/debug";
+// src/internal/Obj/create-object.ts
+import { raise as raise3 } from "@dxos/debug";
+import { assertArgument as assertArgument6, failedInvariant } from "@dxos/invariant";
+import { ObjectId as ObjectId5 } from "@dxos/keys";
+
+// src/internal/Obj/inspect.ts
+import { inspectCustom as inspectCustom2 } from "@dxos/debug";
 var attachedTypedObjectInspector = (obj) => {
-  const descriptor = Object.getOwnPropertyDescriptor(obj, inspectCustom3);
+  const descriptor = Object.getOwnPropertyDescriptor(obj, inspectCustom2);
   if (descriptor) {
     return;
   }
-  Object.defineProperty(obj, inspectCustom3, {
+  Object.defineProperty(obj, inspectCustom2, {
     value: typedObjectInspectFunction,
     writable: false,
     enumerable: false,
@@ -2874,19 +1735,19 @@ var typedObjectInspectFunction = function(depth, options, inspect) {
   }, options);
 };
 
-// src/internal/object/json-serializer.ts
-import * as Schema13 from "effect/Schema";
-import { raise as raise3 } from "@dxos/debug";
+// src/internal/Obj/json-serializer.ts
+import * as Schema10 from "effect/Schema";
+import { raise as raise2 } from "@dxos/debug";
 import { ObjectStructure, isEncodedReference } from "@dxos/echo-protocol";
-import { assertArgument as assertArgument7, invariant as invariant15 } from "@dxos/invariant";
-import { DXN as DXN7, ObjectId as ObjectId6 } from "@dxos/keys";
+import { assertArgument as assertArgument5, invariant as invariant13 } from "@dxos/invariant";
+import { DXN as DXN5, ObjectId as ObjectId4 } from "@dxos/keys";
 import { assumeType as assumeType4, deepMapValues as deepMapValues2, visitValues } from "@dxos/util";
-var __dxlog_file15 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/json-serializer.ts";
+var __dxlog_file13 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/json-serializer.ts";
 var objectToJSON = (obj) => {
   const typename = getTypeDXN(obj)?.toString();
-  invariant15(typename && typeof typename === "string", void 0, {
-    F: __dxlog_file15,
-    L: 62,
+  invariant13(typename && typeof typename === "string", void 0, {
+    F: __dxlog_file13,
+    L: 64,
     S: void 0,
     A: [
       "typename && typeof typename === 'string'",
@@ -2897,34 +1758,35 @@ var objectToJSON = (obj) => {
 };
 var objectFromJSON = async (jsonData, { refResolver, dxn } = {}) => {
   assumeType4(jsonData);
-  assertArgument7(typeof jsonData === "object" && jsonData !== null, "jsonData", "expect object");
-  assertArgument7(typeof jsonData[ATTR_TYPE] === "string", "jsonData[ATTR_TYPE]", "expected object to have a type");
-  assertArgument7(typeof jsonData.id === "string", "jsonData.id", "expected object to have an id");
-  const type = DXN7.parse(jsonData[ATTR_TYPE]);
+  assertArgument5(typeof jsonData === "object" && jsonData !== null, "jsonData", "expect object");
+  assertArgument5(typeof jsonData[ATTR_TYPE] === "string", "jsonData[ATTR_TYPE]", "expected object to have a type");
+  assertArgument5(typeof jsonData.id === "string", "jsonData.id", "expected object to have an id");
+  const type = DXN5.parse(jsonData[ATTR_TYPE]);
   const schema = await refResolver?.resolveSchema(type);
-  invariant15(schema === void 0 || Schema13.isSchema(schema), void 0, {
-    F: __dxlog_file15,
-    L: 83,
+  invariant13(schema === void 0 || Schema10.isSchema(schema), void 0, {
+    F: __dxlog_file13,
+    L: 85,
     S: void 0,
     A: [
       "schema === undefined || Schema.isSchema(schema)",
       ""
     ]
   });
+  const decodedInput = stripInternalJsonKeys(jsonData);
   let obj;
   if (schema != null) {
-    obj = await schema.pipe(Schema13.decodeUnknownPromise)(jsonData);
+    obj = await schema.pipe(Schema10.decodeUnknownPromise)(decodedInput);
     if (refResolver) {
       setRefResolverOnData(obj, refResolver);
     }
   } else {
-    obj = decodeGeneric(jsonData, {
+    obj = decodeGeneric(decodedInput, {
       refResolver
     });
   }
-  invariant15(ObjectId6.isValid(obj.id), "Invalid object id", {
-    F: __dxlog_file15,
-    L: 95,
+  invariant13(ObjectId4.isValid(obj.id), "Invalid object id", {
+    F: __dxlog_file13,
+    L: 98,
     S: void 0,
     A: [
       "ObjectId.isValid(obj.id)",
@@ -2937,8 +1799,8 @@ var objectFromJSON = async (jsonData, { refResolver, dxn } = {}) => {
   }
   const isRelation = typeof jsonData[ATTR_RELATION_SOURCE] === "string" || typeof jsonData[ATTR_RELATION_TARGET] === "string";
   if (isRelation) {
-    const sourceDxn = DXN7.parse(jsonData[ATTR_RELATION_SOURCE] ?? raise3(new TypeError("Missing relation source")));
-    const targetDxn = DXN7.parse(jsonData[ATTR_RELATION_TARGET] ?? raise3(new TypeError("Missing relation target")));
+    const sourceDxn = DXN5.parse(jsonData[ATTR_RELATION_SOURCE] ?? raise2(new TypeError("Missing relation source")));
+    const targetDxn = DXN5.parse(jsonData[ATTR_RELATION_TARGET] ?? raise2(new TypeError("Missing relation target")));
     const source = await refResolver?.resolve(sourceDxn);
     const target = await refResolver?.resolve(targetDxn);
     defineHiddenProperty(obj, KindId, EntityKind.Relation);
@@ -2950,10 +1812,10 @@ var objectFromJSON = async (jsonData, { refResolver, dxn } = {}) => {
     defineHiddenProperty(obj, KindId, EntityKind.Object);
   }
   if (typeof jsonData[ATTR_META] === "object") {
-    const meta = await ObjectMetaSchema.pipe(Schema13.decodeUnknownPromise)(jsonData[ATTR_META]);
-    invariant15(Array.isArray(meta.keys), void 0, {
-      F: __dxlog_file15,
-      L: 121,
+    const meta = await ObjectMetaSchema.pipe(Schema10.decodeUnknownPromise)(jsonData[ATTR_META]);
+    invariant13(Array.isArray(meta.keys), void 0, {
+      F: __dxlog_file13,
+      L: 124,
       S: void 0,
       A: [
         "Array.isArray(meta.keys)",
@@ -2966,58 +1828,63 @@ var objectFromJSON = async (jsonData, { refResolver, dxn } = {}) => {
       keys: []
     });
   }
+  if (jsonData[ATTR_PARENT]) {
+    const parentDxn = DXN5.parse(jsonData[ATTR_PARENT]);
+    const parent = await refResolver?.resolve(parentDxn);
+    defineHiddenProperty(obj, ParentId, parent);
+  }
   if (dxn) {
     defineHiddenProperty(obj, SelfDXNId, dxn);
   }
   assertObjectModel(obj);
-  invariant15(obj[ATTR_TYPE] === void 0, "Invalid object model", {
-    F: __dxlog_file15,
-    L: 134,
+  invariant13(obj[ATTR_TYPE] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 143,
     S: void 0,
     A: [
       "(obj as any)[ATTR_TYPE] === undefined",
       "'Invalid object model'"
     ]
   });
-  invariant15(obj[ATTR_META] === void 0, "Invalid object model", {
-    F: __dxlog_file15,
-    L: 135,
+  invariant13(obj[ATTR_META] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 144,
     S: void 0,
     A: [
       "(obj as any)[ATTR_META] === undefined",
       "'Invalid object model'"
     ]
   });
-  invariant15(obj[ATTR_DELETED] === void 0, "Invalid object model", {
-    F: __dxlog_file15,
-    L: 136,
+  invariant13(obj[ATTR_DELETED] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 145,
     S: void 0,
     A: [
       "(obj as any)[ATTR_DELETED] === undefined",
       "'Invalid object model'"
     ]
   });
-  invariant15(obj[ATTR_SELF_DXN] === void 0, "Invalid object model", {
-    F: __dxlog_file15,
-    L: 137,
+  invariant13(obj[ATTR_SELF_DXN] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 146,
     S: void 0,
     A: [
       "(obj as any)[ATTR_SELF_DXN] === undefined",
       "'Invalid object model'"
     ]
   });
-  invariant15(obj[ATTR_RELATION_SOURCE] === void 0, "Invalid object model", {
-    F: __dxlog_file15,
-    L: 138,
+  invariant13(obj[ATTR_RELATION_SOURCE] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 147,
     S: void 0,
     A: [
       "(obj as any)[ATTR_RELATION_SOURCE] === undefined",
       "'Invalid object model'"
     ]
   });
-  invariant15(obj[ATTR_RELATION_TARGET] === void 0, "Invalid object model", {
-    F: __dxlog_file15,
-    L: 139,
+  invariant13(obj[ATTR_RELATION_TARGET] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 148,
     S: void 0,
     A: [
       "(obj as any)[ATTR_RELATION_TARGET] === undefined",
@@ -3027,7 +1894,7 @@ var objectFromJSON = async (jsonData, { refResolver, dxn } = {}) => {
   return obj;
 };
 var decodeGeneric = (jsonData, options) => {
-  const { [ATTR_TYPE]: _type, [ATTR_META]: _meta, [ATTR_DELETED]: _deleted, [ATTR_SELF_DXN]: _selfDxn, [ATTR_RELATION_SOURCE]: _relationSource, [ATTR_RELATION_TARGET]: _relationTarget, ...props } = jsonData;
+  const props = stripInternalJsonKeys(jsonData);
   return deepMapValues2(props, (value2, visitor) => {
     if (isEncodedReference(value2)) {
       return refFromEncodedReference(value2, options.refResolver);
@@ -3035,6 +1902,10 @@ var decodeGeneric = (jsonData, options) => {
     return visitor(value2);
   });
 };
+var stripInternalJsonKeys = (jsonData) => {
+  const { [ATTR_TYPE]: _type, [ATTR_META]: _meta, [ATTR_DELETED]: _deleted, [ATTR_SELF_DXN]: _selfDxn, [ATTR_RELATION_SOURCE]: _relationSource, [ATTR_RELATION_TARGET]: _relationTarget, ...props } = jsonData;
+  return props;
+};
 var setRefResolverOnData = (obj, refResolver) => {
   const visitor = (value2) => {
     if (Ref.isRef(value2)) {
@@ -3051,24 +1922,25 @@ var objectStructureToJson = (objectId, structure) => {
     id: objectId,
     [ATTR_TYPE]: ObjectStructure.getTypeReference(structure)?.["/"] ?? "",
     [ATTR_DELETED]: ObjectStructure.isDeleted(structure),
+    [ATTR_PARENT]: ObjectStructure.getParent(structure)?.["/"],
     [ATTR_RELATION_SOURCE]: ObjectStructure.getRelationSource(structure)?.["/"],
     [ATTR_RELATION_TARGET]: ObjectStructure.getRelationTarget(structure)?.["/"]
   };
 };
 
-// src/internal/object/create-object.ts
+// src/internal/Obj/create-object.ts
 var createObject = (schema, props) => {
   const annotation = getTypeAnnotation(schema);
   if (!annotation) {
     throw new Error("Schema is not an ECHO schema");
   }
-  assertArgument8(!("@type" in props), "data", "@type is not allowed");
-  assertArgument8(!(RelationSourceDXNId in props), "data", "Relation source DXN is not allowed in the constructor");
-  assertArgument8(!(RelationTargetDXNId in props), "data", "Relation target DXN is not allowed in the constructor");
-  assertArgument8(RelationSourceId in props === RelationTargetId in props, "data", "Relation source and target must be provided together");
+  assertArgument6(!("@type" in props), "data", "@type is not allowed");
+  assertArgument6(!(RelationSourceDXNId in props), "data", "Relation source DXN is not allowed in the constructor");
+  assertArgument6(!(RelationTargetDXNId in props), "data", "Relation target DXN is not allowed in the constructor");
+  assertArgument6(RelationSourceId in props === RelationTargetId in props, "data", "Relation source and target must be provided together");
   const obj = {
     ...props,
-    id: props.id ?? ObjectId7.random()
+    id: props.id ?? ObjectId5.random()
   };
   const kind = RelationSourceId in props ? EntityKind.Relation : EntityKind.Object;
   defineHiddenProperty(obj, KindId, kind);
@@ -3080,8 +1952,8 @@ var createObject = (schema, props) => {
   attachTypedJsonSerializer(obj);
   attachedTypedObjectInspector(obj);
   if (kind === EntityKind.Relation) {
-    const sourceDXN = getObjectDXN(props[RelationSourceId]) ?? raise4(new Error("Unresolved relation source"));
-    const targetDXN = getObjectDXN(props[RelationTargetId]) ?? raise4(new Error("Unresolved relation target"));
+    const sourceDXN = getObjectDXN(props[RelationSourceId]) ?? raise3(new Error("Unresolved relation source"));
+    const targetDXN = getObjectDXN(props[RelationTargetId]) ?? raise3(new Error("Unresolved relation target"));
     defineHiddenProperty(obj, RelationSourceDXNId, sourceDXN);
     defineHiddenProperty(obj, RelationTargetDXNId, targetDXN);
   }
@@ -3089,7 +1961,7 @@ var createObject = (schema, props) => {
   return obj;
 };
 
-// src/internal/object/deleted.ts
+// src/internal/Obj/deleted.ts
 var isDeleted = (obj) => {
   if (obj[ObjectDeletedId] === void 0) {
     return false;
@@ -3097,24 +1969,24 @@ var isDeleted = (obj) => {
   return obj[ObjectDeletedId] ?? false;
 };
 
-// src/internal/object/ids.ts
-import { DXN as DXN8, ObjectId as ObjectId8, QueueSubspaceTags, SpaceId } from "@dxos/keys";
-var createQueueDXN = (spaceId = SpaceId.random(), queueId = ObjectId8.random()) => new DXN8(DXN8.kind.QUEUE, [
+// src/internal/Obj/ids.ts
+import { DXN as DXN6, ObjectId as ObjectId6, QueueSubspaceTags, SpaceId } from "@dxos/keys";
+var createQueueDXN = (spaceId = SpaceId.random(), queueId = ObjectId6.random()) => new DXN6(DXN6.kind.QUEUE, [
   QueueSubspaceTags.DATA,
   spaceId,
   queueId
 ]);
 
-// src/internal/object/set-value.ts
+// src/internal/Obj/set-value.ts
 import * as Match from "effect/Match";
-import * as Option3 from "effect/Option";
-import * as SchemaAST9 from "effect/SchemaAST";
+import * as Option from "effect/Option";
+import * as SchemaAST6 from "effect/SchemaAST";
 import { getArrayElementType, getBaseType, getProperties as getProperties2, isArrayType, isNestedType } from "@dxos/effect";
-import { invariant as invariant16 } from "@dxos/invariant";
-var __dxlog_file16 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/set-value.ts";
+import { invariant as invariant14 } from "@dxos/invariant";
+var __dxlog_file14 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/set-value.ts";
 var setValue = (obj, path, value2) => {
-  invariant16(path.length > 0, "Path must not be empty", {
-    F: __dxlog_file16,
+  invariant14(path.length > 0, "Path must not be empty", {
+    F: __dxlog_file14,
     L: 27,
     S: void 0,
     A: [
@@ -3123,8 +1995,8 @@ var setValue = (obj, path, value2) => {
     ]
   });
   const schema = getSchema(obj);
-  invariant16(schema != null, "Object must have a schema", {
-    F: __dxlog_file16,
+  invariant14(schema != null, "Object must have a schema", {
+    F: __dxlog_file14,
     L: 30,
     S: void 0,
     A: [
@@ -3185,8 +2057,8 @@ var getDefaultValueForType = (ast) => {
   if (!ast) {
     return void 0;
   }
-  const defaultValue = SchemaAST9.getDefaultAnnotation(ast);
-  if (Option3.isSome(defaultValue)) {
+  const defaultValue = SchemaAST6.getDefaultAnnotation(ast);
+  if (Option.isSome(defaultValue)) {
     return defaultValue.value;
   }
   return Match.value(ast).pipe(Match.when({
@@ -3214,12 +2086,20 @@ var createObjectWithDefaults = (ast) => {
   return obj;
 };
 
-// src/internal/object/snapshot.ts
+// src/internal/Obj/snapshot.ts
+import { assertArgument as assertArgument7 } from "@dxos/invariant";
 import { deepMapValues as deepMapValues3 } from "@dxos/util";
-var copySymbolProperty = (source, target, symbol) => {
-  if (symbol in source) {
+var copySymbolProperty = (source, target, symbol, transform) => {
+  let value2;
+  try {
+    value2 = source[symbol];
+  } catch {
+    return;
+  }
+  if (value2 !== void 0) {
+    const finalValue = transform ? transform(value2) : value2;
     Object.defineProperty(target, symbol, {
-      value: source[symbol],
+      value: finalValue,
       writable: false,
       enumerable: false,
       configurable: false
@@ -3227,6 +2107,7 @@ var copySymbolProperty = (source, target, symbol) => {
   }
 };
 var getSnapshot = (obj) => {
+  assertArgument7(typeof obj === "object" && obj !== null && KindId in obj, "obj", "must be an entity");
   const snapshot = deepMapValues3(obj, (value2, recurse) => {
     if (typeof value2 === "object" && value2 !== null && Object.getPrototypeOf(value2) !== Object.prototype && !Array.isArray(value2)) {
       return value2;
@@ -3236,28 +2117,36 @@ var getSnapshot = (obj) => {
   if (obj != null && typeof obj === "object" && KindId in obj) {
     snapshot[SnapshotKindId] = obj[KindId];
   }
-  if (obj != null && typeof obj === "object") {
-    const source = obj;
-    copySymbolProperty(source, snapshot, TypeId);
-    copySymbolProperty(source, snapshot, SchemaId);
-    copySymbolProperty(source, snapshot, MetaId);
-    copySymbolProperty(source, snapshot, RelationSourceDXNId);
-    copySymbolProperty(source, snapshot, RelationTargetDXNId);
-    copySymbolProperty(source, snapshot, RelationSourceId);
-    copySymbolProperty(source, snapshot, RelationTargetId);
-  }
+  const source = obj;
+  copySymbolProperty(source, snapshot, TypeId);
+  copySymbolProperty(source, snapshot, SchemaId);
+  copySymbolProperty(source, snapshot, SelfDXNId);
+  copySymbolProperty(source, snapshot, ObjectDatabaseId);
+  copySymbolProperty(source, snapshot, ObjectDeletedId);
+  copySymbolProperty(source, snapshot, MetaId, (meta) => ({
+    keys: [
+      ...meta?.keys ?? []
+    ],
+    tags: [
+      ...meta?.tags ?? []
+    ]
+  }));
+  copySymbolProperty(source, snapshot, RelationSourceDXNId);
+  copySymbolProperty(source, snapshot, RelationTargetDXNId);
+  copySymbolProperty(source, snapshot, RelationSourceId);
+  copySymbolProperty(source, snapshot, RelationTargetId);
   return Object.freeze(snapshot);
 };
 
-// src/internal/object/clone.ts
-import { invariant as invariant17 } from "@dxos/invariant";
+// src/internal/Obj/clone.ts
+import { invariant as invariant15 } from "@dxos/invariant";
 import { deepMapValues as deepMapValues4 } from "@dxos/util";
-var __dxlog_file17 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/clone.ts";
+var __dxlog_file15 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/clone.ts";
 var clone = (obj, opts) => {
   const { id, ...data } = obj;
   const schema = getSchema(obj);
-  invariant17(schema != null, "Object should have a schema", {
-    F: __dxlog_file17,
+  invariant15(schema != null, "Object should have a schema", {
+    F: __dxlog_file15,
     L: 21,
     S: void 0,
     A: [
@@ -3289,25 +2178,25 @@ var clone = (obj, opts) => {
   return makeObject(schema, props, meta);
 };
 
-// src/internal/schema/echo-schema.ts
-import * as Schema16 from "effect/Schema";
-import * as SchemaAST11 from "effect/SchemaAST";
-import { invariant as invariant19 } from "@dxos/invariant";
+// src/internal/Type/echo-schema.ts
+import * as Schema13 from "effect/Schema";
+import * as SchemaAST8 from "effect/SchemaAST";
+import { invariant as invariant17 } from "@dxos/invariant";
 
-// src/internal/schema/manipulation.ts
-import * as Schema14 from "effect/Schema";
-import * as SchemaAST10 from "effect/SchemaAST";
-import { invariant as invariant18 } from "@dxos/invariant";
-import { DXN as DXN9 } from "@dxos/keys";
-var __dxlog_file18 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/schema/manipulation.ts";
+// src/internal/Type/manipulation.ts
+import * as Schema11 from "effect/Schema";
+import * as SchemaAST7 from "effect/SchemaAST";
+import { invariant as invariant16 } from "@dxos/invariant";
+import { DXN as DXN7 } from "@dxos/keys";
+var __dxlog_file16 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Type/manipulation.ts";
 var addFieldsToSchema = (schema, fields) => {
-  const schemaExtension = Schema14.partial(Schema14.Struct(fields));
-  return Schema14.extend(schema, schemaExtension).annotations(schema.ast.annotations);
+  const schemaExtension = Schema11.partial(Schema11.Struct(fields));
+  return Schema11.extend(schema, schemaExtension).annotations(schema.ast.annotations);
 };
 var updateFieldsInSchema = (schema, fields) => {
   const ast = schema.ast;
-  invariant18(SchemaAST10.isTypeLiteral(ast), void 0, {
-    F: __dxlog_file18,
+  invariant16(SchemaAST7.isTypeLiteral(ast), void 0, {
+    F: __dxlog_file16,
     L: 29,
     S: void 0,
     A: [
@@ -3318,7 +2207,7 @@ var updateFieldsInSchema = (schema, fields) => {
   const updatedProperties = [
     ...ast.propertySignatures
   ];
-  const propertiesToUpdate = Schema14.partial(Schema14.Struct(fields)).ast.propertySignatures;
+  const propertiesToUpdate = Schema11.partial(Schema11.Struct(fields)).ast.propertySignatures;
   for (const property of propertiesToUpdate) {
     const index = updatedProperties.findIndex((p) => p.name === property.name);
     if (index !== -1) {
@@ -3327,15 +2216,15 @@ var updateFieldsInSchema = (schema, fields) => {
       updatedProperties.push(property);
     }
   }
-  return Schema14.make(new SchemaAST10.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
+  return Schema11.make(new SchemaAST7.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
 };
 var removeFieldsFromSchema = (schema, fieldNames) => {
-  return Schema14.make(SchemaAST10.omit(schema.ast, fieldNames)).annotations(schema.ast.annotations);
+  return Schema11.make(SchemaAST7.omit(schema.ast, fieldNames)).annotations(schema.ast.annotations);
 };
 var updateFieldNameInSchema = (schema, { before, after }) => {
   const ast = schema.ast;
-  invariant18(SchemaAST10.isTypeLiteral(ast), void 0, {
-    F: __dxlog_file18,
+  invariant16(SchemaAST7.isTypeLiteral(ast), void 0, {
+    F: __dxlog_file16,
     L: 57,
     S: void 0,
     A: [
@@ -3343,12 +2232,12 @@ var updateFieldNameInSchema = (schema, { before, after }) => {
       ""
     ]
   });
-  return Schema14.make(new SchemaAST10.TypeLiteral(ast.propertySignatures.map((p) => p.name === before ? new SchemaAST10.PropertySignature(after, p.type, p.isOptional, p.isReadonly, p.annotations) : p), ast.indexSignatures, ast.annotations));
+  return Schema11.make(new SchemaAST7.TypeLiteral(ast.propertySignatures.map((p) => p.name === before ? new SchemaAST7.PropertySignature(after, p.type, p.isOptional, p.isReadonly, p.annotations) : p), ast.indexSignatures, ast.annotations));
 };
 var setTypenameInSchema = (schema, typename) => {
   const existingAnnotation = schema.ast.annotations[TypeAnnotationId];
-  invariant18(existingAnnotation, `Missing ${String(TypeAnnotationId)}`, {
-    F: __dxlog_file18,
+  invariant16(existingAnnotation, `Missing ${String(TypeAnnotationId)}`, {
+    F: __dxlog_file16,
     L: 77,
     S: void 0,
     A: [
@@ -3363,37 +2252,42 @@ var setTypenameInSchema = (schema, typename) => {
       typename,
       version: existingAnnotation.version
     },
-    [SchemaAST10.JSONSchemaAnnotationId]: {
-      ...schema.ast.annotations[SchemaAST10.JSONSchemaAnnotationId] ?? {},
-      $id: schema.ast.annotations[TypeIdentifierAnnotationId] ?? DXN9.fromTypename(typename).toString(),
+    [SchemaAST7.JSONSchemaAnnotationId]: {
+      ...schema.ast.annotations[SchemaAST7.JSONSchemaAnnotationId] ?? {},
+      $id: schema.ast.annotations[TypeIdentifierAnnotationId] ?? DXN7.fromTypename(typename).toString(),
       typename
     }
   });
 };
 
-// src/internal/schema/persistent-schema.ts
-import * as Schema15 from "effect/Schema";
-var PersistentSchema = Schema15.Struct({
-  name: Schema15.optional(Schema15.String),
+// src/internal/Type/persistent-schema.ts
+import * as Schema12 from "effect/Schema";
+var PersistentSchema = Schema12.Struct({
+  name: Schema12.optional(Schema12.String),
   typename: TypenameSchema,
   version: VersionSchema,
   jsonSchema: JsonSchemaType
 }).pipe(EchoObjectSchema({
-  typename: "dxos.org/type/Schema",
+  typename: "org.dxos.type.schema",
   version: "0.1.0"
+}), LabelAnnotation.set([
+  "name"
+]), IconAnnotation.set({
+  icon: "ph--brackets-curly--regular",
+  hue: "blue"
 }));
 
-// src/internal/schema/echo-schema.ts
-var __dxlog_file19 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/schema/echo-schema.ts";
+// src/internal/Type/echo-schema.ts
+var __dxlog_file17 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Type/echo-schema.ts";
 var ImmutableSchema = class {
   _schema;
   _objectAnnotation;
   constructor(_schema) {
     this._schema = _schema;
     this._objectAnnotation = getTypeAnnotation(this._schema);
-    invariant19(this._objectAnnotation, void 0, {
-      F: __dxlog_file19,
-      L: 48,
+    invariant17(this._objectAnnotation, void 0, {
+      F: __dxlog_file17,
+      L: 49,
       S: this,
       A: [
         "this._objectAnnotation",
@@ -3404,7 +2298,7 @@ var ImmutableSchema = class {
   //
   // Effect Schema (push to abstract base class).
   //
-  get [Schema16.TypeId]() {
+  get [Schema13.TypeId]() {
     return schemaVariance2;
   }
   get Type() {
@@ -3457,9 +2351,9 @@ var ImmutableSchema = class {
 var EchoSchemaConstructor = () => {
   return class {
     static get _schema() {
-      return Schema16.Union(PersistentSchema, Schema16.instanceOf(EchoSchema)).annotations(PersistentSchema.ast.annotations);
+      return Schema13.Union(PersistentSchema, Schema13.instanceOf(EchoSchema)).annotations(PersistentSchema.ast.annotations);
     }
-    static [Schema16.TypeId] = schemaVariance2;
+    static [Schema13.TypeId] = schemaVariance2;
     static get ast() {
       const schema = this._schema;
       return schema.ast;
@@ -3488,7 +2382,7 @@ var EchoSchema = class extends EchoSchemaConstructor() {
   _isDirty = true;
   /**
   * Schema kind key that marks this as an ECHO schema.
-  * Makes EchoSchema satisfy the Type.Obj.Any type.
+  * Makes EchoSchema satisfy the Type.AnyObj type.
   */
   [SchemaKindId] = EntityKind.Object;
   constructor(_persistentSchema) {
@@ -3497,7 +2391,7 @@ var EchoSchema = class extends EchoSchemaConstructor() {
   //
   // Effect Schema (push to abstract base class).
   //
-  get [Schema16.TypeId]() {
+  get [Schema13.TypeId]() {
     return schemaVariance2;
   }
   get Type() {
@@ -3553,9 +2447,9 @@ var EchoSchema = class extends EchoSchemaConstructor() {
   * Returns a mutable schema.
   */
   get mutable() {
-    invariant19(!this.readonly, "Schema is not mutable", {
-      F: __dxlog_file19,
-      L: 278,
+    invariant17(!this.readonly, "Schema is not mutable", {
+      F: __dxlog_file17,
+      L: 279,
       S: this,
       A: [
         "!this.readonly",
@@ -3594,9 +2488,9 @@ var EchoSchema = class extends EchoSchemaConstructor() {
   }
   getProperties() {
     const ast = this._getSchema().ast;
-    invariant19(SchemaAST11.isTypeLiteral(ast), void 0, {
-      F: __dxlog_file19,
-      L: 313,
+    invariant17(SchemaAST8.isTypeLiteral(ast), void 0, {
+      F: __dxlog_file17,
+      L: 314,
       S: this,
       A: [
         "SchemaAST.isTypeLiteral(ast)",
@@ -3686,7 +2580,7 @@ var EchoSchema = class extends EchoSchemaConstructor() {
   */
   _rebuild() {
     if (this._isDirty || this._schema == null) {
-      this._schema = toEffectSchema(getSnapshot(this._persistentSchema.jsonSchema));
+      this._schema = toEffectSchema(getSnapshot(this._persistentSchema).jsonSchema);
       this._isDirty = false;
     }
   }
@@ -3696,12 +2590,12 @@ var EchoSchema = class extends EchoSchemaConstructor() {
   }
 };
 var unwrapOptionality = (property) => {
-  if (!SchemaAST11.isUnion(property.type)) {
+  if (!SchemaAST8.isUnion(property.type)) {
     return property;
   }
   return {
     ...property,
-    type: property.type.types.find((type) => !SchemaAST11.isUndefinedKeyword(type))
+    type: property.type.types.find((type) => !SchemaAST8.isUndefinedKeyword(type))
   };
 };
 
@@ -3714,75 +2608,28 @@ export {
   foreignKey,
   foreignKeyEquals,
   compareForeignKeys,
-  VersionTypeId,
-  getLabel,
-  setLabel,
-  getDescription,
-  setDescription,
-  makeEchoTypeSchema,
-  ATTR_RELATION_SOURCE,
-  RelationSourceId,
-  RelationSourceDXNId,
-  ATTR_RELATION_TARGET,
-  RelationTargetId,
-  RelationTargetDXNId,
-  EchoRelationSchema,
   ATTR_SELF_DXN,
   SelfDXNId,
   ATTR_DELETED,
   ObjectDeletedId,
   ObjectVersionId,
   ObjectDatabaseId,
-  assertObjectModel,
-  EchoObjectSchema,
-  getObjectDXN,
-  getDXN,
-  getDatabase,
+  ATTR_RELATION_SOURCE,
+  RelationSourceId,
+  RelationSourceDXNId,
+  ATTR_RELATION_TARGET,
+  RelationTargetId,
+  RelationTargetDXNId,
+  VersionTypeId,
+  compare,
+  sortByLabel,
+  sortByTypename,
+  sort,
   getMetaChecked,
   getKeys,
   deleteKeys,
   addTag,
   removeTag,
-  compare,
-  sortByLabel,
-  sortByTypename,
-  sort,
-  isVersion,
-  version,
-  versionValid,
-  compareVersions,
-  encodeVersion,
-  decodeVersion,
-  CustomAnnotations,
-  DecodedAnnotations,
-  EchoAnnotations,
-  JsonSchemaEchoAnnotations,
-  JsonSchemaFields,
-  JsonSchemaType,
-  getSchemaProperty,
-  setSchemaProperty,
-  ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
-  ECHO_ANNOTATIONS_NS_KEY,
-  getNormalizedEchoAnnotations,
-  normalizeSchema,
-  JSON_SCHEMA_ECHO_REF_ID,
-  getSchemaReference,
-  createSchemaReference,
-  getReferenceAst,
-  RefTypeId,
-  Ref,
-  createEchoReferenceSchema,
-  RefImpl,
-  setRefResolver,
-  getRefSavedTarget,
-  refFromEncodedReference,
-  StaticRefResolver,
-  RefArray,
-  PropType,
-  toPropType,
-  toJsonSchema,
-  toEffectSchema,
-  makeTypedEntityClass,
   EventId,
   ChangeId,
   batchEvents,
@@ -3820,6 +2667,21 @@ export {
   makeObject,
   subscribe,
   change,
+  assertObjectModel,
+  getObjectDXN,
+  getDXN,
+  getDatabase,
+  makeEchoTypeSchema,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  isVersion,
+  version,
+  versionValid,
+  compareVersions,
+  encodeVersion,
+  decodeVersion,
+  normalizeSchema,
+  makeTypedEntityClass,
   objectToJSON,
   objectFromJSON,
   setRefResolverOnData,
@@ -3839,9 +2701,9 @@ export {
   ImmutableSchema,
   isMutable,
   EchoSchema,
-  JsonPath2 as JsonPath,
+  JsonPath,
   JsonProp,
   getValue,
   splitJsonPath
 };
-//# sourceMappingURL=chunk-5U5F4AWK.mjs.map
+//# sourceMappingURL=chunk-MFJPOZDU.mjs.map