@dxos/echo 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/dist/lib/neutral/chunk-2HKGAQM4.mjs

@@ -0,0 +1,1394 @@
+import {
+  JsonSchemaType,
+  toEffectSchema
+} from "./chunk-4A2NWKRJ.mjs";
+import {
+  ChangeId,
+  EventId,
+  Ref,
+  change,
+  createEchoReferenceSchema,
+  createProxy,
+  getProxyTarget,
+  isProxy,
+  isReactiveRecord,
+  isValidProxyTarget,
+  normalizeSpliceRange,
+  symbolIsProxy,
+  symbolReactivePrototype
+} from "./chunk-L3E5IXAE.mjs";
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  ATTR_SELF_URI,
+  ATTR_TYPE,
+  Dictionary,
+  MetaId,
+  ObjectDeletedId,
+  ParentId,
+  RelationSourceDXNId,
+  RelationTargetDXNId,
+  SchemaId,
+  SelfURIId,
+  TypeAnnotationId,
+  TypeEntityId,
+  TypeId,
+  getDictionary,
+  getSchemaURI,
+  getTypeAnnotation
+} from "./chunk-3TN2VMI4.mjs";
+import {
+  EntityKind,
+  KindId,
+  SchemaKindId,
+  SnapshotKindId,
+  StaticTypeSchemaSlot,
+  makeTypeJsonSchemaAnnotation
+} from "./chunk-2ZHECXUR.mjs";
+
+// src/internal/common/types/well-known-types.ts
+import { DXN } from "@dxos/keys";
+var TagTypeDXN = DXN.make("org.dxos.type.tag", "0.1.0");
+
+// src/internal/common/types/meta.ts
+import * as Schema from "effect/Schema";
+import { ForeignKey } from "@dxos/echo-protocol";
+import { invariant } from "@dxos/invariant";
+import { DXN as DXN2 } from "@dxos/keys";
+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 TagRefSchema = Schema.suspend(() => (
+  // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.
+  createEchoReferenceSchema(void 0, DXN2.getName(TagTypeDXN), DXN2.getVersion(TagTypeDXN))
+));
+var EntityMetaSchema = Schema.Struct({
+  keys: Schema.Array(ForeignKey),
+  /**
+  * Tags applied to this entity, as references to {@link Tag} objects.
+  */
+  tags: Schema.Array(TagRefSchema),
+  /**
+  * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).
+  * Identifies the canonical registry entry the object instance was created from.
+  */
+  key: Schema.optional(Schema.String),
+  /**
+  * Semantic version of the registry entry the object was created from.
+  * Must be a valid semver string (e.g. `1.2.3`).
+  */
+  version: Schema.optional(Schema.String),
+  /**
+  * Dictionary of annotations to this entity.
+  */
+  annotations: Dictionary,
+  /**
+  * Unix ms timestamp when this entity was created.
+  * Read-only; sourced from the system section of the automerge document — not stored in meta.
+  */
+  createdAt: Schema.optional(Schema.Number),
+  /**
+  * Unix ms timestamp of the last automerge change on this entity's document.
+  * Read-only; derived from the automerge change graph — not stored in meta.
+  */
+  updatedAt: Schema.optional(Schema.Number)
+});
+var getMeta = (obj) => {
+  const metadata = obj[MetaId];
+  invariant(metadata, "EntityMeta not found.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 63, S: void 0, A: ["metadata", "'EntityMeta 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/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.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 9, 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.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 18, 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);
+  if (!meta.tags.some((existing) => existing.uri === tag.uri)) {
+    meta.tags.push(tag);
+  }
+};
+var removeTag = (entity, tag) => {
+  const meta = getMetaChecked(entity);
+  for (let i = 0; i < meta.tags.length; i++) {
+    if (meta.tags[i].uri === tag.uri) {
+      meta.tags.splice(i, 1);
+      i--;
+    }
+  }
+};
+
+// src/internal/Entity/guard.ts
+var isEntity = (value) => {
+  if (value == null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  return value[KindId] !== void 0;
+};
+var isSnapshot = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[SnapshotKindId] !== void 0;
+};
+
+// src/internal/Annotation/entity-dictionary.ts
+import * as Option from "effect/Option";
+import * as Schema2 from "effect/Schema";
+var get = (target, annotation) => {
+  if (isSnapshot(target)) {
+    return getDictionary(getMetaChecked(target).annotations, annotation);
+  }
+  if (isEntity(target)) {
+    const annotations2 = getMetaChecked(target).annotations;
+    return annotation.key in annotations2 ? Option.some(annotations2[annotation.key]) : Option.none();
+  }
+  throw new TypeError("Target is not an annotation target.");
+};
+var set = (target, annotation, value) => {
+  if (isEntity(target)) {
+    Schema2.validateSync(annotation.schema)(value);
+    getMetaChecked(target).annotations[annotation.key] = value;
+  } else {
+    throw new TypeError("Target is not an annotation target.");
+  }
+};
+var update = (target, annotation, mutator) => {
+  change(target, (mutable) => {
+    const current = get(mutable, annotation);
+    if (Option.isSome(current)) {
+      const value = current.value;
+      mutator(value);
+      Schema2.validateSync(annotation.schema)(value);
+    }
+  });
+};
+
+// src/internal/common/proxy/define-hidden-property.ts
+var defineHiddenProperty = (object, key, value) => {
+  Object.defineProperty(object, key, {
+    enumerable: false,
+    configurable: true,
+    value
+  });
+};
+
+// src/internal/common/proxy/json-serializer.ts
+import { invariant as invariant3 } from "@dxos/invariant";
+import { EID } from "@dxos/keys";
+import { deepMapValues, encodeUint8ArrayToJson } 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];
+  }
+  if (this[MetaId]) {
+    result[ATTR_META] = serializeMeta(this[MetaId]);
+  }
+  if (this[SelfURIId]) {
+    result[ATTR_SELF_URI] = this[SelfURIId];
+  }
+  if (this[RelationSourceDXNId]) {
+    const sourceDXN = this[RelationSourceDXNId];
+    invariant3(EID.isEID(sourceDXN), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 44, S: this, A: ["EID.isEID(sourceDXN)", ""] });
+    result[ATTR_RELATION_SOURCE] = sourceDXN;
+  }
+  if (this[RelationTargetDXNId]) {
+    const targetDXN = this[RelationTargetDXNId];
+    invariant3(EID.isEID(targetDXN), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 49, S: this, A: ["EID.isEID(targetDXN)", ""] });
+    result[ATTR_RELATION_TARGET] = targetDXN;
+  }
+  Object.assign(result, serializeData(rest));
+  return result;
+};
+var serializeData = (data) => {
+  return deepMapValues(data, (value, recurse) => {
+    if (Ref.isRef(value)) {
+      return value.noInline().encode();
+    }
+    if (value instanceof Uint8Array) {
+      return encodeUint8ArrayToJson(value);
+    }
+    return recurse(value);
+  });
+};
+var serializeMeta = (meta) => {
+  const { tags, annotations: annotations2, ...rest } = meta;
+  const compact = {
+    ...rest,
+    ...tags != null && tags.length > 0 ? {
+      tags
+    } : {},
+    ...annotations2 != null && Object.keys(annotations2).length > 0 ? {
+      annotations: annotations2
+    } : {}
+  };
+  return serializeData(compact);
+};
+
+// 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/errors.ts
+var MutationOutsideChangeContextError = class extends Error {
+  constructor(operation, suggestion) {
+    super(`Cannot ${operation} outside of Obj.update(). Use Obj.update(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/ownership.ts
+import { invariant as invariant4 } from "@dxos/invariant";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/ownership.ts";
+var EchoOwner = /* @__PURE__ */ Symbol.for("@dxos/echo/Owner");
+var getRawTarget = (value) => {
+  return isProxy(value) ? getProxyTarget(value) : value;
+};
+var getOwner = (value) => {
+  return value?.[EchoOwner];
+};
+var setMetaOwner = (metaTarget, parent) => {
+  defineHiddenProperty(metaTarget, EchoOwner, parent);
+};
+var setOwnerRecursive = (value, owner, options = {}) => {
+  const { visited = /* @__PURE__ */ new Set(), depth = 0, allowedPreviousOwner } = options;
+  if (value == null || typeof value !== "object") {
+    return;
+  }
+  const actualValue = getRawTarget(value);
+  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;
+    invariant4(ownershipAllowed, "Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 76, 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 = (value, visitor, visited = /* @__PURE__ */ new Set()) => {
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  const actualValue = getRawTarget(value);
+  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, value) => traverseObjectGraph(value, (v) => v === targetRoot);
+var hasForeignOwner = (value, target) => traverseObjectGraph(value, (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) => {
+  invariant4(depth < MAX_OWNER_DEPTH, "Owner chain too deep - possible circular ownership", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 169, 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 = 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 SchemaAST from "effect/SchemaAST";
+import { invariant as invariant5 } from "@dxos/invariant";
+var __dxlog_file5 = "/__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 (SchemaAST.isUnion(schema.ast)) {
+      const typeAstList = schema.ast.types.filter((type) => SchemaAST.isTypeLiteral(type));
+      if (typeAstList.length > 1) {
+        getTypeDiscriminators(typeAstList);
+      }
+      visitAll(typeAstList);
+    } else if (SchemaAST.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 (SchemaAST.isTypeLiteral(schema.ast)) {
+      visitAll(SchemaAST.getPropertySignatures(schema.ast).map((p) => p.type));
+    }
+  }
+  static hasTypeAnnotation(rootObjectSchema, property, annotation) {
+    try {
+      let type = this.getPropertySchema(rootObjectSchema, [
+        property
+      ]);
+      if (SchemaAST.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) {
+          const indexSignatureType = getIndexSignatureValueType(schema.ast);
+          if (indexSignatureType != null) {
+            schema = Schema3.make(indexSignatureType).annotations(indexSignatureType.annotations);
+            continue;
+          }
+          throw new TypeError(`Unknown property: ${formatPropertyPath([
+            ...propertyPath.slice(0, i),
+            propertyName
+          ])}`);
+        }
+        schema = Schema3.make(propertyType).annotations(propertyType.annotations);
+      }
+    }
+    return schema;
+  }
+  /**
+  * Rejects properties not declared on the schema. Types with index signatures allow extra keys.
+  */
+  static assertExactProperties(schema, value, getProperty = () => void 0, path = []) {
+    if (!isPlainRecord(value)) {
+      return;
+    }
+    const typeLiteral = resolveTypeLiteral(schema.ast, (propertyName) => getProperty([
+      ...path,
+      propertyName
+    ]));
+    if (typeLiteral == null) {
+      return;
+    }
+    const propertySignatures = SchemaAST.getPropertySignatures(typeLiteral);
+    const allowedKeys = new Set(propertySignatures.map((property) => String(property.name)));
+    const indexSignatureType = typeLiteral.indexSignatures[0]?.type;
+    for (const key of Object.keys(value)) {
+      const propertyPath = [
+        ...path,
+        key
+      ];
+      if (!allowedKeys.has(key)) {
+        if (indexSignatureType == null) {
+          throw new TypeError(`Unknown property: ${formatPropertyPath(propertyPath)}`);
+        }
+        const indexSchema = Schema3.make(indexSignatureType).annotations(indexSignatureType.annotations);
+        this.assertExactProperties(indexSchema, value[key], getProperty, propertyPath);
+        continue;
+      }
+      const propertySignature = propertySignatures.find((property) => String(property.name) === key);
+      invariant5(propertySignature, "Property signature must exist.", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 104, S: this, A: ["propertySignature", "'Property signature must exist.'"] });
+      const propertySchema = Schema3.make(propertySignature.type).annotations(propertySignature.type.annotations);
+      this.assertExactProperties(propertySchema, value[key], getProperty, propertyPath);
+    }
+  }
+  static getIndexedElementSchema(schema, index) {
+    const arrayAst = unwrapArray(schema.ast);
+    if (arrayAst != null) {
+      return getArrayElementSchema(arrayAst, index);
+    }
+    const unionAst = unwrapAst(schema.ast, (candidate) => SchemaAST.isUnion(candidate) && candidate.types.some((member) => unwrapArray(member) != null));
+    if (unionAst != null && SchemaAST.isUnion(unionAst)) {
+      for (const member of unionAst.types) {
+        const memberArrayAst = unwrapArray(member);
+        if (memberArrayAst != null) {
+          return getArrayElementSchema(memberArrayAst, index);
+        }
+      }
+    }
+    return null;
+  }
+  static getTargetPropertySchema(target, prop) {
+    const schema = target[SchemaId];
+    invariant5(schema, "target has no schema", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 127, S: this, A: ["schema", "'target has no schema'"] });
+    if (Array.isArray(target)) {
+      if (prop === "length") {
+        return Schema3.Number;
+      }
+      if (typeof prop !== "symbol") {
+        const indexedSchema = this.getIndexedElementSchema(schema, prop);
+        if (indexedSchema != null) {
+          return indexedSchema;
+        }
+      }
+      if (SchemaAST.isTypeLiteral(schema.ast)) {
+        return schema;
+      }
+    }
+    if (typeof prop === "number" || typeof prop === "string" && /^\d+$/.test(prop)) {
+      const indexedSchema = this.getIndexedElementSchema(schema, prop);
+      if (indexedSchema != null) {
+        return indexedSchema;
+      }
+    }
+    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) {
+      const indexSignatureType = getIndexSignatureValueType(schema.ast);
+      if (indexSignatureType != null) {
+        return Schema3.make(indexSignatureType).annotations(indexSignatureType.annotations);
+      }
+      throw new TypeError(`Unknown property: ${String(prop)}`);
+    }
+    return Schema3.make(propertyType).annotations(propertyType.annotations);
+  }
+};
+var getArrayElementSchema = (tupleAst, property) => {
+  const elementIndex = typeof property === "number" ? property : typeof property === "string" ? parseInt(property, 10) : Number.NaN;
+  if (Number.isNaN(elementIndex)) {
+    invariant5(property === "length", `invalid array property: ${String(property)}`, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 171, 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) => SchemaAST.isUnion(typeAst) ? typeAst.types.flatMap(flattenUnion) : [
+  typeAst
+];
+var getProperties = (typeAst, getTargetPropertyFn) => {
+  const astCandidates = flattenUnion(typeAst);
+  const typeAstList = astCandidates.filter((type) => SchemaAST.isTypeLiteral(type));
+  if (typeAstList.length === 0) {
+    return [];
+  }
+  if (typeAstList.length === 1) {
+    return SchemaAST.getPropertySignatures(typeAstList[0]);
+  }
+  const typeDiscriminators = getTypeDiscriminators(typeAstList);
+  const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
+  const typeIndex = typeDiscriminators.findIndex((p) => targetPropertyValue === p.type.literal);
+  invariant5(typeIndex !== -1, "discriminator field not set on target", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 196, S: void 0, A: ["typeIndex !== -1", "'discriminator field not set on target'"] });
+  return SchemaAST.getPropertySignatures(typeAstList[typeIndex]);
+};
+var getPropertyType = (ast, propertyName, getTargetPropertyFn) => {
+  const anyOrObject = unwrapAst(ast, (candidate) => SchemaAST.isAnyKeyword(candidate) || SchemaAST.isUnknownKeyword(candidate) || SchemaAST.isObjectKeyword(candidate));
+  if (anyOrObject != null) {
+    return ast;
+  }
+  const typeOrDiscriminatedUnion = unwrapAst(ast, (t) => {
+    return SchemaAST.isTypeLiteral(t) || SchemaAST.isUnion(t) && t.types.some((t2) => SchemaAST.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, SchemaAST.isTypeLiteral);
+  if (indexSignatureType && SchemaAST.isTypeLiteral(indexSignatureType) && indexSignatureType.indexSignatures.length > 0) {
+    return unwrapAst(indexSignatureType.indexSignatures[0].type);
+  }
+  return null;
+};
+var getTypeDiscriminators = (typeAstList) => {
+  const discriminatorPropCandidates = typeAstList.flatMap(SchemaAST.getPropertySignatures).filter((p) => SchemaAST.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;
+  invariant5(isDiscriminatedUnion, "type ambiguity: every type in a union must have a single unique-literal field", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 226, 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 (SchemaAST.isUnion(ast)) {
+      const next = ast.types.find((t) => predicate != null && predicate(t) || SchemaAST.isSuspend(t));
+      if (next != null) {
+        ast = next;
+        continue;
+      }
+    }
+    if (SchemaAST.isSuspend(ast)) {
+      ast = ast.f();
+    } else {
+      return predicate == null ? ast : null;
+    }
+  }
+  return null;
+};
+var unwrapArray = (ast) => unwrapAst(ast, SchemaAST.isTupleType);
+var getIndexSignatureValueType = (ast) => {
+  const typeLiteral = unwrapAst(ast, SchemaAST.isTypeLiteral);
+  if (typeLiteral == null || !SchemaAST.isTypeLiteral(typeLiteral) || typeLiteral.indexSignatures.length === 0) {
+    return null;
+  }
+  return unwrapAst(typeLiteral.indexSignatures[0].type);
+};
+var resolveTypeLiteral = (ast, getTargetPropertyFn) => {
+  const anyOrObject = unwrapAst(ast, (candidate) => SchemaAST.isAnyKeyword(candidate) || SchemaAST.isUnknownKeyword(candidate) || SchemaAST.isObjectKeyword(candidate));
+  if (anyOrObject != null) {
+    return null;
+  }
+  const typeOrDiscriminatedUnion = unwrapAst(ast, (type) => {
+    return SchemaAST.isTypeLiteral(type) || SchemaAST.isUnion(type) && type.types.some((member) => SchemaAST.isTypeLiteral(member));
+  });
+  if (typeOrDiscriminatedUnion == null) {
+    return null;
+  }
+  if (SchemaAST.isTypeLiteral(typeOrDiscriminatedUnion)) {
+    return typeOrDiscriminatedUnion;
+  }
+  if (!SchemaAST.isUnion(typeOrDiscriminatedUnion)) {
+    return null;
+  }
+  const typeAstList = typeOrDiscriminatedUnion.types.filter((type) => SchemaAST.isTypeLiteral(type));
+  if (typeAstList.length === 1) {
+    return typeAstList[0];
+  }
+  const typeDiscriminators = getTypeDiscriminators(typeAstList);
+  const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
+  const typeIndex = typeDiscriminators.findIndex((property) => targetPropertyValue === property.type.literal);
+  invariant5(typeIndex !== -1, "discriminator field not set on target", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 292, S: void 0, A: ["typeIndex !== -1", "'discriminator field not set on target'"] });
+  return typeAstList[typeIndex];
+};
+var isPlainRecord = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Uint8Array) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+var formatPropertyPath = (path) => path.map(String).join(".");
+var checkIdNotPresentOnSchema = (schema) => {
+  invariant5(SchemaAST.isTypeLiteral(schema.ast), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 304, S: void 0, A: ["SchemaAST.isTypeLiteral(schema.ast)", ""] });
+  const idProperty = SchemaAST.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
+import * as Schema4 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+import { Event } from "@dxos/async";
+import { inspectCustom } from "@dxos/debug";
+import { assertArgument as assertArgument2, invariant as invariant6 } from "@dxos/invariant";
+import { getDeep, setDeep } from "@dxos/util";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/typed-handler.ts";
+var deepCopy = (value, visited = /* @__PURE__ */ new Map()) => {
+  if (value == null || typeof value !== "object") {
+    return value;
+  }
+  const actualValue = getRawTarget(value);
+  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 !== Array.prototype && proto !== null && !isReactiveRecord(actualValue)) {
+    return value;
+  }
+  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 TypedObjectPrototype = Object.create(Object.prototype);
+defineHiddenProperty(TypedObjectPrototype, symbolReactivePrototype, true);
+Object.defineProperties(TypedObjectPrototype, {
+  // TODO(burdon): Remove?
+  [objectData]: {
+    get() {
+      return toJSON(getRawTarget(this));
+    }
+  },
+  [ChangeId]: {
+    // A function that runs a mutation inside a controlled change context. Only root objects (which
+    // own an `EventId`) expose one; nested records share their root's reactivity and return undefined.
+    get() {
+      const target = getRawTarget(this);
+      if (!(EventId in target)) {
+        return void 0;
+      }
+      return (callback) => executeChange(target, target, this, callback);
+    }
+  },
+  [StaticTypeSchemaSlot]: {
+    // Lazily rebuild the source Effect Schema from `jsonSchema` and cache it as an own (hidden)
+    // property so subsequent reads short-circuit this accessor; the set-trap deletes the cache when
+    // `jsonSchema` is mutated.
+    get() {
+      const target = getRawTarget(this);
+      const jsonSchema = target.jsonSchema;
+      if (jsonSchema == null) {
+        return void 0;
+      }
+      const rebuilt = toEffectSchema(jsonSchema);
+      defineHiddenProperty(target, StaticTypeSchemaSlot, rebuilt);
+      return rebuilt;
+    }
+  }
+});
+var isBehaviourAccessor = (target, prop) => {
+  let proto = Object.getPrototypeOf(target);
+  while (proto != null && proto !== Object.prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(proto, prop);
+    if (descriptor != null) {
+      return descriptor.get != null;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return false;
+};
+var assertMutableWithinChange = (echoRoot, prop) => {
+  const isInitialized = EventId in echoRoot;
+  if (isInitialized && typeof prop !== "symbol" && !isInChangeContext(echoRoot)) {
+    throw new Error(`Cannot modify object property "${String(prop)}" outside of Obj.update(). Use Obj.update(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
+  }
+  return isInitialized;
+};
+var compactMetadataToInstanceState = (target) => {
+  if (Array.isArray(target) || Object.getPrototypeOf(target) !== Object.prototype) {
+    return;
+  }
+  const state = Object.create(TypedObjectPrototype);
+  for (const symbol of Object.getOwnPropertySymbols(target)) {
+    Object.defineProperty(state, symbol, Object.getOwnPropertyDescriptor(target, symbol));
+    delete target[symbol];
+  }
+  Object.setPrototypeOf(target, state);
+};
+var TypedReactiveHandler = class _TypedReactiveHandler {
+  static instance = new _TypedReactiveHandler();
+  _proxyMap = /* @__PURE__ */ new WeakMap();
+  _inSet = false;
+  constructor() {
+  }
+  init(target) {
+    assertArgument2(typeof target === "object" && target !== null, "target");
+    invariant6(SchemaId in target, "Schema is not defined for the target", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 223, 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) {
+      for (const key in target) {
+        if (target[symbolIsProxy]) {
+          continue;
+        }
+        let value = target[key];
+        if (isValidProxyTarget(value) || isProxy(value)) {
+          if (hasForeignOwner(value, target)) {
+            value = deepCopy(value);
+            target[key] = value;
+          }
+          setOwnerRecursive(value, target);
+        }
+      }
+    }
+    Object.defineProperty(target, inspectCustom, {
+      enumerable: false,
+      configurable: true,
+      value: this._inspect.bind(target)
+    });
+    compactMetadataToInstanceState(target);
+  }
+  /**
+  * Hide the internal instance-state prototype so consumers see a plain object; arrays keep their
+  * real (ReactiveArray) prototype.
+  */
+  getPrototypeOf(target) {
+    return Array.isArray(target) ? Reflect.getPrototypeOf(target) : Object.prototype;
+  }
+  get(target, prop, receiver) {
+    if (typeof prop === "symbol" && isBehaviourAccessor(target, prop)) {
+      return Reflect.get(target, prop, receiver);
+    }
+    if (prop === TypeEntityId) {
+      return Reflect.get(target, prop, receiver);
+    }
+    if (Object.getOwnPropertyDescriptor(target, prop)?.get) {
+      return Reflect.get(target, prop, receiver);
+    }
+    const value = Reflect.get(target, prop, receiver);
+    if (isValidProxyTarget(value)) {
+      return createProxy(value, this);
+    }
+    return value;
+  }
+  set(target, prop, value, receiver) {
+    const echoRoot = getEchoRoot(target);
+    const isInitialized = assertMutableWithinChange(echoRoot, prop);
+    let result = false;
+    this._inSet = true;
+    try {
+      batchEvents(() => {
+        const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, prop, value);
+        result = Reflect.set(target, prop, preparedValue, receiver);
+        if (prop === "jsonSchema") {
+          Reflect.deleteProperty(target, StaticTypeSchemaSlot);
+        }
+        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 = 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 = assertMutableWithinChange(echoRoot, property);
+    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;
+  }
+  textUpdate(target, path, newText) {
+    this._applyTextMutation(target, path, () => newText);
+  }
+  textSplice(target, path, start, deleteCount, insert) {
+    let removed = "";
+    this._applyTextMutation(target, path, (current) => {
+      const range = normalizeSpliceRange(current.length, start, deleteCount);
+      removed = current.slice(range.start, range.start + range.deleteCount);
+      return current.slice(0, range.start) + insert + current.slice(range.start + range.deleteCount);
+    });
+    return removed;
+  }
+  /**
+  * Shared read-modify-write for the in-memory string CRDT path. Mirrors the `set` trap: enforce the
+  * change context, then mutate and notify through the same batched notification path so reactivity fires.
+  *
+  * Writes via `setDeep` on the raw target, intentionally bypassing `_prepareValueForAssignment` /
+  * `_validateValue`: a string CRDT delta produces a string, and per-delta schema checks (pattern,
+  * maxLength) would reject valid intermediate states during incremental edits. Such constraints are
+  * enforced at the initial assignment or as application-level invariants, mirroring the Automerge path.
+  */
+  _applyTextMutation(target, path, compute) {
+    const echoRoot = getEchoRoot(target);
+    if (!isInChangeContext(echoRoot)) {
+      throw new Error(`Cannot modify text at "${path.join(".")}" outside of Obj.update(). Use Obj.update(obj, () => { Text.splice(obj, path, ...); }) instead.`);
+    }
+    const keyPath = [
+      ...path
+    ];
+    invariant6(keyPath.length > 0, "Text path must be non-empty", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 380, S: this, A: ["keyPath.length > 0", "'Text path must be non-empty'"] });
+    const current = getDeep(target, keyPath);
+    if (typeof current !== "string") {
+      throw new TypeError(`Text mutation target at "${keyPath.join(".")}" is not a string.`);
+    }
+    const next = compute(current);
+    batchEvents(() => {
+      setDeep(target, keyPath, next);
+      queueNotification(echoRoot);
+      notifyOwnerChain(target);
+    });
+  }
+  /**
+  * Prepare a value for assignment to a typed object property.
+  * Handles cycle detection, copy-on-assign, array conversion, validation, and ownership.
+  */
+  _prepareValueForAssignment(target, prop, value) {
+    const echoRoot = getEchoRoot(target);
+    if (typeof prop === "symbol") {
+      return {
+        echoRoot,
+        preparedValue: value
+      };
+    }
+    if (isValidProxyTarget(value) || isProxy(value)) {
+      if (wouldCreateCycle(echoRoot, value)) {
+        throw new Error("Cannot create cycles in typed object graph. Consider using Ref for circular references.");
+      }
+    }
+    if (isValidProxyTarget(value) || isProxy(value)) {
+      const actualValue = getRawTarget(value);
+      const isRootEchoObject = EventId in actualValue;
+      if (isRootEchoObject) {
+        throw new Error("Object references must be wrapped with `Ref.make`");
+      }
+    }
+    if (isValidProxyTarget(value) || isProxy(value)) {
+      const actualValue = getRawTarget(value);
+      const existingOwner = getOwner(actualValue);
+      if (existingOwner != null && existingOwner !== echoRoot) {
+        value = deepCopy(value);
+      }
+    }
+    if (Array.isArray(value) && !(value instanceof ReactiveArray)) {
+      value = ReactiveArray.from(value);
+    }
+    const validatedValue = this._validateValue(target, prop, value);
+    if (isValidProxyTarget(validatedValue) || isProxy(validatedValue)) {
+      setOwnerRecursive(validatedValue, echoRoot);
+    }
+    return {
+      echoRoot,
+      preparedValue: validatedValue
+    };
+  }
+  _validateValue(target, prop, value) {
+    if (prop === ParentId) {
+      return value;
+    }
+    const schema = SchemaValidator.getTargetPropertySchema(target, prop);
+    const _ = Schema4.asserts(schema)(value);
+    SchemaValidator.assertExactProperties(schema, value, (path) => getDeep(value, path));
+    if (isValidProxyTarget(value)) {
+      setSchemaProperties(value, schema);
+    }
+    return value;
+  }
+  _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, typeSource) => {
+  const schemaType = getSchemaURI(schema);
+  if (schemaType != null) {
+    defineHiddenProperty(obj, TypeId, schemaType);
+  }
+  if (typeSource != null) {
+    defineHiddenProperty(obj, TypeEntityId, typeSource);
+    Object.defineProperty(obj, SchemaId, {
+      get: () => typeSource[StaticTypeSchemaSlot] ?? schema,
+      enumerable: false,
+      configurable: true
+    });
+  } else {
+    defineHiddenProperty(obj, SchemaId, schema);
+  }
+  if (Array.isArray(obj)) {
+    for (let index = 0; index < obj.length; index++) {
+      if (isValidProxyTarget(obj[index])) {
+        const elementSchema = SchemaValidator.getIndexedElementSchema(schema, index) ?? Schema4.Any;
+        setSchemaProperties(obj[index], elementSchema);
+      }
+    }
+    return;
+  }
+  for (const key in obj) {
+    if (isValidProxyTarget(obj[key])) {
+      let elementSchema;
+      try {
+        elementSchema = SchemaValidator.getTargetPropertySchema(obj, key);
+      } catch {
+        elementSchema = Schema4.Any;
+      }
+      setSchemaProperties(obj[key], elementSchema);
+    }
+  }
+};
+var prepareTypedTarget = (target, schema, typeSource) => {
+  if (!SchemaAST2.isTypeLiteral(schema.ast)) {
+    throw new Error("schema has to describe an object type");
+  }
+  SchemaValidator.validateSchema(schema);
+  const _ = Schema4.asserts(schema)(target);
+  SchemaValidator.assertExactProperties(schema, target, (path) => getDeep(target, path));
+  makeArraysReactive(target);
+  setSchemaProperties(target, schema, typeSource);
+};
+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
+import { EntityId } from "@dxos/keys";
+var makeObject = (schema, obj, meta, typeSource) => {
+  return createReactiveObject(Object.assign({}, obj), meta, schema, typeSource);
+};
+var createReactiveObject = (obj, meta, schema, typeSource) => {
+  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, typeSource);
+  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 (!EntityId.isValid(target.id)) {
+      throw new Error("Invalid object id format.");
+    }
+  } else {
+    target.id = EntityId.random();
+  }
+};
+var initMeta = (obj, meta) => {
+  const fullMeta = {
+    ...meta,
+    keys: meta?.keys ?? [],
+    tags: meta?.tags ?? [],
+    annotations: meta?.annotations ?? {}
+  };
+  prepareTypedTarget(fullMeta, EntityMetaSchema);
+  defineHiddenProperty(obj, MetaId, createProxy(fullMeta, TypedReactiveHandler.instance));
+};
+
+// src/internal/Entity/entity.ts
+import * as Schema5 from "effect/Schema";
+import * as SchemaAST3 from "effect/SchemaAST";
+import { DXN as DXN3, EntityId as EntityId2 } from "@dxos/keys";
+var TypeMetaSchemaDXN = DXN3.make("org.dxos.type.schema", "0.1.0");
+var persistentEntitySchema = (() => {
+  const typename = DXN3.getName(TypeMetaSchemaDXN);
+  const version = DXN3.getVersion(TypeMetaSchemaDXN);
+  const struct = Schema5.Struct({
+    name: Schema5.optional(Schema5.String),
+    jsonSchema: JsonSchemaType.pipe(Schema5.optional),
+    id: EntityId2
+  });
+  const ast = SchemaAST3.annotations(struct.ast, {
+    [TypeAnnotationId]: {
+      kind: EntityKind.Type,
+      typename,
+      version
+    },
+    [SchemaAST3.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+      kind: EntityKind.Type,
+      typename,
+      version
+    })
+  });
+  return Schema5.make(ast);
+})();
+var makeEchoTypeSchema = (fields, ast, typename, version, kind, computeJsonSchema, explicitId) => {
+  const sourceSchema = Schema5.make(ast);
+  const meta = {
+    keys: [],
+    key: typename,
+    version
+  };
+  const id = explicitId ?? EntityId2.deterministic(typename, version);
+  const entity = makeObject(persistentEntitySchema, {
+    id
+  }, meta);
+  const target = getProxyTarget(entity);
+  let memoizedJsonSchema;
+  Object.defineProperty(target, "jsonSchema", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return memoizedJsonSchema ??= computeJsonSchema();
+    },
+    set(value) {
+      memoizedJsonSchema = value;
+    }
+  });
+  defineHiddenProperty(target, StaticTypeSchemaSlot, sourceSchema);
+  defineHiddenProperty(target, SchemaKindId, kind);
+  Object.defineProperty(target, "fields", {
+    configurable: true,
+    enumerable: false,
+    get: () => fields
+  });
+  return entity;
+};
+
+// src/internal/common/atom-snapshot.ts
+var snapshotForComparison = (value) => {
+  if (Array.isArray(value)) {
+    return [
+      ...value
+    ];
+  }
+  if (value !== null && typeof value === "object") {
+    return {
+      ...value
+    };
+  }
+  return value;
+};
+
+export {
+  TagTypeDXN,
+  ATTR_META,
+  EntityMetaSchema,
+  getMeta,
+  foreignKey,
+  foreignKeyEquals,
+  compareForeignKeys,
+  getMetaChecked,
+  getKeys,
+  deleteKeys,
+  addTag,
+  removeTag,
+  isEntity,
+  get,
+  set,
+  update,
+  snapshotForComparison,
+  defineHiddenProperty,
+  attachTypedJsonSerializer,
+  typedJsonSerializer,
+  batchEvents,
+  emitEvent,
+  enterChangeContext,
+  isInChangeContext,
+  queueNotification,
+  queueOwnerNotification,
+  hasPendingNotifications,
+  clearPendingNotifications,
+  executeChange,
+  MutationOutsideChangeContextError,
+  createPropertySetError,
+  createPropertyDeleteError,
+  createArrayMethodError,
+  setMetaOwner,
+  getEchoRoot,
+  objectData,
+  ReactiveArray,
+  SchemaValidator,
+  checkIdNotPresentOnSchema,
+  TypedReactiveHandler,
+  prepareTypedTarget,
+  makeObject,
+  TypeMetaSchemaDXN,
+  makeEchoTypeSchema
+};
+//# sourceMappingURL=chunk-2HKGAQM4.mjs.map