@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/dist/lib/neutral/{chunk-MOR5ERFM.mjs → chunk-7FPIAJIV.mjs}

@@ -3,47 +3,70 @@ import {
   JsonSchemaType,
   toEffectSchema,
   toJsonSchema
-} from "./chunk-JUXPFOEI.mjs";
+} from "./chunk-7PI7C4EF.mjs";
+import {
+  ATTR_META,
+  EntityMetaSchema,
+  getMeta,
+  isEntity
+} from "./chunk-4ZUHOTCG.mjs";
 import {
   Ref,
+  RefTypeId,
+  loadRefTarget,
   refFromEncodedReference,
   setRefResolver
-} from "./chunk-G3IQMKF7.mjs";
+} from "./chunk-WTQJHC75.mjs";
 import {
+  ATTR_DELETED,
   ATTR_PARENT,
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
   ATTR_TYPE,
   IconAnnotation,
   LabelAnnotation,
+  MetaId,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  ObjectVersionId,
   ParentId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
   SchemaId,
-  SchemaMetaSymbol,
+  SelfURIId,
   TypeAnnotationId,
+  TypeEntityId,
   TypeId,
-  TypeIdentifierAnnotationId,
-  TypenameSchema,
-  VersionSchema,
+  assertObjectModel,
+  getDatabase,
   getEntityKind,
   getLabel,
+  getObjectEchoUri,
   getSchema,
-  getSchemaDXN,
   getSchemaTypename,
+  getSchemaURI,
+  getType,
   getTypeAnnotation,
-  getTypeDXN,
   getTypeIdentifierAnnotation,
+  getTypeURI,
   getTypename,
   setSchema,
+  setType,
   setTypename
-} from "./chunk-2KHZ36F5.mjs";
+} from "./chunk-R5W6DXR4.mjs";
 import {
   EntityKind,
   KindId,
   SchemaKindId,
   SnapshotKindId,
+  StaticTypeSchemaSlot,
+  getStaticTypeSchema,
   makeTypeJsonSchemaAnnotation
-} from "./chunk-TBKX6JQO.mjs";
-
-// src/internal/index.ts
-import { JsonPath, JsonProp, getValue, splitJsonPath } from "@dxos/effect";
+} from "./chunk-O6BH7EPN.mjs";
 
 // src/internal/common/types/base.ts
 import * as Schema from "effect/Schema";
@@ -54,60 +77,6 @@ var RawObject = (schema) => {
   ]));
 };
 
-// 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";
 
@@ -135,64 +104,6 @@ var sort = (...comparators) => {
   };
 };
 
-// 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");
@@ -282,7 +193,7 @@ var defineHiddenProperty = (object, key, 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.`);
+    super(`Cannot ${operation} outside of Obj.update(). Use Obj.update(obj, (mutableObj) => { ${suggestion} }) instead.`);
     this.name = "MutationOutsideChangeContextError";
   }
 };
@@ -297,10 +208,10 @@ var createArrayMethodError = (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";
+import { invariant } from "@dxos/invariant";
+import { EID } from "@dxos/keys";
+import { deepMapValues, encodeUint8ArrayToJson } from "@dxos/util";
+var __dxlog_file = "/__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) {
@@ -320,39 +231,23 @@ var typedJsonSerializer = function() {
     id
   };
   if (this[TypeId]) {
-    result[ATTR_TYPE] = this[TypeId].toString();
+    result[ATTR_TYPE] = this[TypeId];
   }
   if (this[MetaId]) {
     result[ATTR_META] = serializeMeta(this[MetaId]);
   }
-  if (this[SelfDXNId]) {
-    result[ATTR_SELF_DXN] = this[SelfDXNId].toString();
+  if (this[SelfURIId]) {
+    result[ATTR_SELF_URI] = this[SelfURIId];
   }
   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();
+    invariant(EID.isEID(sourceDXN), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 44, S: this, A: ["EID.isEID(sourceDXN)", ""] });
+    result[ATTR_RELATION_SOURCE] = sourceDXN;
   }
   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();
+    invariant(EID.isEID(targetDXN), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 49, S: this, A: ["EID.isEID(targetDXN)", ""] });
+    result[ATTR_RELATION_TARGET] = targetDXN;
   }
   Object.assign(result, serializeData(rest));
   return result;
@@ -362,19 +257,32 @@ var serializeData = (data) => {
     if (Ref.isRef(value2)) {
       return value2.noInline().encode();
     }
+    if (value2 instanceof Uint8Array) {
+      return encodeUint8ArrayToJson(value2);
+    }
     return recurse(value2);
   });
 };
 var serializeMeta = (meta) => {
-  return deepMapValues(meta, (value2, recurse) => recurse(value2));
+  const { tags, annotations: annotations5, ...rest } = meta;
+  const compact = {
+    ...rest,
+    ...tags != null && tags.length > 0 ? {
+      tags
+    } : {},
+    ...annotations5 != null && Object.keys(annotations5).length > 0 ? {
+      annotations: annotations5
+    } : {}
+  };
+  return serializeData(compact);
 };
 
 // src/internal/common/proxy/make-object.ts
-import { ObjectId } from "@dxos/keys";
+import { EntityId } 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";
+import { invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/__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) => {
@@ -388,15 +296,7 @@ var isValidProxyTarget = (value2) => {
 };
 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",
-      ""
-    ]
-  });
+  invariant2(value2 instanceof ProxyHandlerSlot, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 22, S: void 0, A: ["value instanceof ProxyHandlerSlot", ""] });
   return value2;
 };
 var getProxyTarget = (proxy) => {
@@ -430,15 +330,7 @@ var ProxyHandlerSlot = class {
     this._handler = _handler;
   }
   get handler() {
-    invariant4(this._handler, void 0, {
-      F: __dxlog_file4,
-      L: 91,
-      S: this,
-      A: [
-        "this._handler",
-        ""
-      ]
-    });
+    invariant2(this._handler, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 71, S: this, A: ["this._handler", ""] });
     return this._handler;
   }
   // TODO(burdon): Requires comment.
@@ -491,15 +383,15 @@ var ProxyHandlerSlot = class {
 };
 
 // src/internal/common/proxy/typed-handler.ts
-import * as Schema4 from "effect/Schema";
+import * as Schema3 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";
+import { assertArgument, invariant as invariant5 } 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";
+import { invariant as invariant3 } from "@dxos/invariant";
+var __dxlog_file3 = "/__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;
@@ -528,15 +420,7 @@ var setOwnerRecursive = (value2, owner, options = {}) => {
   }
   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.'"
-      ]
-    });
+    invariant3(ownershipAllowed, "Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, 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 = {
@@ -603,15 +487,7 @@ var hasForeignOwner = (value2, target) => traverseObjectGraph(value2, (v) => {
 });
 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'"
-    ]
-  });
+  invariant3(depth < MAX_OWNER_DEPTH, "Owner chain too deep - possible circular ownership", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 169, S: void 0, A: ["depth < MAX_OWNER_DEPTH", "'Owner chain too deep - possible circular ownership'"] });
   if (KindId in target) {
     return target;
   }
@@ -675,18 +551,18 @@ var ReactiveArray = class extends Array {
 };
 
 // src/internal/common/proxy/schema-validator.ts
-import * as Schema3 from "effect/Schema";
+import * as Schema2 from "effect/Schema";
 import * as SchemaAST2 from "effect/SchemaAST";
-import { invariant as invariant6 } from "@dxos/invariant";
+import { invariant as invariant4 } 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 __dxlog_file4 = "/__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)));
+    const visitAll = (nodes) => nodes.forEach((node) => this.validateSchema(Schema2.make(node)));
     if (SchemaAST2.isUnion(schema.ast)) {
       const typeAstList = schema.ast.types.filter((type) => SchemaAST2.isTypeLiteral(type));
       if (typeAstList.length > 1) {
@@ -733,70 +609,41 @@ var SchemaValidator = class {
           log.warn("unknown property", {
             path: propertyPath,
             property: propertyName
-          }, {
-            F: __dxlog_file6,
-            L: 71,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 60, S: this });
           continue;
         }
-        schema = Schema3.make(propertyType).annotations(propertyType.annotations);
+        schema = Schema2.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'"
-      ]
-    });
+    invariant4(schema, "target has no schema", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 73, 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);
+      return Schema2.Any;
+    }
+    invariant4(propertyType, `invalid property: ${prop.toString()}`, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 82, S: this, A: ["propertyType", "`invalid property: ${prop.toString()}`"] });
+    return Schema2.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;
+    invariant4(property === "length", `invalid array property: ${String(property)}`, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 93, S: void 0, A: ["property === 'length'", "`invalid array property: ${String(property)}`"] });
+    return Schema2.Number;
   }
   if (elementIndex < tupleAst.elements.length) {
     const elementType = tupleAst.elements[elementIndex].type;
-    return Schema3.make(elementType).annotations(elementType.annotations);
+    return Schema2.make(elementType).annotations(elementType.annotations);
   }
   const restType = tupleAst.rest;
-  return Schema3.make(restType[0].type).annotations(restType[0].annotations);
+  return Schema2.make(restType[0].type).annotations(restType[0].annotations);
 };
 var flattenUnion = (typeAst) => SchemaAST2.isUnion(typeAst) ? typeAst.types.flatMap(flattenUnion) : [
   typeAst
@@ -813,15 +660,7 @@ var getProperties = (typeAst, getTargetPropertyFn) => {
   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'"
-    ]
-  });
+  invariant4(typeIndex !== -1, "discriminator field not set on target", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 118, S: void 0, A: ["typeIndex !== -1", "'discriminator field not set on target'"] });
   return SchemaAST2.getPropertySignatures(typeAstList[typeIndex]);
 };
 var getPropertyType = (ast, propertyName, getTargetPropertyFn) => {
@@ -851,15 +690,7 @@ var getTypeDiscriminators = (typeAstList) => {
   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'"
-    ]
-  });
+  invariant4(isDiscriminatedUnion, "type ambiguity: every type in a union must have a single unique-literal field", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 148, 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) => {
@@ -885,15 +716,7 @@ var unwrapAst = (rootAst, predicate) => {
 };
 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)",
-      ""
-    ]
-  });
+  invariant4(SchemaAST2.isTypeLiteral(schema.ast), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 184, 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');
@@ -901,7 +724,7 @@ var checkIdNotPresentOnSchema = (schema) => {
 };
 
 // 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 __dxlog_file5 = "/__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;
@@ -954,24 +777,8 @@ var TypedReactiveHandler = class _TypedReactiveHandler {
   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'"
-      ]
-    });
+    assertArgument(typeof target === "object" && target !== null, "target");
+    invariant5(SchemaId in target, "Schema is not defined for the target", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 101, 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());
@@ -1013,6 +820,22 @@ var TypedReactiveHandler = class _TypedReactiveHandler {
         }
         return (callback) => executeChange(target, target, receiver, callback);
       }
+      case TypeEntityId: {
+        return Reflect.get(target, prop, receiver);
+      }
+      case StaticTypeSchemaSlot: {
+        const existing = Reflect.get(target, prop, receiver);
+        if (existing !== void 0) {
+          return existing;
+        }
+        const jsonSchema = target.jsonSchema;
+        if (jsonSchema == null) {
+          return void 0;
+        }
+        const rebuilt = toEffectSchema(jsonSchema);
+        defineHiddenProperty(target, StaticTypeSchemaSlot, rebuilt);
+        return rebuilt;
+      }
     }
     if (Object.getOwnPropertyDescriptor(target, prop)?.get) {
       return Reflect.get(target, prop, receiver);
@@ -1028,7 +851,7 @@ var TypedReactiveHandler = class _TypedReactiveHandler {
     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.`);
+      throw new Error(`Cannot modify object property "${String(prop)}" outside of Obj.update(). Use Obj.update(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
     }
     let result = false;
     this._inSet = true;
@@ -1036,6 +859,9 @@ var TypedReactiveHandler = class _TypedReactiveHandler {
       batchEvents(() => {
         const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, prop, value2);
         result = Reflect.set(target, prop, preparedValue, receiver);
+        if (prop === "jsonSchema") {
+          Reflect.deleteProperty(target, StaticTypeSchemaSlot);
+        }
         if (isInitialized) {
           queueNotification(echoRoot);
           notifyOwnerChain(target);
@@ -1067,7 +893,7 @@ var TypedReactiveHandler = class _TypedReactiveHandler {
     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.`);
+      throw new Error(`Cannot modify object property "${String(property)}" outside of Obj.update(). Use Obj.update(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
     }
     const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, property, attributes.value);
     const result = Reflect.defineProperty(target, property, {
@@ -1127,7 +953,7 @@ var TypedReactiveHandler = class _TypedReactiveHandler {
       return value2;
     }
     const schema = SchemaValidator.getTargetPropertySchema(target, prop);
-    const _ = Schema4.asserts(schema)(value2);
+    const _ = Schema3.asserts(schema)(value2);
     if (isValidProxyTarget(value2)) {
       setSchemaProperties(value2, schema);
     }
@@ -1148,12 +974,21 @@ var toJSON = (target) => {
     ...target
   };
 };
-var setSchemaProperties = (obj, schema) => {
-  const schemaType = getSchemaDXN(schema);
+var setSchemaProperties = (obj, schema, typeSource) => {
+  const schemaType = getSchemaURI(schema);
   if (schemaType != null) {
     defineHiddenProperty(obj, TypeId, schemaType);
   }
-  defineHiddenProperty(obj, SchemaId, schema);
+  if (typeSource != null) {
+    defineHiddenProperty(obj, TypeEntityId, typeSource);
+    Object.defineProperty(obj, SchemaId, {
+      get: () => typeSource[StaticTypeSchemaSlot] ?? schema,
+      enumerable: false,
+      configurable: true
+    });
+  } else {
+    defineHiddenProperty(obj, SchemaId, schema);
+  }
   for (const key in obj) {
     if (isValidProxyTarget(obj[key])) {
       const elementSchema = SchemaValidator.getTargetPropertySchema(obj, key);
@@ -1163,14 +998,14 @@ var setSchemaProperties = (obj, schema) => {
     }
   }
 };
-var prepareTypedTarget = (target, schema) => {
+var prepareTypedTarget = (target, schema, typeSource) => {
   if (!SchemaAST3.isTypeLiteral(schema.ast)) {
     throw new Error("schema has to describe an object type");
   }
   SchemaValidator.validateSchema(schema);
-  const _ = Schema4.asserts(schema)(target);
+  const _ = Schema3.asserts(schema)(target);
   makeArraysReactive(target);
-  setSchemaProperties(target, schema);
+  setSchemaProperties(target, schema, typeSource);
 };
 var makeArraysReactive = (target) => {
   for (const key in target) {
@@ -1187,10 +1022,10 @@ var makeArraysReactive = (target) => {
 };
 
 // src/internal/common/proxy/make-object.ts
-var makeObject = (schema, obj, meta) => {
-  return createReactiveObject(Object.assign({}, obj), meta, schema);
+var makeObject = (schema, obj, meta, typeSource) => {
+  return createReactiveObject(Object.assign({}, obj), meta, schema, typeSource);
 };
-var createReactiveObject = (obj, meta, schema) => {
+var createReactiveObject = (obj, meta, schema, typeSource) => {
   if (!isValidProxyTarget(obj)) {
     throw new Error("Value cannot be made into a reactive object.");
   }
@@ -1210,7 +1045,7 @@ var createReactiveObject = (obj, meta, schema) => {
   if (parent !== void 0) {
     defineHiddenProperty(obj, ParentId, parent);
   }
-  prepareTypedTarget(obj, schema);
+  prepareTypedTarget(obj, schema, typeSource);
   attachTypedJsonSerializer(obj);
   const proxy = createProxy(obj, TypedReactiveHandler.instance);
   const metaProxy = obj[MetaId];
@@ -1224,22 +1059,30 @@ var createReactiveObject = (obj, meta, schema) => {
 };
 var setIdOnTarget = (target) => {
   if ("id" in target && target.id !== void 0 && target.id !== null) {
-    if (!ObjectId.isValid(target.id)) {
+    if (!EntityId.isValid(target.id)) {
       throw new Error("Invalid object id format.");
     }
   } else {
-    target.id = ObjectId.random();
+    target.id = EntityId.random();
   }
 };
-var initMeta = (obj, meta = {
-  keys: []
-}) => {
-  prepareTypedTarget(meta, ObjectMetaSchema);
-  defineHiddenProperty(obj, MetaId, createProxy(meta, TypedReactiveHandler.instance));
+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/common/proxy/reactive.ts
 var subscribe = (obj, callback) => {
+  if (!isProxy(obj)) {
+    return () => {
+    };
+  }
   const target = getProxyTarget(obj);
   if (target && EventId in target) {
     return target[EventId].on(callback);
@@ -1256,208 +1099,177 @@ var change = (obj, callback) => {
   }
 };
 
-// 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'"
-    ]
+// src/internal/Entity/entity.ts
+import * as Schema4 from "effect/Schema";
+import * as SchemaAST4 from "effect/SchemaAST";
+import { DXN, EntityId as EntityId2 } from "@dxos/keys";
+var TypeMetaSchemaDXN = DXN.make("org.dxos.type.schema", "0.1.0");
+var persistentEntitySchema = (() => {
+  const typename = DXN.getName(TypeMetaSchemaDXN);
+  const version2 = DXN.getVersion(TypeMetaSchemaDXN);
+  const struct = Schema4.Struct({
+    name: Schema4.optional(Schema4.String),
+    jsonSchema: JsonSchemaType.pipe(Schema4.optional),
+    id: EntityId2
   });
-  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'"
-    ]
+  const ast = SchemaAST4.annotations(struct.ast, {
+    [TypeAnnotationId]: {
+      kind: EntityKind.Type,
+      typename,
+      version: version2
+    },
+    [SchemaAST4.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+      kind: EntityKind.Type,
+      typename,
+      version: version2
+    })
   });
-  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'"
-    ]
+  return Schema4.make(ast);
+})();
+var makeEchoTypeSchema = (fields, ast, typename, version2, kind, computeJsonSchema, explicitId) => {
+  const sourceSchema = Schema4.make(ast);
+  const meta = {
+    keys: [],
+    key: typename,
+    version: version2
+  };
+  const id = explicitId ?? EntityId2.deterministic(typename, version2);
+  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(value2) {
+      memoizedJsonSchema = value2;
+    }
   });
-  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'"
-    ]
+  defineHiddenProperty(target, StaticTypeSchemaSlot, sourceSchema);
+  defineHiddenProperty(target, SchemaKindId, kind);
+  Object.defineProperty(target, "fields", {
+    configurable: true,
+    enumerable: false,
+    get: () => fields
   });
-  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'"
-      ]
-    });
-  }
-}
+  return entity;
+};
 
-// src/internal/Entity/util.ts
+// src/internal/Entity/object.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);
-};
+import * as SchemaAST5 from "effect/SchemaAST";
+import { invariant as invariant6 } from "@dxos/invariant";
+import { DXN as DXN2 } from "@dxos/keys";
 
-// 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;
+// src/internal/JsonSchema/json-schema-normalize.ts
+var normalizeSchema = (schema) => {
+  const copy = structuredClone(schema);
+  go(copy);
+  return copy;
 };
-var getDatabase = (entity) => {
-  assumeType3(entity);
-  return entity[ObjectDatabaseId];
+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);
+  }
 };
-
-// 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);
+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/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 }) => {
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/object.ts";
+var EchoObjectSchema = (dxn, options) => {
+  const typename = DXN2.getName(dxn);
+  const version2 = DXN2.getVersion(dxn);
+  invariant6(version2, `Type.makeObject requires a versioned DXN: ${dxn}`, { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 19, S: void 0, A: ["version", "`Type.makeObject requires a versioned DXN: ${dxn}`"] });
   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.'"
-      ]
-    });
+    invariant6(typeof TypeAnnotationId === "symbol", "Sanity.", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 21, S: void 0, A: ["typeof TypeAnnotationId === 'symbol'", "'Sanity.'"] });
+    invariant6(SchemaAST5.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 22, 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 schemaWithId = Schema5.extend(self, Schema5.Struct({
+      id: Schema5.String
     }));
-    const ast = SchemaAST4.annotations(schemaWithId.ast, {
+    const ast = SchemaAST5.annotations(schemaWithId.ast, {
       // TODO(dmaretskyi): `extend` kills the annotations.
       ...self.ast.annotations,
       [TypeAnnotationId]: {
@@ -1466,49 +1278,46 @@ var EchoObjectSchema = ({ typename, version: version2 }) => {
         version: version2
       },
       // TODO(dmaretskyi): TypeIdentifierAnnotationId?
-      [SchemaAST4.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+      [SchemaAST5.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
         kind: EntityKind.Object,
         typename,
         version: version2
       })
     });
-    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Object);
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Object, () => toJsonSchema(Schema5.make(ast)), options?.id);
   };
 };
 
 // src/internal/Entity/relation.ts
-import * as Schema8 from "effect/Schema";
-import * as SchemaAST5 from "effect/SchemaAST";
+import * as Schema6 from "effect/Schema";
+import * as SchemaAST6 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) {
+import { assertArgument as assertArgument2, invariant as invariant7 } from "@dxos/invariant";
+import { DXN as DXN3 } from "@dxos/keys";
+var __dxlog_file7 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/relation.ts";
+var EchoRelationSchema = ({ dxn, source, target, id: explicitId }) => {
+  const sourceSchema = source != null ? getStaticTypeSchema(source) ?? source : source;
+  const targetSchema = target != null ? getStaticTypeSchema(target) ?? target : target;
+  assertArgument2(Schema6.isSchema(sourceSchema), "source");
+  assertArgument2(Schema6.isSchema(targetSchema), "target");
+  const typename = DXN3.getName(dxn);
+  const version2 = DXN3.getVersion(dxn);
+  invariant7(version2, `Type.makeRelation requires a versioned DXN: ${dxn}`, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 27, S: void 0, A: ["version", "`Type.makeRelation requires a versioned DXN: ${dxn}`"] });
+  const sourceDXN = getDXNForRelationSchemaRef(sourceSchema);
+  const targetDXN = getDXNForRelationSchemaRef(targetSchema);
+  if (getEntityKind(sourceSchema) !== EntityKind.Object) {
     raise(new Error("Source schema must be an echo object schema."));
   }
-  if (getEntityKind(target) !== EntityKind.Object) {
+  if (getEntityKind(targetSchema) !== 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.'"
-      ]
-    });
+    invariant7(SchemaAST6.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 37, 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 schemaWithId = Schema6.extend(self, Schema6.Struct({
+      id: Schema6.String
     }));
-    const ast = SchemaAST5.annotations(schemaWithId.ast, {
+    const ast = SchemaAST6.annotations(schemaWithId.ast, {
       // TODO(dmaretskyi): `extend` kills the annotations.
       ...self.ast.annotations,
       [TypeAnnotationId]: {
@@ -1519,7 +1328,7 @@ var EchoRelationSchema = ({ source, target, typename, version: version2 }) => {
         targetSchema: targetDXN
       },
       // TODO(dmaretskyi): TypeIdentifierAnnotationId?
-      [SchemaAST5.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+      [SchemaAST6.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
         kind: EntityKind.Relation,
         typename,
         version: version2,
@@ -1527,24 +1336,57 @@ var EchoRelationSchema = ({ source, target, typename, version: version2 }) => {
         relationTarget: targetDXN
       })
     });
-    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Relation);
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Relation, () => toJsonSchema(Schema6.make(ast)), explicitId);
   };
 };
 var getDXNForRelationSchemaRef = (schema) => {
-  assertArgument3(Schema8.isSchema(schema), "schema");
+  assertArgument2(Schema6.isSchema(schema), "schema");
   const identifier = getTypeIdentifierAnnotation(schema);
   if (identifier) {
-    return identifier;
+    return DXN3.tryMake(identifier) ?? raise(new Error(`Invalid schema identifier: ${identifier}`));
   }
   const typename = getSchemaTypename(schema);
   if (!typename) {
     throw new Error("Schema must have a typename");
   }
-  return DXN4.fromTypename(typename).toString();
+  return DXN3.make(typename);
+};
+
+// src/internal/Entity/type-kind.ts
+import * as Schema7 from "effect/Schema";
+import * as SchemaAST7 from "effect/SchemaAST";
+import { invariant as invariant8 } from "@dxos/invariant";
+import { DXN as DXN4 } from "@dxos/keys";
+var __dxlog_file8 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/type-kind.ts";
+var EchoTypeKindSchema = (dxn, options) => {
+  const typename = DXN4.getName(dxn);
+  const version2 = DXN4.getVersion(dxn);
+  invariant8(version2, `Type-kind schemas require a versioned DXN: ${dxn}`, { "~LogMeta": "~LogMeta", F: __dxlog_file8, L: 22, S: void 0, A: ["version", "`Type-kind schemas require a versioned DXN: ${dxn}`"] });
+  return (self) => {
+    invariant8(SchemaAST7.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", { "~LogMeta": "~LogMeta", F: __dxlog_file8, L: 24, 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 = SchemaAST7.annotations(schemaWithId.ast, {
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Type,
+        typename,
+        version: version2
+      },
+      [SchemaAST7.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Type,
+        typename,
+        version: version2
+      })
+    });
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Type, () => toJsonSchema(Schema7.make(ast)), options?.id);
+  };
 };
 
 // src/internal/Entity/version.ts
-import { assertArgument as assertArgument4 } from "@dxos/invariant";
+import { assertArgument as assertArgument3 } from "@dxos/invariant";
 var unversioned = {
   [VersionTypeId]: {},
   versioned: false
@@ -1560,12 +1402,12 @@ var version = (entity) => {
   return ver;
 };
 var versionValid = (ver) => {
-  assertArgument4(isVersion(ver), "version", "Invalid version object");
+  assertArgument3(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");
+  assertArgument3(isVersion(version1), "version1", "Invalid version object");
+  assertArgument3(isVersion(version2), "version2", "Invalid version object");
   if (!versionValid(version1) || !versionValid(version2)) {
     return "unversioned";
   }
@@ -1586,99 +1428,8 @@ var decodeVersion = (ver) => {
   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";
+import * as Schema8 from "effect/Schema";
 var makeTypedEntityClass = (typename, version2, baseSchema) => {
   return class {
     // Implement TypedObject properties.
@@ -1686,7 +1437,7 @@ var makeTypedEntityClass = (typename, version2, baseSchema) => {
     static version = version2;
     // Implement Schema.Schema properties.
     // TODO(burdon): Comment required.
-    static [Schema9.TypeId] = schemaVariance;
+    static [Schema8.TypeId] = schemaVariance;
     static ast = baseSchema.ast;
     static annotations = baseSchema.annotations.bind(baseSchema);
     static pipe = baseSchema.pipe.bind(baseSchema);
@@ -1708,8 +1459,8 @@ var schemaVariance = {
 
 // 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";
+import { assertArgument as assertArgument5, failedInvariant } from "@dxos/invariant";
+import { EntityId as EntityId4 } from "@dxos/keys";
 
 // src/internal/Obj/inspect.ts
 import { inspectCustom as inspectCustom2 } from "@dxos/debug";
@@ -1729,53 +1480,37 @@ var typedObjectInspectFunction = function(depth, options, inspect) {
   const { id, ...props } = this;
   return inspect({
     id,
-    [ATTR_TYPE]: getTypeDXN(this),
+    [ATTR_TYPE]: getTypeURI(this),
     ...props,
     [ATTR_META]: this[MetaId]
   }, options);
 };
 
 // src/internal/Obj/json-serializer.ts
-import * as Schema10 from "effect/Schema";
+import * as Schema9 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";
+import { EntityStructure, isEncodedReference } from "@dxos/echo-protocol";
+import { assertArgument as assertArgument4, invariant as invariant9 } from "@dxos/invariant";
+import { EID as EID2, EntityId as EntityId3, URI } from "@dxos/keys";
+import { assumeType, decodeUint8ArrayFromJson, deepMapValues as deepMapValues2, isEncodedUint8Array, visitValues } from "@dxos/util";
+var __dxlog_file9 = "/__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'",
-      ""
-    ]
-  });
+  const typename = getTypeURI(obj);
+  invariant9(typename && typeof typename === "string", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 23, 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]);
+var objectFromJSON = async (jsonData, { refResolver, uri, database, parent } = {}) => {
+  assumeType(jsonData);
+  assertArgument4(typeof jsonData === "object" && jsonData !== null, "jsonData", "expect object");
+  assertArgument4(typeof jsonData[ATTR_TYPE] === "string", "jsonData[ATTR_TYPE]", "expected object to have a type");
+  assertArgument4(typeof jsonData.id === "string", "jsonData.id", "expected object to have an id");
+  const type = URI.make(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);
+  invariant9(schema === void 0 || Schema9.isSchema(schema), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 43, S: void 0, A: ["schema === undefined || Schema.isSchema(schema)", ""] });
+  const decodedInput = restoreUint8Arrays(stripInternalJsonKeys(jsonData));
   let obj;
   if (schema != null) {
-    obj = await schema.pipe(Schema10.decodeUnknownPromise)(decodedInput);
+    obj = await schema.pipe(Schema9.decodeUnknownPromise)(decodedInput);
     if (refResolver) {
       setRefResolverOnData(obj, refResolver);
     }
@@ -1784,23 +1519,21 @@ var objectFromJSON = async (jsonData, { refResolver, dxn, database, parent } = {
       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'"
-    ]
-  });
+  invariant9(EntityId3.isValid(obj.id), "Invalid object id", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 56, S: void 0, A: ["EntityId.isValid(obj.id)", "'Invalid object id'"] });
   setTypename(obj, type);
   if (schema) {
     setSchema(obj, schema);
   }
+  if (refResolver?.resolveType) {
+    const typeEntity = await refResolver.resolveType(type);
+    if (typeEntity != null) {
+      setType(obj, typeEntity);
+    }
+  }
   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 sourceDxn = jsonData[ATTR_RELATION_SOURCE] ?? raise2(new TypeError("Missing relation source"));
+    const targetDxn = 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);
@@ -1809,106 +1542,74 @@ var objectFromJSON = async (jsonData, { refResolver, dxn, database, parent } = {
     defineHiddenProperty(obj, RelationSourceId, source);
     defineHiddenProperty(obj, RelationTargetId, target);
   } else {
-    defineHiddenProperty(obj, KindId, EntityKind.Object);
+    const annotationKind = schema != null ? getTypeAnnotation(schema)?.kind : void 0;
+    defineHiddenProperty(obj, KindId, annotationKind === EntityKind.Type ? EntityKind.Type : 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)",
-        ""
-      ]
-    });
+    const meta = await EntityMetaSchema.pipe(Schema9.decodeUnknownPromise)(normalizeMeta(jsonData[ATTR_META]));
+    invariant9(Array.isArray(meta.keys), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 92, S: void 0, A: ["Array.isArray(meta.keys)", ""] });
     defineHiddenProperty(obj, MetaId, meta);
   } else {
     defineHiddenProperty(obj, MetaId, {
-      keys: []
+      keys: [],
+      tags: [],
+      annotations: {}
     });
   }
   if (jsonData[ATTR_PARENT]) {
-    const parentDxn = DXN5.parse(jsonData[ATTR_PARENT]);
+    const parentDxn = 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 (uri) {
+    defineHiddenProperty(obj, SelfURIId, uri);
   }
   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'"
-    ]
-  });
+  invariant9(obj[ATTR_TYPE] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 115, S: void 0, A: ["obj[ATTR_TYPE] === undefined", "'Invalid object model'"] });
+  invariant9(obj[ATTR_META] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 116, S: void 0, A: ["obj[ATTR_META] === undefined", "'Invalid object model'"] });
+  invariant9(obj[ATTR_DELETED] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 117, S: void 0, A: ["obj[ATTR_DELETED] === undefined", "'Invalid object model'"] });
+  invariant9(obj[ATTR_SELF_URI] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 118, S: void 0, A: ["obj[ATTR_SELF_URI] === undefined", "'Invalid object model'"] });
+  invariant9(obj[ATTR_SELF_URI_LEGACY] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 119, S: void 0, A: ["obj[ATTR_SELF_URI_LEGACY] === undefined", "'Invalid object model'"] });
+  invariant9(obj[ATTR_RELATION_SOURCE] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 120, S: void 0, A: ["obj[ATTR_RELATION_SOURCE] === undefined", "'Invalid object model'"] });
+  invariant9(obj[ATTR_RELATION_TARGET] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file9, L: 121, S: void 0, A: ["obj[ATTR_RELATION_TARGET] === undefined", "'Invalid object model'"] });
   return obj;
 };
+var normalizeMeta = (meta) => {
+  const tags = Array.isArray(meta?.tags) ? meta.tags.map((tag) => typeof tag === "string" ? {
+    "/": URI.make(tag)
+  } : tag) : [];
+  return {
+    ...meta,
+    keys: Array.isArray(meta?.keys) ? meta.keys : [],
+    tags,
+    annotations: meta?.annotations ?? {}
+  };
+};
 var decodeGeneric = (jsonData, options) => {
   const props = stripInternalJsonKeys(jsonData);
   return deepMapValues2(props, (value2, visitor) => {
     if (isEncodedReference(value2)) {
       return refFromEncodedReference(value2, options.refResolver);
     }
+    if (isEncodedUint8Array(value2)) {
+      return decodeUint8ArrayFromJson(value2);
+    }
     return visitor(value2);
   });
 };
+var restoreUint8Arrays = (data) => deepMapValues2(data, (value2, recurse) => {
+  if (isEncodedUint8Array(value2)) {
+    return decodeUint8ArrayFromJson(value2);
+  }
+  return recurse(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;
+  const { [ATTR_TYPE]: _type, [ATTR_META]: _meta, [ATTR_DELETED]: _deleted, [ATTR_SELF_URI]: _selfUri, [ATTR_SELF_URI_LEGACY]: _legacySelfUri, [ATTR_RELATION_SOURCE]: _relationSource, [ATTR_RELATION_TARGET]: _relationTarget, ...props } = jsonData;
   return props;
 };
 var setRefResolverOnData = (obj, refResolver) => {
@@ -1922,43 +1623,58 @@ var setRefResolverOnData = (obj, refResolver) => {
   visitor(obj);
 };
 var objectStructureToJson = (objectId, structure) => {
+  const typeRef = EntityStructure.getTypeReference(structure)?.["/"];
+  const parent = EntityStructure.getParent(structure)?.["/"];
+  const source = EntityStructure.getRelationSource(structure)?.["/"];
+  const target = EntityStructure.getRelationTarget(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)?.["/"]
+    [ATTR_TYPE]: typeRef ? URI.make(typeRef) : void 0,
+    [ATTR_DELETED]: EntityStructure.isDeleted(structure),
+    [ATTR_PARENT]: parent !== void 0 ? EID2.tryParse(parent) : void 0,
+    [ATTR_RELATION_SOURCE]: source !== void 0 ? EID2.tryParse(source) : void 0,
+    [ATTR_RELATION_TARGET]: target !== void 0 ? EID2.tryParse(target) : void 0
   };
 };
 
 // src/internal/Obj/create-object.ts
-var createObject = (schema, props) => {
+var createObject = (input, props) => {
+  const schema = getStaticTypeSchema(input) ?? failedInvariant("Type entity is missing its source schema");
   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");
+  assertArgument5(!("@type" in props), "data", "@type is not allowed");
+  assertArgument5(!(RelationSourceDXNId in props), "data", "Relation source DXN is not allowed in the constructor");
+  assertArgument5(!(RelationTargetDXNId in props), "data", "Relation target DXN is not allowed in the constructor");
+  assertArgument5(RelationSourceId in props === RelationTargetId in props, "data", "Relation source and target must be provided together");
+  const metaOverride = props[MetaId];
+  if (metaOverride !== void 0) {
+    delete props[MetaId];
+  }
   const obj = {
     ...props,
-    id: props.id ?? ObjectId5.random()
+    id: props.id ?? EntityId4.random()
   };
-  const kind = RelationSourceId in props ? EntityKind.Relation : EntityKind.Object;
+  const kind = annotation.kind === EntityKind.Type ? EntityKind.Type : annotation.kind === EntityKind.Relation || RelationSourceId in props ? EntityKind.Relation : EntityKind.Object;
   defineHiddenProperty(obj, KindId, kind);
   defineHiddenProperty(obj, MetaId, {
-    keys: []
+    ...metaOverride,
+    keys: metaOverride?.keys ?? [],
+    tags: metaOverride?.tags ?? [],
+    annotations: metaOverride?.annotations ?? {}
   });
   setSchema(obj, schema);
-  setTypename(obj, getSchemaDXN(schema) ?? failedInvariant("Missing schema DXN"));
+  if (input !== schema) {
+    setType(obj, input);
+  }
+  setTypename(obj, getSchemaURI(schema) ?? failedInvariant("Missing schema URI"));
   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"));
+    const sourceDXN = getObjectEchoUri(props[RelationSourceId]) ?? raise3(new Error("Unresolved relation source"));
+    const targetDXN = getObjectEchoUri(props[RelationTargetId]) ?? raise3(new Error("Unresolved relation target"));
     defineHiddenProperty(obj, RelationSourceDXNId, sourceDXN);
     defineHiddenProperty(obj, RelationTargetDXNId, targetDXN);
   }
@@ -1974,41 +1690,17 @@ var isDeleted = (obj) => {
   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";
+import * as SchemaAST8 from "effect/SchemaAST";
+import { SchemaEx } from "@dxos/effect";
+import { invariant as invariant10 } from "@dxos/invariant";
+var __dxlog_file10 = "/__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'"
-    ]
-  });
+  invariant10(path.length > 0, "Path must not be empty", { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 14, 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'"
-    ]
-  });
+  invariant10(schema != null, "Object must have a schema", { "~LogMeta": "~LogMeta", F: __dxlog_file10, L: 16, 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++) {
@@ -2016,7 +1708,7 @@ var setValue = (obj, path, value2) => {
     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;
+      const shouldBeArray = propertyAST ? SchemaEx.isArrayType(propertyAST) : false;
       if (shouldBeArray) {
         parent[key] = [];
       } else {
@@ -2035,15 +1727,15 @@ var getPropertyAST = (ast, propertyName) => {
   if (!ast) {
     return void 0;
   }
-  if (isNestedType(ast)) {
-    const properties = getProperties2(ast);
+  if (SchemaEx.isNestedType(ast)) {
+    const properties = SchemaEx.getProperties(ast);
     const property = properties.find((p) => p.name.toString() === propertyName);
     if (property) {
-      return getBaseType(property).type;
+      return SchemaEx.getBaseType(property).type;
     }
   }
-  if (isArrayType(ast)) {
-    const elementType = getArrayElementType(ast);
+  if (SchemaEx.isArrayType(ast)) {
+    const elementType = SchemaEx.getArrayElementType(ast);
     return elementType;
   }
   return void 0;
@@ -2052,17 +1744,17 @@ var getRequiredProperties = (ast) => {
   if (!ast) {
     return [];
   }
-  if (!isNestedType(ast)) {
+  if (!SchemaEx.isNestedType(ast)) {
     return [];
   }
-  const properties = getProperties2(ast);
+  const properties = SchemaEx.getProperties(ast);
   return properties.filter((p) => !p.isOptional);
 };
 var getDefaultValueForType = (ast) => {
   if (!ast) {
     return void 0;
   }
-  const defaultValue = SchemaAST6.getDefaultAnnotation(ast);
+  const defaultValue = SchemaAST8.getDefaultAnnotation(ast);
   if (Option.isSome(defaultValue)) {
     return defaultValue.value;
   }
@@ -2084,7 +1776,7 @@ var createObjectWithDefaults = (ast) => {
     const defaultValue = getDefaultValueForType(prop.type);
     if (defaultValue !== void 0) {
       obj[prop.name] = defaultValue;
-    } else if (isNestedType(prop.type)) {
+    } else if (SchemaEx.isNestedType(prop.type)) {
       obj[prop.name] = createObjectWithDefaults(prop.type);
     }
   }
@@ -2092,7 +1784,7 @@ var createObjectWithDefaults = (ast) => {
 };
 
 // src/internal/Obj/snapshot.ts
-import { assertArgument as assertArgument7 } from "@dxos/invariant";
+import { assertArgument as assertArgument6 } from "@dxos/invariant";
 import { deepMapValues as deepMapValues3 } from "@dxos/util";
 var copySymbolProperty = (source, target, symbol, transform) => {
   let value2;
@@ -2112,7 +1804,7 @@ var copySymbolProperty = (source, target, symbol, transform) => {
   }
 };
 var getSnapshot = (obj) => {
-  assertArgument7(typeof obj === "object" && obj !== null && KindId in obj, "obj", "must be an entity");
+  assertArgument6(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;
@@ -2125,16 +1817,29 @@ var getSnapshot = (obj) => {
   const source = obj;
   copySymbolProperty(source, snapshot, TypeId);
   copySymbolProperty(source, snapshot, SchemaId);
-  copySymbolProperty(source, snapshot, SelfDXNId);
+  copySymbolProperty(source, snapshot, TypeEntityId);
+  copySymbolProperty(source, snapshot, SelfURIId);
   copySymbolProperty(source, snapshot, ObjectDatabaseId);
   copySymbolProperty(source, snapshot, ObjectDeletedId);
+  copySymbolProperty(source, snapshot, ParentId);
   copySymbolProperty(source, snapshot, MetaId, (meta) => ({
     keys: [
       ...meta?.keys ?? []
     ],
     tags: [
       ...meta?.tags ?? []
-    ]
+    ],
+    ...meta?.key != null ? {
+      key: meta.key
+    } : {},
+    ...meta?.version != null ? {
+      version: meta.version
+    } : {},
+    ...meta?.annotations ? {
+      annotations: {
+        ...meta.annotations
+      }
+    } : {}
   }));
   copySymbolProperty(source, snapshot, RelationSourceDXNId);
   copySymbolProperty(source, snapshot, RelationTargetDXNId);
@@ -2143,22 +1848,151 @@ var getSnapshot = (obj) => {
   return Object.freeze(snapshot);
 };
 
+// src/internal/Obj/atoms.ts
+import * as Atom from "@effect-atom/atom/Atom";
+import * as Result from "@effect-atom/atom/Result";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option2 from "effect/Option";
+import { assertArgument as assertArgument7 } from "@dxos/invariant";
+var isRef = (obj) => obj != null && typeof obj === "object" && RefTypeId in obj;
+var getReactiveOption = (snapshot) => Effect.gen(function* () {
+  const db = getDatabase(snapshot);
+  if (!db) {
+    return Option2.none();
+  }
+  const obj = db.getObjectById(snapshot.id);
+  return obj ? Option2.some(obj) : Option2.none();
+});
+var objectFamily = Atom.family((obj) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(obj, () => {
+      get.setSelf(getSnapshot(obj));
+    });
+    get.addFinalizer(() => unsubscribe());
+    return getSnapshot(obj);
+  }).pipe(Atom.keepAlive);
+});
+var refFamily = Atom.family((ref) => {
+  return Atom.make((get) => {
+    let unsubscribeTarget;
+    const setupTargetSubscription = (target) => {
+      unsubscribeTarget?.();
+      unsubscribeTarget = subscribe(target, () => {
+        get.setSelf(getSnapshot(target));
+      });
+      return getSnapshot(target);
+    };
+    get.addFinalizer(() => {
+      unsubscribeTarget?.();
+    });
+    return loadRefTarget(ref, get, setupTargetSubscription);
+  }).pipe(Atom.keepAlive);
+});
+var snapshotForComparison = (value2) => {
+  if (Array.isArray(value2)) {
+    return [
+      ...value2
+    ];
+  }
+  if (value2 !== null && typeof value2 === "object") {
+    return {
+      ...value2
+    };
+  }
+  return value2;
+};
+var propertyFamily = Atom.family((obj) => Atom.family((key) => {
+  return Atom.make((get) => {
+    let previousSnapshot = snapshotForComparison(obj[key]);
+    const unsubscribe2 = subscribe(obj, () => {
+      const newValue = obj[key];
+      const newSnapshot = snapshotForComparison(newValue);
+      if (newSnapshot !== previousSnapshot) {
+        previousSnapshot = newSnapshot;
+        get.setSelf(newSnapshot);
+      }
+    });
+    get.addFinalizer(() => unsubscribe2());
+    return snapshotForComparison(obj[key]);
+  }).pipe(Atom.keepAlive);
+}));
+var objectWithReactiveFamily = Atom.family((obj) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(obj, () => {
+      get.setSelf(obj);
+    });
+    get.addFinalizer(() => unsubscribe());
+    return obj;
+  }).pipe(Atom.keepAlive);
+});
+var refWithReactiveFamily = Atom.family((ref) => {
+  const effect = (get) => Effect.gen(function* () {
+    const snapshot = get(makeAtom(ref));
+    if (snapshot == null) {
+      return void 0;
+    }
+    const option = yield* getReactiveOption(snapshot);
+    return Option2.getOrElse(option, () => void 0);
+  });
+  return Function.pipe(Atom.make(effect), Atom.map((result) => Result.getOrElse(result, () => void 0)));
+});
+var entityFamily = Atom.family((entity) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(entity, () => {
+      get.setSelf(getSnapshot(entity));
+    });
+    get.addFinalizer(() => unsubscribe());
+    return getSnapshot(entity);
+  }).pipe(Atom.keepAlive);
+});
+var relationFamily = Atom.family((relation) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(relation, () => {
+      get.setSelf(getSnapshot(relation));
+    });
+    get.addFinalizer(() => unsubscribe());
+    return getSnapshot(relation);
+  }).pipe(Atom.keepAlive);
+});
+var makeAtom = (objOrRef) => {
+  if (isRef(objOrRef)) {
+    return refFamily(objOrRef);
+  }
+  const obj = objOrRef;
+  assertArgument7(isEntity(obj), "obj", "Object must be a reactive object");
+  return objectFamily(obj);
+};
+var makeProperty = (obj, key) => {
+  assertArgument7(isEntity(obj), "obj", "Object must be a reactive object");
+  return propertyFamily(obj)(key);
+};
+var makeWithReactive = (objOrRef) => {
+  if (isRef(objOrRef)) {
+    return refWithReactiveFamily(objOrRef);
+  }
+  const obj = objOrRef;
+  assertArgument7(isEntity(obj), "obj", "Object must be a reactive object");
+  return objectWithReactiveFamily(obj);
+};
+var makeEntity = (entity) => {
+  assertArgument7(isEntity(entity), "entity", "Must be a reactive ECHO entity");
+  return entityFamily(entity);
+};
+var makeRelation = (relation) => {
+  assertArgument7(isEntity(relation), "relation", "Must be a reactive ECHO relation");
+  return relationFamily(relation);
+};
+
 // src/internal/Obj/clone.ts
-import { invariant as invariant15 } from "@dxos/invariant";
+import { invariant as invariant11 } 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 __dxlog_file11 = "/__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 typeEntity = getType(obj);
+  const schema = typeEntity != null ? getStaticTypeSchema(typeEntity) : getSchema(obj);
+  invariant11(schema != null, "Object should have a type or schema", { "~LogMeta": "~LogMeta", F: __dxlog_file11, L: 21, S: void 0, A: ["schema != null", "'Object should have a type or schema'"] });
   const props = deepMapValues4(data, (value2, recurse) => {
     if (Ref.isRef(value2)) {
       if (opts?.deep) {
@@ -2180,13 +2014,16 @@ var clone = (obj, opts) => {
     }
     return recurse(value2);
   });
-  return makeObject(schema, props, meta);
+  return makeObject(schema, props, meta, typeEntity);
 };
 
-// src/internal/Query.ts
+// src/internal/Query/pretty.ts
 var prettyFilter = (filter) => {
   switch (filter.type) {
     case "object": {
+      if (filter.typename === null && (filter.id === void 0 || filter.id.length === 0) && Object.keys(filter.props).length === 0 && (filter.foreignKeys === void 0 || filter.foreignKeys.length === 0) && filter.metaKey !== void 0) {
+        return filter.metaVersion !== void 0 ? `Filter.key(${JSON.stringify(filter.metaKey)}, { version: ${JSON.stringify(filter.metaVersion)} })` : `Filter.key(${JSON.stringify(filter.metaKey)})`;
+      }
       const parts = [];
       if (filter.typename !== null) {
         parts.push(String(filter.typename));
@@ -2202,6 +2039,9 @@ var prettyFilter = (filter) => {
       if (filter.foreignKeys !== void 0 && filter.foreignKeys.length > 0) {
         parts.push(`foreignKeys: [${filter.foreignKeys.map((fk) => JSON.stringify(fk)).join(", ")}]`);
       }
+      if (filter.metaKey !== void 0) {
+        parts.push(filter.metaVersion !== void 0 ? `metaKey: ${JSON.stringify(filter.metaKey)} (${filter.metaVersion})` : `metaKey: ${JSON.stringify(filter.metaKey)}`);
+      }
       return parts.length > 0 ? `Filter.type(${parts.join(", ")})` : "Filter.everything()";
     }
     case "compare":
@@ -2265,6 +2105,9 @@ var prettyQuery = (query) => {
           return "Order.natural()";
         } else if (o.kind === "rank") {
           return `Order.rank(${JSON.stringify(o.direction)})`;
+        } else if (o.kind === "timestamp") {
+          const fn = o.field === "updatedAt" ? "updated" : "created";
+          return `Order.${fn}(${JSON.stringify(o.direction)})`;
         } else {
           return `Order.property(${JSON.stringify(o.property)}, ${JSON.stringify(o.direction)})`;
         }
@@ -2277,22 +2120,26 @@ var prettyQuery = (query) => {
       if (opts.deleted !== void 0) {
         parts.push(`deleted: ${JSON.stringify(opts.deleted)}`);
       }
+      if (opts.debugLabel !== void 0) {
+        parts.push(`debugLabel: ${JSON.stringify(opts.debugLabel)}`);
+      }
       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}`);
+        if (query.from.scopes.length === 0) {
+          return `${prettyQuery(query.query)}.from('all-accessible-spaces')`;
         }
-        return `${prettyQuery(query.query)}.from({ ${parts.join(", ")} })`;
+        const scopeStrs = query.from.scopes.map((scope) => {
+          if (scope._tag === "space") {
+            return scope.includeAllFeeds ? `{ space: ${JSON.stringify(scope.spaceId)}, includeAllFeeds: true }` : `{ space: ${JSON.stringify(scope.spaceId)} }`;
+          }
+          if (scope._tag === "feed") {
+            return `{ feed: ${JSON.stringify(String(scope.feedUri))} }`;
+          }
+          return `{ registry: ${JSON.stringify(scope.location)} }`;
+        });
+        return `${prettyQuery(query.query)}.from([${scopeStrs.join(", ")}])`;
       }
       return `${prettyQuery(query.query)}.from(${prettyQuery(query.from.query)})`;
     }
@@ -2301,36 +2148,22 @@ var prettyQuery = (query) => {
   }
 };
 
-// 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";
+import * as Schema10 from "effect/Schema";
+import * as SchemaAST9 from "effect/SchemaAST";
+import { invariant as invariant12 } from "@dxos/invariant";
+var __dxlog_file12 = "/__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);
+  const schemaExtension = Schema10.partial(Schema10.Struct(fields));
+  return Schema10.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)",
-      ""
-    ]
-  });
+  invariant12(SchemaAST9.isTypeLiteral(ast), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 14, S: void 0, A: ["SchemaAST.isTypeLiteral(ast)", ""] });
   const updatedProperties = [
     ...ast.propertySignatures
   ];
-  const propertiesToUpdate = Schema11.partial(Schema11.Struct(fields)).ast.propertySignatures;
+  const propertiesToUpdate = Schema10.partial(Schema10.Struct(fields)).ast.propertySignatures;
   for (const property of propertiesToUpdate) {
     const index = updatedProperties.findIndex((p) => p.name === property.name);
     if (index !== -1) {
@@ -2339,420 +2172,37 @@ var updateFieldsInSchema = (schema, fields) => {
       updatedProperties.push(property);
     }
   }
-  return Schema11.make(new SchemaAST7.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
+  return Schema10.make(new SchemaAST9.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
 };
 var removeFieldsFromSchema = (schema, fieldNames) => {
-  return Schema11.make(SchemaAST7.omit(schema.ast, fieldNames)).annotations(schema.ast.annotations);
+  return Schema10.make(SchemaAST9.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
-    }
-  });
+  invariant12(SchemaAST9.isTypeLiteral(ast), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file12, L: 34, S: void 0, A: ["SchemaAST.isTypeLiteral(ast)", ""] });
+  return Schema10.make(new SchemaAST9.TypeLiteral(ast.propertySignatures.map((p) => p.name === before ? new SchemaAST9.PropertySignature(after, p.type, p.isOptional, p.isReadonly, p.annotations) : p), ast.indexSignatures, ast.annotations));
 };
 
-// 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,
+// src/internal/Type/type-schema.ts
+import * as Schema11 from "effect/Schema";
+var TypeSchemaStruct = Schema11.Struct({
+  name: Schema11.optional(Schema11.String),
   jsonSchema: JsonSchemaType
-}).pipe(EchoObjectSchema({
-  typename: "org.dxos.type.schema",
-  version: "0.1.0"
-}), LabelAnnotation.set([
+});
+var TypeSchema = TypeSchemaStruct.pipe(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))
-  };
-};
+}), EchoTypeKindSchema(TypeMetaSchemaDXN));
 
 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,
@@ -2790,20 +2240,19 @@ export {
   makeObject,
   subscribe,
   change,
-  assertObjectModel,
-  getObjectDXN,
-  getDXN,
-  getDatabase,
+  TypeMetaSchemaDXN,
   makeEchoTypeSchema,
+  normalizeSchema,
   EchoObjectSchema,
   EchoRelationSchema,
+  getDXNForRelationSchemaRef,
+  EchoTypeKindSchema,
   isVersion,
   version,
   versionValid,
   compareVersions,
   encodeVersion,
   decodeVersion,
-  normalizeSchema,
   makeTypedEntityClass,
   objectToJSON,
   objectFromJSON,
@@ -2811,9 +2260,13 @@ export {
   objectStructureToJson,
   createObject,
   isDeleted,
-  createQueueDXN,
   setValue,
   getSnapshot,
+  makeAtom,
+  makeProperty,
+  makeWithReactive,
+  makeEntity,
+  makeRelation,
   clone,
   prettyFilter,
   prettyQuery,
@@ -2821,14 +2274,6 @@ export {
   updateFieldsInSchema,
   removeFieldsFromSchema,
   updateFieldNameInSchema,
-  setTypenameInSchema,
-  PersistentSchema,
-  ImmutableSchema,
-  isMutable,
-  EchoSchema,
-  JsonPath,
-  JsonProp,
-  getValue,
-  splitJsonPath
-};
-//# sourceMappingURL=chunk-MOR5ERFM.mjs.map
+  TypeSchema
+};
+//# sourceMappingURL=chunk-7FPIAJIV.mjs.map