@dxos/echo 0.8.4-main.fffef41 → 0.8.4-staging.ac66bdf99f

package/dist/lib/neutral/chunk-MOR5ERFM.mjs

@@ -0,0 +1,2834 @@
+import {
+  JsonSchemaFields,
+  JsonSchemaType,
+  toEffectSchema,
+  toJsonSchema
+} from "./chunk-JUXPFOEI.mjs";
+import {
+  Ref,
+  refFromEncodedReference,
+  setRefResolver
+} from "./chunk-G3IQMKF7.mjs";
+import {
+  ATTR_PARENT,
+  ATTR_TYPE,
+  IconAnnotation,
+  LabelAnnotation,
+  ParentId,
+  SchemaId,
+  SchemaMetaSymbol,
+  TypeAnnotationId,
+  TypeId,
+  TypeIdentifierAnnotationId,
+  TypenameSchema,
+  VersionSchema,
+  getEntityKind,
+  getLabel,
+  getSchema,
+  getSchemaDXN,
+  getSchemaTypename,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypeIdentifierAnnotation,
+  getTypename,
+  setSchema,
+  setTypename
+} from "./chunk-2KHZ36F5.mjs";
+import {
+  EntityKind,
+  KindId,
+  SchemaKindId,
+  SnapshotKindId,
+  makeTypeJsonSchemaAnnotation
+} from "./chunk-TBKX6JQO.mjs";
+
+// src/internal/index.ts
+import { JsonPath, JsonProp, getValue, splitJsonPath } from "@dxos/effect";
+
+// src/internal/common/types/base.ts
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+var RawObject = (schema) => {
+  return Schema.make(SchemaAST.omit(schema.ast, [
+    "id"
+  ]));
+};
+
+// 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/common/types/meta.ts";
+var ATTR_META = "@meta";
+var MetaId = /* @__PURE__ */ Symbol.for("@dxos/echo/Meta");
+var ObjectMetaSchema = Schema2.Struct({
+  keys: Schema2.Array(ForeignKey),
+  /**
+  * A set of tags.
+  * Tags are arbitrary application-defined strings.
+  * ECHO makes no assumptions about the tag structure.
+  */
+  // 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: 54,
+    S: void 0,
+    A: [
+      "metadata",
+      "'ObjectMeta not found.'"
+    ]
+  });
+  return metadata;
+};
+var foreignKey = (source, id) => ({
+  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/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/Annotation/sorting.ts
+var compare = (a, b) => {
+  if (a == null) {
+    return b == null ? 0 : 1;
+  }
+  if (b == null) {
+    return -1;
+  }
+  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;
+      }
+    }
+    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 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/common/proxy/symbols.ts
+var EventId = /* @__PURE__ */ Symbol.for("@dxos/live-object/EventId");
+var ChangeId = /* @__PURE__ */ Symbol.for("@dxos/live-object/ChangeId");
+
+// 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/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;
+  }
+};
+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/common/proxy/define-hidden-property.ts
+var defineHiddenProperty = (object, key, value2) => {
+  Object.defineProperty(object, key, {
+    enumerable: false,
+    configurable: true,
+    value: value2
+  });
+};
+
+// 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: 64,
+      S: this,
+      A: [
+        "sourceDXN instanceof DXN",
+        ""
+      ]
+    });
+    result[ATTR_RELATION_SOURCE] = sourceDXN.toString();
+  }
+  if (this[RelationTargetDXNId]) {
+    const targetDXN = this[RelationTargetDXNId];
+    invariant3(targetDXN instanceof DXN, void 0, {
+      F: __dxlog_file3,
+      L: 69,
+      S: this,
+      A: [
+        "targetDXN instanceof DXN",
+        ""
+      ]
+    });
+    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();
+    }
+    return recurse(value2);
+  });
+};
+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 (Array.isArray(value2)) {
+    return true;
+  }
+  return typeof value2 === "object" && Object.getPrototypeOf(value2) === Object.prototype;
+};
+var getProxySlot = (proxy) => {
+  const value2 = proxy[symbolIsProxy];
+  invariant4(value2 instanceof ProxyHandlerSlot, void 0, {
+    F: __dxlog_file4,
+    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() {
+    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);
+        }
+      });
+    }
+  }
+};
+
+// 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 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;
+  }
+  visited.add(actualValue);
+  const existingOwner = getOwner(actualValue);
+  const isRootEchoObject = EventId in actualValue;
+  let newAllowedPreviousOwner = allowedPreviousOwner;
+  if (isRootEchoObject && depth === 0) {
+    newAllowedPreviousOwner = actualValue;
+  }
+  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: 101,
+      S: void 0,
+      A: [
+        "ownershipAllowed",
+        "'Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.'"
+      ]
+    });
+  }
+  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 {
+    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);
+        }
+      }
+    }
+  }
+};
+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;
+  }
+  visited.add(actualValue);
+  if (visitor(actualValue)) {
+    return true;
+  }
+  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;
+        }
+      }
+    }
+  }
+  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) => {
+  invariant5(depth < MAX_OWNER_DEPTH, "Owner chain too deep - possible circular ownership", {
+    F: __dxlog_file5,
+    L: 220,
+    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);
+  }
+  return target;
+};
+var notifyOwnerChain = (target) => {
+  const owner = getOwner(target);
+  if (owner) {
+    queueOwnerNotification(getEchoRoot(owner));
+    notifyOwnerChain(owner);
+  }
+};
+
+// src/internal/common/proxy/proxy-types.ts
+var objectData = /* @__PURE__ */ Symbol.for("@dxos/live-object/objectData");
+
+// 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;
+  }
+  if (!isInChangeContext(echoRoot)) {
+    throw createArrayMethodError(method);
+  }
+};
+var ReactiveArray = class extends Array {
+  static get [Symbol.species]() {
+    return Array;
+  }
+  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;
+        }
+      });
+    }
+  }
+};
+
+// 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 {
+  /**
+  * 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(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));
+    }
+  }
+  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;
+    }
+  }
+  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);
+      }
+    }
+    return schema;
+  }
+  static getTargetPropertySchema(target, prop) {
+    const schema = target[SchemaId];
+    invariant6(schema, "target has no schema", {
+      F: __dxlog_file6,
+      L: 84,
+      S: this,
+      A: [
+        "schema",
+        "'target has no schema'"
+      ]
+    });
+    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 Schema3.Any;
+    }
+    invariant6(propertyType, `invalid property: ${prop.toString()}`, {
+      F: __dxlog_file6,
+      L: 95,
+      S: this,
+      A: [
+        "propertyType",
+        "`invalid property: ${prop.toString()}`"
+      ]
+    });
+    return Schema3.make(propertyType);
+  }
+};
+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: [
+        "property === 'length'",
+        "`invalid array property: ${String(property)}`"
+      ]
+    });
+    return Schema3.Number;
+  }
+  if (elementIndex < tupleAst.elements.length) {
+    const elementType = tupleAst.elements[elementIndex].type;
+    return Schema3.make(elementType).annotations(elementType.annotations);
+  }
+  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 [];
+  }
+  if (typeAstList.length === 1) {
+    return SchemaAST2.getPropertySignatures(typeAstList[0]);
+  }
+  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: [
+      "typeIndex !== -1",
+      "'discriminator field not set on target'"
+    ]
+  });
+  return SchemaAST2.getPropertySignatures(typeAstList[typeIndex]);
+};
+var getPropertyType = (ast, propertyName, getTargetPropertyFn) => {
+  const anyOrObject = unwrapAst(ast, (candidate) => SchemaAST2.isAnyKeyword(candidate) || SchemaAST2.isObjectKeyword(candidate));
+  if (anyOrObject != null) {
+    return ast;
+  }
+  const typeOrDiscriminatedUnion = unwrapAst(ast, (t) => {
+    return SchemaAST2.isTypeLiteral(t) || SchemaAST2.isUnion(t) && t.types.some((t2) => SchemaAST2.isTypeLiteral(t2));
+  });
+  if (typeOrDiscriminatedUnion == null) {
+    return null;
+  }
+  const targetProperty = getProperties(typeOrDiscriminatedUnion, getTargetPropertyFn).find((p) => p.name === propertyName);
+  if (targetProperty != null) {
+    return unwrapAst(targetProperty.type);
+  }
+  const indexSignatureType = unwrapAst(ast, SchemaAST2.isTypeLiteral);
+  if (indexSignatureType && SchemaAST2.isTypeLiteral(indexSignatureType) && indexSignatureType.indexSignatures.length > 0) {
+    return unwrapAst(indexSignatureType.indexSignatures[0].type);
+  }
+  return null;
+};
+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: [
+      "isDiscriminatedUnion",
+      "'type ambiguity: every type in a union must have a single unique-literal field'"
+    ]
+  });
+  return discriminatorPropCandidates;
+};
+var unwrapAst = (rootAst, predicate) => {
+  let ast = rootAst;
+  while (ast != null) {
+    if (predicate?.(ast)) {
+      return ast;
+    }
+    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 {
+      return predicate == null ? ast : null;
+    }
+  }
+  return null;
+};
+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: [
+      "SchemaAST.isTypeLiteral(schema.ast)",
+      ""
+    ]
+  });
+  const idProperty = SchemaAST2.getPropertySignatures(schema.ast).find((prop) => prop.name === "id");
+  if (idProperty != null) {
+    throw new Error('"id" property name is reserved');
+  }
+};
+
+// 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 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;
+  }
+  if (Array.isArray(actualValue)) {
+    const copy2 = new ReactiveArray();
+    visited.set(actualValue, copy2);
+    for (const item of actualValue) {
+      copy2.push(deepCopy(item, visited));
+    }
+    return copy2;
+  }
+  const copy = {};
+  visited.set(actualValue, copy);
+  for (const key of Object.keys(actualValue)) {
+    copy[key] = deepCopy(actualValue[key], visited);
+  }
+  copyHiddenProperties(actualValue, copy);
+  return copy;
+};
+var copyHiddenProperties = (source, target) => {
+  if (SchemaId in source) {
+    defineHiddenProperty(target, SchemaId, source[SchemaId]);
+  }
+  if (TypeId in source) {
+    defineHiddenProperty(target, TypeId, source[TypeId]);
+  }
+};
+var TypedReactiveHandler = class _TypedReactiveHandler {
+  static instance = new _TypedReactiveHandler();
+  _proxyMap = /* @__PURE__ */ new WeakMap();
+  _inSet = false;
+  constructor() {
+  }
+  init(target) {
+    invariant7(typeof target === "object" && target !== null, void 0, {
+      F: __dxlog_file7,
+      L: 145,
+      S: this,
+      A: [
+        "typeof target === 'object' && target !== null",
+        ""
+      ]
+    });
+    invariant7(SchemaId in target, "Schema is not defined for the target", {
+      F: __dxlog_file7,
+      L: 146,
+      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 Event());
+    }
+    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)
+    });
+  }
+  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;
+  }
+  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;
+  }
+  ownKeys(target) {
+    return Reflect.ownKeys(target);
+  }
+  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;
+  }
+  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;
+  }
+  /**
+  * 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.");
+      }
+    }
+    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
+    };
+  }
+  _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;
+  }
+  _inspect(_, options, inspectFn) {
+    const inspected = inspectFn(this, {
+      ...options,
+      showHidden: false,
+      customInspect: false
+    });
+    return `Typed ${inspected}`;
+  }
+};
+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);
+      }
+    }
+  }
+};
+var prepareTypedTarget = (target, schema) => {
+  if (!SchemaAST3.isTypeLiteral(schema.ast)) {
+    throw new Error("schema has to describe an object type");
+  }
+  SchemaValidator.validateSchema(schema);
+  const _ = Schema4.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]);
+    }
+  }
+};
+
+// 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 (!schema) {
+    throw new Error("Schema is required for reactive objects. Use Atom for untyped reactive state.");
+  }
+  const parent = obj[ParentId];
+  if (parent !== void 0) {
+    delete obj[ParentId];
+  }
+  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;
+};
+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();
+  }
+};
+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);
+  }
+  return () => {
+  };
+};
+var change = (obj, callback) => {
+  const changeFn = obj[ChangeId];
+  if (changeFn) {
+    changeFn(callback);
+  } else {
+    callback(obj);
+  }
+};
+
+// 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: [
+        "!(obj[RelationSourceId] instanceof DXN)",
+        "'Invalid object model: source pointer is a DXN'"
+      ]
+    });
+    invariant8(!(obj[RelationTargetId] instanceof DXN2), "Invalid object model: target pointer is a DXN", {
+      F: __dxlog_file8,
+      L: 107,
+      S: this,
+      A: [
+        "!(obj[RelationTargetId] instanceof DXN)",
+        "'Invalid object model: target pointer is a DXN'"
+      ]
+    });
+  }
+}
+
+// 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: [
+        "object[SelfDXNId] instanceof DXN",
+        "'Invalid object model: invalid self dxn'"
+      ]
+    });
+    return object[SelfDXNId];
+  }
+  if (!ObjectId3.isValid(object.id)) {
+    throw new TypeError("Object id is not valid.");
+  }
+  return DXN3.fromLocalObjectId(object.id);
+};
+
+// 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: 19,
+    S: void 0,
+    A: [
+      "dxn != null",
+      "'Invalid entity.'"
+    ]
+  });
+  return dxn;
+};
+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: 36,
+      S: void 0,
+      A: [
+        "typeof TypeAnnotationId === 'symbol'",
+        "'Sanity.'"
+      ]
+    });
+    invariant11(SchemaAST4.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+      F: __dxlog_file11,
+      L: 37,
+      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."));
+  }
+  if (getEntityKind(target) !== EntityKind.Object) {
+    raise(new Error("Target schema must be an echo object schema."));
+  }
+  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 typename = getSchemaTypename(schema);
+  if (!typename) {
+    throw new Error("Schema must have a typename");
+  }
+  return DXN4.fromTypename(typename).toString();
+};
+
+// src/internal/Entity/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;
+};
+var version = (entity) => {
+  const ver = entity[ObjectVersionId];
+  if (ver === void 0) {
+    return unversioned;
+  }
+  return ver;
+};
+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 (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return "different";
+  }
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return "different";
+  }
+  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 go = (schema) => {
+  if (typeof schema !== "object" || schema === null) {
+    return;
+  }
+  if (schema.exclusiveMaximum === true) {
+    schema.exclusiveMaximum = schema.maximum;
+    delete schema.exclusiveMaximum;
+  } else if (schema.exclusiveMaximum === false) {
+    delete schema.exclusiveMaximum;
+  }
+  if (schema.exclusiveMinimum === true) {
+    schema.exclusiveMinimum = schema.minimum;
+    delete schema.exclusiveMinimum;
+  } else if (schema.exclusiveMinimum === false) {
+    delete schema.exclusiveMinimum;
+  }
+  for (const key of Object.keys(schema)) {
+    if (!JsonSchemaFields.includes(key)) {
+      delete schema[key];
+    }
+  }
+  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);
+  }
+  if (schema.$defs) {
+    goOnRecord(schema.$defs);
+  }
+  if (schema.reference) {
+    go(schema.reference.schema);
+  }
+};
+var maybeGoOnArray = (value2) => {
+  if (Array.isArray(value2)) {
+    for (const item of value2) {
+      go(item);
+    }
+  } else if (typeof value2 === "object" && value2 !== null) {
+    go(value2);
+  }
+};
+var goOnRecord = (record) => {
+  for (const key of Object.keys(record)) {
+    go(record[key]);
+  }
+};
+
+// 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 schemaVariance = {
+  _A: (_) => _,
+  _I: (_) => _,
+  _R: (_) => _
+};
+
+// 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, inspectCustom2);
+  if (descriptor) {
+    return;
+  }
+  Object.defineProperty(obj, inspectCustom2, {
+    value: typedObjectInspectFunction,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+};
+var typedObjectInspectFunction = function(depth, options, inspect) {
+  const { id, ...props } = this;
+  return inspect({
+    id,
+    [ATTR_TYPE]: getTypeDXN(this),
+    ...props,
+    [ATTR_META]: this[MetaId]
+  }, options);
+};
+
+// 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 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_file13 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/json-serializer.ts";
+var objectToJSON = (obj) => {
+  const typename = getTypeDXN(obj)?.toString();
+  invariant13(typename && typeof typename === "string", void 0, {
+    F: __dxlog_file13,
+    L: 66,
+    S: void 0,
+    A: [
+      "typename && typeof typename === 'string'",
+      ""
+    ]
+  });
+  return typedJsonSerializer.call(obj);
+};
+var objectFromJSON = async (jsonData, { refResolver, dxn, database, parent } = {}) => {
+  assumeType4(jsonData);
+  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);
+  invariant13(schema === void 0 || Schema10.isSchema(schema), void 0, {
+    F: __dxlog_file13,
+    L: 97,
+    S: void 0,
+    A: [
+      "schema === undefined || Schema.isSchema(schema)",
+      ""
+    ]
+  });
+  const decodedInput = stripInternalJsonKeys(jsonData);
+  let obj;
+  if (schema != null) {
+    obj = await schema.pipe(Schema10.decodeUnknownPromise)(decodedInput);
+    if (refResolver) {
+      setRefResolverOnData(obj, refResolver);
+    }
+  } else {
+    obj = decodeGeneric(decodedInput, {
+      refResolver
+    });
+  }
+  invariant13(ObjectId4.isValid(obj.id), "Invalid object id", {
+    F: __dxlog_file13,
+    L: 110,
+    S: void 0,
+    A: [
+      "ObjectId.isValid(obj.id)",
+      "'Invalid object id'"
+    ]
+  });
+  setTypename(obj, type);
+  if (schema) {
+    setSchema(obj, schema);
+  }
+  const isRelation = typeof jsonData[ATTR_RELATION_SOURCE] === "string" || typeof jsonData[ATTR_RELATION_TARGET] === "string";
+  if (isRelation) {
+    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);
+    defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
+    defineHiddenProperty(obj, RelationTargetDXNId, targetDxn);
+    defineHiddenProperty(obj, RelationSourceId, source);
+    defineHiddenProperty(obj, RelationTargetId, target);
+  } else {
+    defineHiddenProperty(obj, KindId, EntityKind.Object);
+  }
+  if (typeof jsonData[ATTR_META] === "object") {
+    const meta = await ObjectMetaSchema.pipe(Schema10.decodeUnknownPromise)(jsonData[ATTR_META]);
+    invariant13(Array.isArray(meta.keys), void 0, {
+      F: __dxlog_file13,
+      L: 136,
+      S: void 0,
+      A: [
+        "Array.isArray(meta.keys)",
+        ""
+      ]
+    });
+    defineHiddenProperty(obj, MetaId, meta);
+  } else {
+    defineHiddenProperty(obj, MetaId, {
+      keys: []
+    });
+  }
+  if (jsonData[ATTR_PARENT]) {
+    const parentDxn = DXN5.parse(jsonData[ATTR_PARENT]);
+    const resolvedParent = await refResolver?.resolve(parentDxn);
+    defineHiddenProperty(obj, ParentId, resolvedParent);
+  } else if (parent) {
+    defineHiddenProperty(obj, ParentId, parent);
+  }
+  if (dxn) {
+    defineHiddenProperty(obj, SelfDXNId, dxn);
+  }
+  if (database) {
+    defineHiddenProperty(obj, ObjectDatabaseId, database);
+  }
+  assertObjectModel(obj);
+  invariant13(obj[ATTR_TYPE] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 161,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_TYPE] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant13(obj[ATTR_META] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 162,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_META] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant13(obj[ATTR_DELETED] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 163,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_DELETED] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant13(obj[ATTR_SELF_DXN] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 164,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_SELF_DXN] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant13(obj[ATTR_RELATION_SOURCE] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 165,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_RELATION_SOURCE] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant13(obj[ATTR_RELATION_TARGET] === void 0, "Invalid object model", {
+    F: __dxlog_file13,
+    L: 166,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_RELATION_TARGET] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  return obj;
+};
+var decodeGeneric = (jsonData, options) => {
+  const props = stripInternalJsonKeys(jsonData);
+  return deepMapValues2(props, (value2, visitor) => {
+    if (isEncodedReference(value2)) {
+      return refFromEncodedReference(value2, options.refResolver);
+    }
+    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)) {
+      setRefResolver(value2, refResolver);
+    } else {
+      visitValues(value2, visitor);
+    }
+  };
+  visitor(obj);
+};
+var objectStructureToJson = (objectId, structure) => {
+  return {
+    ...structure.data,
+    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/Obj/create-object.ts
+var createObject = (schema, props) => {
+  const annotation = getTypeAnnotation(schema);
+  if (!annotation) {
+    throw new Error("Schema is not an ECHO schema");
+  }
+  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 ?? ObjectId5.random()
+  };
+  const kind = RelationSourceId in props ? EntityKind.Relation : EntityKind.Object;
+  defineHiddenProperty(obj, KindId, kind);
+  defineHiddenProperty(obj, MetaId, {
+    keys: []
+  });
+  setSchema(obj, schema);
+  setTypename(obj, getSchemaDXN(schema) ?? failedInvariant("Missing schema DXN"));
+  attachTypedJsonSerializer(obj);
+  attachedTypedObjectInspector(obj);
+  if (kind === EntityKind.Relation) {
+    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);
+  }
+  assertObjectModel(obj);
+  return obj;
+};
+
+// src/internal/Obj/deleted.ts
+var isDeleted = (obj) => {
+  if (obj[ObjectDeletedId] === void 0) {
+    return false;
+  }
+  return obj[ObjectDeletedId] ?? false;
+};
+
+// 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/Obj/set-value.ts
+import * as Match from "effect/Match";
+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 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) => {
+  invariant14(path.length > 0, "Path must not be empty", {
+    F: __dxlog_file14,
+    L: 27,
+    S: void 0,
+    A: [
+      "path.length > 0",
+      "'Path must not be empty'"
+    ]
+  });
+  const schema = getSchema(obj);
+  invariant14(schema != null, "Object must have a schema", {
+    F: __dxlog_file14,
+    L: 30,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object must have a schema'"
+    ]
+  });
+  let parent = obj;
+  let currentAST = schema.ast;
+  for (let i = 0; i < path.length - 1; i++) {
+    const part = path[i];
+    const key = typeof part === "number" ? part : String(part);
+    if (parent[key] === void 0) {
+      const propertyAST = getPropertyAST(currentAST, String(part));
+      const shouldBeArray = propertyAST ? isArrayType(propertyAST) : false;
+      if (shouldBeArray) {
+        parent[key] = [];
+      } else {
+        const objWithDefaults = createObjectWithDefaults(propertyAST);
+        parent[key] = objWithDefaults;
+      }
+    }
+    parent = parent[key];
+    currentAST = getPropertyAST(currentAST, String(part));
+  }
+  const finalKey = path[path.length - 1];
+  parent[finalKey] = value2;
+  return value2;
+};
+var getPropertyAST = (ast, propertyName) => {
+  if (!ast) {
+    return void 0;
+  }
+  if (isNestedType(ast)) {
+    const properties = getProperties2(ast);
+    const property = properties.find((p) => p.name.toString() === propertyName);
+    if (property) {
+      return getBaseType(property).type;
+    }
+  }
+  if (isArrayType(ast)) {
+    const elementType = getArrayElementType(ast);
+    return elementType;
+  }
+  return void 0;
+};
+var getRequiredProperties = (ast) => {
+  if (!ast) {
+    return [];
+  }
+  if (!isNestedType(ast)) {
+    return [];
+  }
+  const properties = getProperties2(ast);
+  return properties.filter((p) => !p.isOptional);
+};
+var getDefaultValueForType = (ast) => {
+  if (!ast) {
+    return void 0;
+  }
+  const defaultValue = SchemaAST6.getDefaultAnnotation(ast);
+  if (Option.isSome(defaultValue)) {
+    return defaultValue.value;
+  }
+  return Match.value(ast).pipe(Match.when({
+    _tag: "StringKeyword"
+  }, () => ""), Match.when({
+    _tag: "NumberKeyword"
+  }, () => 0), Match.when({
+    _tag: "BooleanKeyword"
+  }, () => false), Match.orElse(() => void 0));
+};
+var createObjectWithDefaults = (ast) => {
+  if (!ast) {
+    return {};
+  }
+  const requiredProps = getRequiredProperties(ast);
+  const obj = {};
+  for (const prop of requiredProps) {
+    const defaultValue = getDefaultValueForType(prop.type);
+    if (defaultValue !== void 0) {
+      obj[prop.name] = defaultValue;
+    } else if (isNestedType(prop.type)) {
+      obj[prop.name] = createObjectWithDefaults(prop.type);
+    }
+  }
+  return obj;
+};
+
+// src/internal/Obj/snapshot.ts
+import { assertArgument as assertArgument7 } from "@dxos/invariant";
+import { deepMapValues as deepMapValues3 } from "@dxos/util";
+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: finalValue,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+};
+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;
+    }
+    return recurse(value2);
+  });
+  if (obj != null && typeof obj === "object" && KindId in obj) {
+    snapshot[SnapshotKindId] = obj[KindId];
+  }
+  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/Obj/clone.ts
+import { invariant as invariant15 } from "@dxos/invariant";
+import { deepMapValues as deepMapValues4 } from "@dxos/util";
+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);
+  invariant15(schema != null, "Object should have a schema", {
+    F: __dxlog_file15,
+    L: 21,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object should have a schema'"
+    ]
+  });
+  const props = deepMapValues4(data, (value2, recurse) => {
+    if (Ref.isRef(value2)) {
+      if (opts?.deep) {
+        return Ref.make(clone(value2.target, opts));
+      }
+      return value2;
+    }
+    return recurse(value2);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = deepMapValues4(getMeta(obj), (value2, recurse) => {
+    if (Ref.isRef(value2)) {
+      if (opts?.deep) {
+        return Ref.make(clone(value2.target, opts));
+      }
+      return value2;
+    }
+    return recurse(value2);
+  });
+  return makeObject(schema, props, meta);
+};
+
+// src/internal/Query.ts
+var prettyFilter = (filter) => {
+  switch (filter.type) {
+    case "object": {
+      const parts = [];
+      if (filter.typename !== null) {
+        parts.push(String(filter.typename));
+      }
+      if (filter.id !== void 0 && filter.id.length > 0) {
+        parts.push(`id: [${filter.id.join(", ")}]`);
+      }
+      const propEntries = Object.entries(filter.props);
+      if (propEntries.length > 0) {
+        const propsStr = propEntries.map(([k, v]) => `${k}: ${prettyFilter(v)}`).join(", ");
+        parts.push(`{ ${propsStr} }`);
+      }
+      if (filter.foreignKeys !== void 0 && filter.foreignKeys.length > 0) {
+        parts.push(`foreignKeys: [${filter.foreignKeys.map((fk) => JSON.stringify(fk)).join(", ")}]`);
+      }
+      return parts.length > 0 ? `Filter.type(${parts.join(", ")})` : "Filter.everything()";
+    }
+    case "compare":
+      return `Filter.${filter.operator}(${JSON.stringify(filter.value)})`;
+    case "in":
+      return `Filter.in([${filter.values.map((v) => JSON.stringify(v)).join(", ")}])`;
+    case "contains":
+      return `Filter.contains(${JSON.stringify(filter.value)})`;
+    case "tag":
+      return `Filter.tag(${JSON.stringify(filter.tag)})`;
+    case "range":
+      return `Filter.range(${JSON.stringify(filter.from)}, ${JSON.stringify(filter.to)})`;
+    case "text-search":
+      return filter.searchKind ? `Filter.textSearch(${JSON.stringify(filter.text)}, ${JSON.stringify(filter.searchKind)})` : `Filter.textSearch(${JSON.stringify(filter.text)})`;
+    case "timestamp":
+      return `Filter.${filter.field}.${filter.operator}(${filter.value})`;
+    case "child-of":
+      return `Filter.childOf([${filter.parents.map((p) => JSON.stringify(p)).join(", ")}], { transitive: ${filter.transitive} })`;
+    case "not":
+      return `Filter.not(${prettyFilter(filter.filter)})`;
+    case "and":
+      return `Filter.and(${filter.filters.map(prettyFilter).join(", ")})`;
+    case "or":
+      return `Filter.or(${filter.filters.map(prettyFilter).join(", ")})`;
+  }
+};
+var prettyQuery = (query) => {
+  switch (query.type) {
+    case "select":
+      return `Query.select(${prettyFilter(query.filter)})`;
+    case "filter":
+      return `${prettyQuery(query.selection)}.select(${prettyFilter(query.filter)})`;
+    case "reference-traversal":
+      return `${prettyQuery(query.anchor)}.reference(${JSON.stringify(query.property)})`;
+    case "incoming-references": {
+      const args = [];
+      if (query.typename !== null) {
+        args.push(String(query.typename));
+      }
+      if (query.property !== null) {
+        args.push(JSON.stringify(query.property));
+      }
+      return `${prettyQuery(query.anchor)}.referencedBy(${args.join(", ")})`;
+    }
+    case "relation": {
+      const method = query.direction === "outgoing" ? "sourceOf" : query.direction === "incoming" ? "targetOf" : "relationOf";
+      const filterStr = query.filter !== void 0 ? prettyFilter(query.filter) : "";
+      return `${prettyQuery(query.anchor)}.${method}(${filterStr})`;
+    }
+    case "relation-traversal":
+      return `${prettyQuery(query.anchor)}.${query.direction}()`;
+    case "hierarchy-traversal":
+      return query.direction === "to-parent" ? `${prettyQuery(query.anchor)}.parent()` : `${prettyQuery(query.anchor)}.children()`;
+    case "union":
+      return `Query.all(${query.queries.map(prettyQuery).join(", ")})`;
+    case "set-difference":
+      return `Query.without(${prettyQuery(query.source)}, ${prettyQuery(query.exclude)})`;
+    case "order": {
+      const orders = query.order.map((o) => {
+        if (o.kind === "natural") {
+          return "Order.natural()";
+        } else if (o.kind === "rank") {
+          return `Order.rank(${JSON.stringify(o.direction)})`;
+        } else {
+          return `Order.property(${JSON.stringify(o.property)}, ${JSON.stringify(o.direction)})`;
+        }
+      });
+      return `${prettyQuery(query.query)}.orderBy(${orders.join(", ")})`;
+    }
+    case "options": {
+      const opts = query.options;
+      const parts = [];
+      if (opts.deleted !== void 0) {
+        parts.push(`deleted: ${JSON.stringify(opts.deleted)}`);
+      }
+      return `${prettyQuery(query.query)}.options({ ${parts.join(", ")} })`;
+    }
+    case "from": {
+      if (query.from._tag === "scope") {
+        const scope = query.from.scope;
+        const parts = [];
+        if (scope.spaceIds !== void 0) {
+          parts.push(`spaceIds: [${scope.spaceIds.map((s) => JSON.stringify(s)).join(", ")}]`);
+        }
+        if (scope.queues !== void 0) {
+          parts.push(`queues: [${scope.queues.map(String).join(", ")}]`);
+        }
+        if (scope.allQueuesFromSpaces !== void 0) {
+          parts.push(`allQueuesFromSpaces: ${scope.allQueuesFromSpaces}`);
+        }
+        return `${prettyQuery(query.query)}.from({ ${parts.join(", ")} })`;
+      }
+      return `${prettyQuery(query.query)}.from(${prettyQuery(query.from.query)})`;
+    }
+    case "limit":
+      return `${prettyQuery(query.query)}.limit(${query.limit})`;
+  }
+};
+
+// 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/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 = Schema11.partial(Schema11.Struct(fields));
+  return Schema11.extend(schema, schemaExtension).annotations(schema.ast.annotations);
+};
+var updateFieldsInSchema = (schema, fields) => {
+  const ast = schema.ast;
+  invariant16(SchemaAST7.isTypeLiteral(ast), void 0, {
+    F: __dxlog_file16,
+    L: 29,
+    S: void 0,
+    A: [
+      "SchemaAST.isTypeLiteral(ast)",
+      ""
+    ]
+  });
+  const updatedProperties = [
+    ...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) {
+      updatedProperties[index] = property;
+    } else {
+      updatedProperties.push(property);
+    }
+  }
+  return Schema11.make(new SchemaAST7.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
+};
+var removeFieldsFromSchema = (schema, fieldNames) => {
+  return Schema11.make(SchemaAST7.omit(schema.ast, fieldNames)).annotations(schema.ast.annotations);
+};
+var updateFieldNameInSchema = (schema, { before, after }) => {
+  const ast = schema.ast;
+  invariant16(SchemaAST7.isTypeLiteral(ast), void 0, {
+    F: __dxlog_file16,
+    L: 57,
+    S: void 0,
+    A: [
+      "SchemaAST.isTypeLiteral(ast)",
+      ""
+    ]
+  });
+  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];
+  invariant16(existingAnnotation, `Missing ${String(TypeAnnotationId)}`, {
+    F: __dxlog_file16,
+    L: 77,
+    S: void 0,
+    A: [
+      "existingAnnotation",
+      "`Missing ${String(TypeAnnotationId)}`"
+    ]
+  });
+  return schema.annotations({
+    ...schema.ast.annotations,
+    [TypeAnnotationId]: {
+      kind: existingAnnotation.kind,
+      typename,
+      version: existingAnnotation.version
+    },
+    [SchemaAST7.JSONSchemaAnnotationId]: {
+      ...schema.ast.annotations[SchemaAST7.JSONSchemaAnnotationId] ?? {},
+      $id: schema.ast.annotations[TypeIdentifierAnnotationId] ?? DXN7.fromTypename(typename).toString(),
+      typename
+    }
+  });
+};
+
+// 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: "org.dxos.type.schema",
+  version: "0.1.0"
+}), LabelAnnotation.set([
+  "name"
+]), IconAnnotation.set({
+  icon: "ph--database--regular",
+  hue: "green"
+}));
+
+// 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);
+    invariant17(this._objectAnnotation, void 0, {
+      F: __dxlog_file17,
+      L: 48,
+      S: this,
+      A: [
+        "this._objectAnnotation",
+        ""
+      ]
+    });
+  }
+  //
+  // Effect Schema (push to abstract base class).
+  //
+  get [Schema13.TypeId]() {
+    return schemaVariance2;
+  }
+  get Type() {
+    return this._schema.Type;
+  }
+  get Encoded() {
+    return this._schema.Encoded;
+  }
+  get Context() {
+    return this._schema.Context;
+  }
+  get ast() {
+    return this._schema.ast;
+  }
+  get annotations() {
+    return this._schema.annotations;
+  }
+  get pipe() {
+    return this._schema.pipe;
+  }
+  //
+  // TypedObject
+  //
+  get kind() {
+    return this._objectAnnotation.kind;
+  }
+  get typename() {
+    return this._objectAnnotation.typename;
+  }
+  get version() {
+    return this._objectAnnotation.version;
+  }
+  //
+  // BaseSchema
+  //
+  get readonly() {
+    return true;
+  }
+  get snapshot() {
+    return this._schema;
+  }
+  // TODO(burdon): Change from getter since this is expensive.
+  get jsonSchema() {
+    return toJsonSchema(this._schema);
+  }
+  get mutable() {
+    throw new Error("Schema is readonly.");
+  }
+};
+var EchoSchemaConstructor = () => {
+  return class {
+    static get _schema() {
+      return Schema13.Union(PersistentSchema, Schema13.instanceOf(EchoSchema)).annotations(PersistentSchema.ast.annotations);
+    }
+    static [Schema13.TypeId] = schemaVariance2;
+    static get ast() {
+      const schema = this._schema;
+      return schema.ast;
+    }
+    static get annotations() {
+      const schema = this._schema;
+      return schema.annotations.bind(schema);
+    }
+    static get pipe() {
+      const schema = this._schema;
+      return schema.pipe.bind(schema);
+    }
+  };
+};
+var isMutable = (schema) => {
+  return schema instanceof EchoSchema;
+};
+var schemaVariance2 = {
+  _A: (_) => _,
+  _I: (_) => _,
+  _R: (_) => _
+};
+var EchoSchema = class extends EchoSchemaConstructor() {
+  _persistentSchema;
+  _schema;
+  _isDirty = true;
+  /**
+  * Schema kind key that marks this as an ECHO schema.
+  * Makes EchoSchema satisfy the Type.AnyObj type.
+  */
+  [SchemaKindId] = EntityKind.Object;
+  constructor(_persistentSchema) {
+    super(), this._persistentSchema = _persistentSchema;
+  }
+  //
+  // Effect Schema (push to abstract base class).
+  //
+  get [Schema13.TypeId]() {
+    return schemaVariance2;
+  }
+  get Type() {
+    return this._persistentSchema;
+  }
+  get Encoded() {
+    return this._persistentSchema;
+  }
+  get Context() {
+    const schema = this._getSchema();
+    return schema.Context;
+  }
+  get ast() {
+    const schema = this._getSchema();
+    return schema.ast;
+  }
+  get annotations() {
+    const schema = this._getSchema();
+    return schema.annotations.bind(schema);
+  }
+  get pipe() {
+    const schema = this._getSchema();
+    return schema.pipe.bind(schema);
+  }
+  //
+  // BaseSchema
+  //
+  get kind() {
+    return EntityKind.Object;
+  }
+  get typename() {
+    return this._persistentSchema.typename;
+  }
+  get version() {
+    return this._persistentSchema.version;
+  }
+  get readonly() {
+    return false;
+  }
+  /**
+  * Returns an immutable schema snapshot of the current state of the schema.
+  */
+  get snapshot() {
+    return this._getSchema();
+  }
+  /**
+  * Returns the JSON schema for the schema.
+  */
+  get jsonSchema() {
+    return this._persistentSchema.jsonSchema;
+  }
+  /**
+  * Returns a mutable schema.
+  */
+  get mutable() {
+    invariant17(!this.readonly, "Schema is not mutable", {
+      F: __dxlog_file17,
+      L: 278,
+      S: this,
+      A: [
+        "!this.readonly",
+        "'Schema is not mutable'"
+      ]
+    });
+    return this;
+  }
+  //
+  // Mutable Schema
+  //
+  /**
+  * Id of the ECHO object containing the schema.
+  */
+  get id() {
+    return this._persistentSchema.id;
+  }
+  /**
+  * Short name of the schema.
+  */
+  get name() {
+    return this._persistentSchema.name;
+  }
+  get [SchemaMetaSymbol]() {
+    return {
+      id: this.id,
+      typename: this.typename,
+      version: this._persistentSchema.version
+    };
+  }
+  /**
+  * Reference to the underlying persistent schema object.
+  */
+  get persistentSchema() {
+    return this._persistentSchema;
+  }
+  getProperties() {
+    const ast = this._getSchema().ast;
+    invariant17(SchemaAST8.isTypeLiteral(ast), void 0, {
+      F: __dxlog_file17,
+      L: 313,
+      S: this,
+      A: [
+        "SchemaAST.isTypeLiteral(ast)",
+        ""
+      ]
+    });
+    return [
+      ...ast.propertySignatures
+    ].filter((p) => p.name !== "id").map(unwrapOptionality);
+  }
+  //
+  // Mutation methods.
+  // TODO(burdon): Create separate interface for dynamic schema.
+  // TODO(burdon): Deprecate direct manipulation? Use JSONSchema directly.
+  //
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  updateTypename(typename) {
+    const updated = setTypenameInSchema(this._getSchema(), typename);
+    this._change((schema) => {
+      schema.typename = typename;
+      schema.jsonSchema = toJsonSchema(updated);
+    });
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  addFields(fields) {
+    const extended = addFieldsToSchema(this._getSchema(), fields);
+    this._change((schema) => {
+      schema.jsonSchema = toJsonSchema(extended);
+    });
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  updateFields(fields) {
+    const updated = updateFieldsInSchema(this._getSchema(), fields);
+    this._change((schema) => {
+      schema.jsonSchema = toJsonSchema(updated);
+    });
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  updateFieldPropertyName({ before, after }) {
+    const renamed = updateFieldNameInSchema(this._getSchema(), {
+      before,
+      after
+    });
+    this._change((schema) => {
+      schema.jsonSchema = toJsonSchema(renamed);
+    });
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  removeFields(fieldNames) {
+    const removed = removeFieldsFromSchema(this._getSchema(), fieldNames);
+    this._change((schema) => {
+      schema.jsonSchema = toJsonSchema(removed);
+    });
+  }
+  /**
+  * Wrapper for Obj.change that handles the change context for the persistent schema.
+  */
+  _change(callback) {
+    const changeFn = this._persistentSchema[ChangeId];
+    if (changeFn) {
+      changeFn(callback);
+    } else {
+      callback(this._persistentSchema);
+    }
+  }
+  //
+  // Internals
+  //
+  /**
+  * Called by DatabaseSchemaRegistry on update.
+  */
+  _invalidate() {
+    this._isDirty = true;
+  }
+  /**
+  * Rebuilds this schema if it is dirty.
+  */
+  _rebuild() {
+    if (this._isDirty || this._schema == null) {
+      this._schema = toEffectSchema(getSnapshot(this._persistentSchema).jsonSchema);
+      this._isDirty = false;
+    }
+  }
+  _getSchema() {
+    this._rebuild();
+    return this._schema;
+  }
+};
+var unwrapOptionality = (property) => {
+  if (!SchemaAST8.isUnion(property.type)) {
+    return property;
+  }
+  return {
+    ...property,
+    type: property.type.types.find((type) => !SchemaAST8.isUndefinedKeyword(type))
+  };
+};
+
+export {
+  RawObject,
+  ATTR_META,
+  MetaId,
+  ObjectMetaSchema,
+  getMeta,
+  foreignKey,
+  foreignKeyEquals,
+  compareForeignKeys,
+  ATTR_SELF_DXN,
+  SelfDXNId,
+  ATTR_DELETED,
+  ObjectDeletedId,
+  ObjectVersionId,
+  ObjectDatabaseId,
+  ATTR_RELATION_SOURCE,
+  RelationSourceId,
+  RelationSourceDXNId,
+  ATTR_RELATION_TARGET,
+  RelationTargetId,
+  RelationTargetDXNId,
+  VersionTypeId,
+  compare,
+  sortByLabel,
+  sortByTypename,
+  sort,
+  getMetaChecked,
+  getKeys,
+  deleteKeys,
+  addTag,
+  removeTag,
+  EventId,
+  ChangeId,
+  batchEvents,
+  emitEvent,
+  enterChangeContext,
+  isInChangeContext,
+  queueNotification,
+  queueOwnerNotification,
+  hasPendingNotifications,
+  clearPendingNotifications,
+  executeChange,
+  defineHiddenProperty,
+  MutationOutsideChangeContextError,
+  createPropertySetError,
+  createPropertyDeleteError,
+  createArrayMethodError,
+  attachTypedJsonSerializer,
+  typedJsonSerializer,
+  symbolIsProxy,
+  isProxy,
+  isValidProxyTarget,
+  getProxySlot,
+  getProxyTarget,
+  getProxyHandler,
+  dangerouslySetProxyId,
+  createProxy,
+  setMetaOwner,
+  getEchoRoot,
+  objectData,
+  ReactiveArray,
+  SchemaValidator,
+  checkIdNotPresentOnSchema,
+  TypedReactiveHandler,
+  prepareTypedTarget,
+  makeObject,
+  subscribe,
+  change,
+  assertObjectModel,
+  getObjectDXN,
+  getDXN,
+  getDatabase,
+  makeEchoTypeSchema,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  isVersion,
+  version,
+  versionValid,
+  compareVersions,
+  encodeVersion,
+  decodeVersion,
+  normalizeSchema,
+  makeTypedEntityClass,
+  objectToJSON,
+  objectFromJSON,
+  setRefResolverOnData,
+  objectStructureToJson,
+  createObject,
+  isDeleted,
+  createQueueDXN,
+  setValue,
+  getSnapshot,
+  clone,
+  prettyFilter,
+  prettyQuery,
+  addFieldsToSchema,
+  updateFieldsInSchema,
+  removeFieldsFromSchema,
+  updateFieldNameInSchema,
+  setTypenameInSchema,
+  PersistentSchema,
+  ImmutableSchema,
+  isMutable,
+  EchoSchema,
+  JsonPath,
+  JsonProp,
+  getValue,
+  splitJsonPath
+};
+//# sourceMappingURL=chunk-MOR5ERFM.mjs.map