@dxos/echo 0.8.4-main.e098934 → 0.8.4-main.e8ec1fe

package/dist/lib/browser/chunk-BIDAASFK.mjs

@@ -0,0 +1,3727 @@
+import "@dxos/node-std/globals";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/internal/index.ts
+import { JsonPath as JsonPath2, splitJsonPath as splitJsonPath2, JsonProp } from "@dxos/effect";
+import { ObjectId as ObjectId9 } from "@dxos/keys";
+import { ForeignKey as ForeignKey2 } from "@dxos/echo-protocol";
+
+// src/internal/ast/annotations.ts
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema2 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+import { assertArgument } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+
+// src/internal/ast/annotation-helper.ts
+import * as SchemaAST from "effect/SchemaAST";
+var createAnnotationHelper = (id) => {
+  return {
+    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),
+    set: (value) => (schema) => schema.annotations({
+      [id]: value
+    })
+  };
+};
+
+// src/internal/ast/entity-kind.ts
+import * as Schema from "effect/Schema";
+var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
+  EntityKind2["Object"] = "object";
+  EntityKind2["Relation"] = "relation";
+  return EntityKind2;
+})({});
+var EntityKindSchema = Schema.Enums(EntityKind);
+
+// src/internal/ast/annotations.ts
+var unwrapOptional = (property) => {
+  if (!property.isOptional || !SchemaAST2.isUnion(property.type)) {
+    return property;
+  }
+  return property.type.types[0];
+};
+var TypeIdentifierAnnotationId = Symbol.for("@dxos/schema/annotation/TypeIdentifier");
+var getTypeIdentifierAnnotation = (schema) => Function.flow(SchemaAST2.getAnnotation(TypeIdentifierAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+var TypeAnnotationId = Symbol.for("@dxos/schema/annotation/Type");
+var Typename = Schema2.String.pipe(Schema2.pattern(/^[a-zA-Z]\w+\.[a-zA-Z]\w{1,}\/[\w/_-]+$/));
+var SchemaVersion = Schema2.String.pipe(Schema2.pattern(/^\d+.\d+.\d+$/));
+var TypeAnnotation = Schema2.Struct({
+  kind: Schema2.Enums(EntityKind),
+  typename: Typename,
+  version: SchemaVersion,
+  /**
+  * If this is a relation, the schema of the source object.
+  * Must be present if entity kind is {@link EntityKind.Relation}.
+  */
+  sourceSchema: Schema2.optional(DXN.Schema),
+  /**
+  * If this is a relation, the schema of the target object.
+  * Must be present if entity kind is {@link EntityKind.Relation}.
+  */
+  targetSchema: Schema2.optional(DXN.Schema)
+});
+var getTypeAnnotation = (schema) => {
+  assertArgument(schema != null && schema.ast != null, "schema", "invalid schema");
+  return Function.flow(SchemaAST2.getAnnotation(TypeAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+};
+var getEntityKind = (schema) => getTypeAnnotation(schema)?.kind;
+var getSchemaTypename = (schema) => getTypeAnnotation(schema)?.typename;
+var getSchemaVersion = (schema) => getTypeAnnotation(schema)?.version;
+var PropertyMetaAnnotationId = Symbol.for("@dxos/schema/annotation/PropertyMeta");
+var PropertyMeta = (name, value) => {
+  return (self) => {
+    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId];
+    return self.annotations({
+      [PropertyMetaAnnotationId]: {
+        ...existingMeta,
+        [name]: value
+      }
+    });
+  };
+};
+var getPropertyMetaAnnotation = (prop, name) => Function.pipe(SchemaAST2.getAnnotation(PropertyMetaAnnotationId)(prop.type), Option.map((meta) => meta[name]), Option.getOrElse(() => void 0));
+var ReferenceAnnotationId = Symbol.for("@dxos/schema/annotation/Reference");
+var getReferenceAnnotation = (schema) => Function.pipe(SchemaAST2.getAnnotation(ReferenceAnnotationId)(schema.ast), Option.getOrElse(() => void 0));
+var SchemaMetaSymbol = Symbol.for("@dxos/schema/SchemaMeta");
+var ViewAnnotationId = Symbol.for("@dxos/schema/annotation/View");
+var ViewAnnotation = createAnnotationHelper(ViewAnnotationId);
+var LabelAnnotationId = Symbol.for("@dxos/schema/annotation/Label");
+var LabelAnnotation = createAnnotationHelper(LabelAnnotationId);
+var DescriptionAnnotationId = Symbol.for("@dxos/schema/annotation/Description");
+var DescriptionAnnotation = createAnnotationHelper(DescriptionAnnotationId);
+var FormAnnotationId = Symbol.for("@dxos/schema/annotation/Form");
+var FormAnnotation = createAnnotationHelper(FormAnnotationId);
+var FieldLookupAnnotationId = Symbol.for("@dxos/schema/annotation/FieldLookup");
+var GeneratorAnnotationId = Symbol.for("@dxos/schema/annotation/Generator");
+var GeneratorAnnotation = createAnnotationHelper(GeneratorAnnotationId);
+var getSchemaDXN = (schema) => {
+  assertArgument(Schema2.isSchema(schema), "schema", "invalid schema");
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return DXN.parse(id);
+  }
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (!objectAnnotation) {
+    return void 0;
+  }
+  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);
+};
+
+// src/internal/ast/types.ts
+var FIELD_PATH_ANNOTATION = "path";
+var FieldPath = (path) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
+
+// src/internal/formats/number.ts
+import * as Schema3 from "effect/Schema";
+
+// src/internal/formats/types.ts
+import * as Function2 from "effect/Function";
+import * as Option2 from "effect/Option";
+import * as SchemaAST3 from "effect/SchemaAST";
+var TypeEnum = /* @__PURE__ */ (function(TypeEnum2) {
+  TypeEnum2["Array"] = "array";
+  TypeEnum2["Object"] = "object";
+  TypeEnum2["String"] = "string";
+  TypeEnum2["Number"] = "number";
+  TypeEnum2["Boolean"] = "boolean";
+  TypeEnum2["Ref"] = "ref";
+  return TypeEnum2;
+})({});
+var getTypeEnum = (property) => {
+  switch (property.type) {
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return void 0;
+  }
+};
+var FormatAnnotationId = Symbol.for("@dxos/schema/annotation/Format");
+var FormatAnnotation = createAnnotationHelper(FormatAnnotationId);
+var getFormatAnnotation = (node) => Function2.pipe(SchemaAST3.getAnnotation(FormatAnnotationId)(node), Option2.getOrUndefined);
+var FormatEnum = /* @__PURE__ */ (function(FormatEnum2) {
+  FormatEnum2["None"] = "none";
+  FormatEnum2["String"] = "string";
+  FormatEnum2["Number"] = "number";
+  FormatEnum2["Boolean"] = "boolean";
+  FormatEnum2["Ref"] = "ref";
+  FormatEnum2["DID"] = "did";
+  FormatEnum2["DXN"] = "dxn";
+  FormatEnum2["Email"] = "email";
+  FormatEnum2["Formula"] = "formula";
+  FormatEnum2["Hostname"] = "hostname";
+  FormatEnum2["JSON"] = "json";
+  FormatEnum2["Markdown"] = "markdown";
+  FormatEnum2["Regex"] = "regex";
+  FormatEnum2["SingleSelect"] = "single-select";
+  FormatEnum2["MultiSelect"] = "multi-select";
+  FormatEnum2["URL"] = "url";
+  FormatEnum2["UUID"] = "uuid";
+  FormatEnum2["Currency"] = "currency";
+  FormatEnum2["Integer"] = "integer";
+  FormatEnum2["Percent"] = "percent";
+  FormatEnum2["Timestamp"] = "timestamp";
+  FormatEnum2["DateTime"] = "date-time";
+  FormatEnum2["Date"] = "date";
+  FormatEnum2["Time"] = "time";
+  FormatEnum2["Duration"] = "duration";
+  FormatEnum2["GeoPoint"] = "lnglat";
+  return FormatEnum2;
+})({});
+var FormatEnums = Object.values(FormatEnum).sort();
+var PropertyKind = {
+  type: TypeEnum,
+  format: FormatEnum
+};
+var typeToFormat = {
+  ["string"]: "string",
+  ["number"]: "number",
+  ["boolean"]: "boolean"
+};
+var formatToType = {
+  ["none"]: void 0,
+  ["string"]: "string",
+  ["number"]: "number",
+  ["boolean"]: "boolean",
+  ["ref"]: "ref",
+  ["did"]: "string",
+  ["dxn"]: "string",
+  ["email"]: "string",
+  ["formula"]: "string",
+  ["hostname"]: "string",
+  ["json"]: "string",
+  ["markdown"]: "string",
+  ["regex"]: "string",
+  ["url"]: "string",
+  ["uuid"]: "string",
+  ["single-select"]: "string",
+  ["multi-select"]: "object",
+  ["date"]: "string",
+  ["date-time"]: "string",
+  ["duration"]: "string",
+  ["time"]: "string",
+  ["currency"]: "number",
+  ["integer"]: "number",
+  ["percent"]: "number",
+  ["timestamp"]: "number",
+  ["lnglat"]: "array"
+};
+var OptionsAnnotationId = Symbol.for("@dxos/schema/annotation/Options");
+var getOptionsAnnotation = (node) => Function2.pipe(SchemaAST3.getAnnotation(OptionsAnnotationId)(node), Option2.getOrUndefined);
+
+// src/internal/formats/number.ts
+var encodeMultipleOf = (divisor) => 1 / Math.pow(10, divisor);
+var encodeMultiple = (divisor) => (self) => divisor === void 0 || divisor === 0 ? self : self.pipe(Schema3.multipleOf(encodeMultipleOf(divisor)));
+var DecimalPrecision = Schema3.transform(Schema3.Number, Schema3.Number, {
+  strict: true,
+  encode: (value) => encodeMultipleOf(value),
+  decode: (value) => Math.log10(1 / value)
+}).annotations({
+  title: "Number of digits"
+});
+var CurrencyAnnotationId = Symbol.for("@dxos/schema/annotation/Currency");
+var Currency = ({ decimals, code } = {
+  decimals: 2
+}) => Schema3.Number.pipe(encodeMultiple(decimals), FormatAnnotation.set(FormatEnum.Currency), Schema3.annotations({
+  title: "Currency",
+  description: "Currency value",
+  ...code ? {
+    [CurrencyAnnotationId]: code.toUpperCase()
+  } : {}
+}));
+var Integer = () => Schema3.Number.pipe(Schema3.int(), FormatAnnotation.set(FormatEnum.Integer), Schema3.annotations({
+  title: "Integer",
+  description: "Integer value"
+}));
+var Percent = ({ decimals } = {
+  decimals: 2
+}) => Schema3.Number.pipe(encodeMultiple(decimals), FormatAnnotation.set(FormatEnum.Percent), Schema3.annotations({
+  title: "Percent",
+  description: "Percentage value"
+}));
+var Timestamp = Schema3.Number.pipe(FormatAnnotation.set(FormatEnum.Timestamp), Schema3.annotations({
+  title: "Timestamp",
+  description: "Unix timestamp"
+}));
+
+// src/internal/formats/object.ts
+import * as Schema4 from "effect/Schema";
+import { clamp as clamp2 } from "@dxos/util";
+var GeoPoint = Schema4.Tuple(Schema4.Number.pipe(Schema4.annotations({
+  title: "Longitude"
+}), Schema4.clamp(-180, 180), Schema4.multipleOf(1e-5)), Schema4.Number.pipe(Schema4.annotations({
+  title: "Latitude"
+}), Schema4.clamp(-90, 90), Schema4.multipleOf(1e-5)), Schema4.optionalElement(Schema4.Number).annotations({
+  title: "Height ASL (m)"
+})).pipe(FormatAnnotation.set(FormatEnum.GeoPoint), Schema4.annotations({
+  title: "GeoPoint",
+  description: "GeoJSON Position"
+}));
+(function(GeoLocation2) {
+  GeoLocation2.toGeoPoint = ({ longitude, latitude, height }) => {
+    const clampedLongitude = clamp2(longitude, -180, 180);
+    const clampedLatitude = clamp2(latitude, -90, 90);
+    return height !== void 0 ? [
+      clampedLongitude,
+      clampedLatitude,
+      height
+    ] : [
+      clampedLongitude,
+      clampedLatitude
+    ];
+  };
+  GeoLocation2.fromGeoPoint = (geoPoint) => {
+    if (!geoPoint) {
+      return {
+        longitude: 0,
+        latitude: 0
+      };
+    }
+    const result = {
+      longitude: geoPoint[0],
+      latitude: geoPoint[1]
+    };
+    if (geoPoint[2] !== void 0) {
+      result.height = geoPoint[2];
+    }
+    return result;
+  };
+})(GeoLocation || (GeoLocation = {}));
+var GeoLocation;
+
+// src/internal/formats/format.ts
+import * as Schema7 from "effect/Schema";
+import * as Keys from "@dxos/keys";
+
+// src/internal/formats/date.ts
+import * as Schema5 from "effect/Schema";
+import * as SchemaAST4 from "effect/SchemaAST";
+var SimpleDate = Schema5.Struct({
+  year: Schema5.Number.pipe(Schema5.between(1900, 9999)),
+  month: Schema5.Number.pipe(Schema5.between(1, 12)),
+  day: Schema5.Number.pipe(Schema5.between(1, 31))
+});
+var SimpleTime = Schema5.Struct({
+  hours: Schema5.Number.pipe(Schema5.between(0, 23)),
+  minutes: Schema5.Number.pipe(Schema5.between(0, 59)),
+  seconds: Schema5.Number.pipe(Schema5.between(0, 59))
+});
+var SimpleDateTime = Schema5.extend(SimpleDate, SimpleTime);
+var DateOnly = (
+  /* Schema.transformOrFail(Schema.String, SimpleDate, {
+    strict: true,
+    decode: (str, _, ast) => {
+      if (!isValidDateFormat(str)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected YYYY-MM-DD format'));
+      }
+      if (!isValidDate(str)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Invalid date'));
+      }
+  
+      const [year, month, day] = str.split('-').map(Number);
+      return ParseResult.succeed({ year, month, day });
+    },
+    encode: (date) => {
+      return ParseResult.succeed(
+        [
+          date.year.toString().padStart(4, '0'),
+          date.month.toString().padStart(2, '0'),
+          date.day.toString().padStart(2, '0'),
+        ].join('-'),
+      );
+    },
+  }) */
+  Schema5.String.pipe(FormatAnnotation.set(FormatEnum.Date), Schema5.annotations({
+    title: "Date",
+    description: "Valid date in ISO format"
+  }))
+);
+var TimeOnly = (
+  /* Schema.transformOrFail(Schema.String, SimpleTime, {
+    strict: true,
+    decode: (str, _, ast) => {
+      if (!isValidTimeFormat(str)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));
+      }
+  
+      const [hours, minutes, seconds] = str.split(':').map(Number);
+      return ParseResult.succeed({ hours, minutes, seconds });
+    },
+    encode: (time) => {
+      return ParseResult.succeed(
+        [
+          time.hours.toString().padStart(2, '0'),
+          time.minutes.toString().padStart(2, '0'),
+          time.seconds.toString().padStart(2, '0'),
+        ].join(':'),
+      );
+    },
+  }) */
+  Schema5.String.pipe(FormatAnnotation.set(FormatEnum.Time), Schema5.annotations({
+    title: "Time",
+    description: "Valid time in ISO format"
+  }))
+);
+var DateTime = (
+  /* Schema.transformOrFail(Schema.String, SimpleDateTime, {
+    strict: false,
+    decode: (str, _, ast) => {
+      const [date, time] = str.split('T');
+      if (!isValidDateFormat(date)) {
+        return ParseResult.fail(new ParseResult.Type(ast, date, 'Expected YYYY-MM-DD format'));
+      }
+      if (!isValidDate(date)) {
+        return ParseResult.fail(new ParseResult.Type(ast, date, 'Invalid date'));
+      }
+      if (!isValidTimeFormat(time)) {
+        return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));
+      }
+  
+      const [year, month, day] = date.split('-').map(Number);
+      const [hours, minutes, seconds] = time.split(':').map(Number);
+      return ParseResult.succeed({ year, month, day, hours, minutes, seconds });
+    },
+    encode: (datetime) => {
+      return ParseResult.succeed(
+        [
+          [
+            datetime.year.toString().padStart(4, '0'),
+            datetime.month.toString().padStart(2, '0'),
+            datetime.day.toString().padStart(2, '0'),
+          ].join('-'),
+          [
+            datetime.hours.toString().padStart(2, '0'),
+            datetime.minutes.toString().padStart(2, '0'),
+            datetime.seconds.toString().padStart(2, '0'),
+          ].join(':'),
+        ].join('T'),
+      );
+    },
+  }) */
+  Schema5.String.pipe(FormatAnnotation.set(FormatEnum.DateTime), Schema5.annotations({
+    title: "DateTime",
+    description: "Valid date and time in ISO format"
+  }))
+);
+var Duration = Schema5.String.pipe(FormatAnnotation.set(FormatEnum.Duration), Schema5.annotations({
+  title: "Duration",
+  description: "Duration in ISO 8601 format",
+  [SchemaAST4.ExamplesAnnotationId]: [
+    "1h",
+    "3D"
+  ]
+}));
+
+// src/internal/formats/string.ts
+import * as Schema6 from "effect/Schema";
+import * as SchemaAST5 from "effect/SchemaAST";
+var Email = Schema6.String.pipe(Schema6.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/), FormatAnnotation.set(FormatEnum.Email), Schema6.annotations({
+  title: "Email",
+  description: "Email address"
+}));
+var Formula = Schema6.String.pipe(FormatAnnotation.set(FormatEnum.Formula));
+var Hostname = Schema6.String.pipe(FormatAnnotation.set(FormatEnum.Hostname));
+var JSON = Schema6.String.pipe(FormatAnnotation.set(FormatEnum.JSON));
+var Markdown = Schema6.String.pipe(FormatAnnotation.set(FormatEnum.Markdown));
+var Regex = Schema6.String.pipe(FormatAnnotation.set(FormatEnum.Regex));
+var URL = Schema6.String.pipe(Schema6.pattern(/^(\w+?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/i), FormatAnnotation.set(FormatEnum.URL), Schema6.annotations({
+  title: "URL",
+  description: "URL"
+}));
+var UUID2 = Schema6.UUID.pipe(FormatAnnotation.set(FormatEnum.UUID), Schema6.annotations({
+  [SchemaAST5.ExamplesAnnotationId]: [
+    "3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a"
+  ]
+}));
+
+// src/internal/formats/format.ts
+(function(Format2) {
+  Format2.DXN = Keys.DXN.Schema;
+  Format2.Email = Email;
+  Format2.Formula = Formula;
+  Format2.Hostname = Hostname;
+  Format2.JSON = JSON;
+  Format2.Markdown = Markdown;
+  Format2.Regex = Regex;
+  Format2.URL = URL;
+  Format2.UUID = Schema7.UUID;
+  Format2.Currency = Currency;
+  Format2.Integer = Integer;
+  Format2.Percent = Percent;
+  Format2.Timestamp = Timestamp;
+  Format2.DateTime = DateTime;
+  Format2.Date = DateOnly;
+  Format2.Time = TimeOnly;
+  Format2.Duration = Duration;
+  Format2.GeoPoint = GeoPoint;
+})(Format || (Format = {}));
+var Format;
+
+// src/internal/formats/select.ts
+import * as Schema8 from "effect/Schema";
+var SelectOptionSchema = Schema8.Struct({
+  /** Stable identifier for the option. */
+  id: Schema8.NonEmptyString,
+  title: Schema8.String,
+  /** Color palette used for visual styling. */
+  color: Schema8.String
+}).pipe(Schema8.mutable);
+
+// src/internal/json/json-schema.ts
+import * as Array4 from "effect/Array";
+import * as Function3 from "effect/Function";
+import * as JSONSchema from "effect/JSONSchema";
+import * as Option5 from "effect/Option";
+import * as Schema19 from "effect/Schema";
+import * as SchemaAST11 from "effect/SchemaAST";
+import { raise as raise4 } from "@dxos/debug";
+import { mapAst } from "@dxos/effect";
+import { assertArgument as assertArgument7, invariant as invariant10 } from "@dxos/invariant";
+import { DXN as DXN10, ObjectId as ObjectId7 } from "@dxos/keys";
+import { log } from "@dxos/log";
+import { clearUndefined, orderKeys, removeProperties } from "@dxos/util";
+
+// src/internal/json-schema/json-schema-type.ts
+import * as Schema9 from "effect/Schema";
+import { JsonPath } from "@dxos/effect";
+var SimpleTypes = Schema9.Literal("array", "boolean", "integer", "null", "number", "object", "string");
+var NonNegativeInteger = Schema9.Number.pipe(Schema9.greaterThanOrEqualTo(0));
+var StringArray = Schema9.Array(Schema9.String).pipe(Schema9.mutable);
+var JsonSchemaOrBoolean = Schema9.Union(Schema9.suspend(() => JsonSchemaType), Schema9.Boolean);
+var JsonSchemaEchoAnnotations = Schema9.Struct({
+  /**
+  * Label for this schema.
+  * Mapped from {@link LabelAnnotationId}.
+  */
+  labelProp: Schema9.optional(Schema9.Union(JsonPath, Schema9.Array(JsonPath))),
+  /**
+  * Generator function for this schema.
+  * Mapped from {@link GeneratorAnnotationId}.
+  */
+  generator: Schema9.optional(Schema9.Union(Schema9.String, Schema9.Tuple(Schema9.String, Schema9.Number))),
+  /**
+  * {@link PropertyMeta} annotations get serialized here.
+  */
+  meta: Schema9.optional(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.Any
+  }).pipe(Schema9.mutable)),
+  /**
+  * @deprecated
+  */
+  // TODO(dmaretskyi): We risk old schema not passing validation due to the extra fields. Remove when we are sure this is safe
+  type: Schema9.optional(Schema9.Struct({
+    typename: Schema9.String,
+    version: Schema9.String,
+    // Not used.
+    schemaId: Schema9.optional(Schema9.String)
+  }).pipe(Schema9.mutable)),
+  /**
+  * @deprecated Superseded by `meta`.
+  */
+  annotations: Schema9.optional(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.Any
+  }).pipe(Schema9.mutable))
+}).pipe(Schema9.mutable);
+var _JsonSchemaType = Schema9.Struct({
+  /**
+  * Identifier for this schema.
+  * This schema might be referenced by $ref clause in other schemas.
+  */
+  // TODO(dmaretskyi): Specify how the ids are generated.
+  // TODO(dmaretskyi): For type dxns, should this include the version?
+  $id: Schema9.optional(Schema9.String),
+  /**
+  * Schema of this schema.
+  * Set to "https://json-schema.org/draft-07/schema".
+  */
+  $schema: Schema9.optional(Schema9.String),
+  /**
+  * Reference to another schema.
+  */
+  $ref: Schema9.optional(Schema9.String),
+  /**
+  * Comments are ignored when interpreting the schema.
+  */
+  $comment: Schema9.optional(Schema9.String),
+  /**
+  * Defines whether this schema is an object schema or a relation schema.
+  */
+  entityKind: Schema9.optional(EntityKindSchema),
+  /**
+  * Typename of this schema.
+  * Only on schema representing an ECHO object.
+  *
+  * @example 'example.com/type/MyType'
+  */
+  typename: Schema9.optional(Schema9.String),
+  /**
+  * Version of this schema.
+  * Custom dialect for ECHO.
+  */
+  version: Schema9.optional(Schema9.String),
+  /**
+  * Target of this relation.
+  * Only for relation schemas.
+  * The referenced schema must be an object schema.
+  */
+  relationTarget: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  /**
+  * Source of this relation.
+  * Only for relation schemas.
+  * The referenced schema must be an object schema.
+  */
+  relationSource: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  /**
+  * Title of this schema.
+  */
+  title: Schema9.optional(Schema9.String),
+  /**
+  * Description of this schema.
+  */
+  description: Schema9.optional(Schema9.String),
+  /**
+  * Whether this schema is read-only.
+  */
+  readOnly: Schema9.optional(Schema9.Boolean),
+  /**
+  * Whether this schema is write-only.
+  */
+  writeOnly: Schema9.optional(Schema9.Boolean),
+  /**
+  * Examples of instances of this schema.
+  */
+  examples: Schema9.optional(Schema9.Array(Schema9.Any)),
+  /**
+  * Default value for this schema.
+  */
+  default: Schema9.optional(Schema9.Any),
+  /**
+  * This schema only matches values that are equal to this value.
+  */
+  const: Schema9.optional(Schema9.Any),
+  /**
+  * This schema only matches one of the values in this array.
+  */
+  enum: Schema9.optional(Schema9.Array(Schema9.Any)),
+  /**
+  * Base type of the schema.
+  */
+  type: Schema9.optional(Schema9.Union(SimpleTypes, Schema9.Array(SimpleTypes))),
+  //
+  // Numbers.
+  //
+  multipleOf: Schema9.optional(Schema9.Number.pipe(Schema9.greaterThan(0))),
+  maximum: Schema9.optional(Schema9.Number),
+  exclusiveMaximum: Schema9.optional(Schema9.Number),
+  minimum: Schema9.optional(Schema9.Number),
+  exclusiveMinimum: Schema9.optional(Schema9.Number),
+  //
+  // Strings.
+  //
+  maxLength: Schema9.optional(NonNegativeInteger),
+  /**
+  * Regex pattern for strings.
+  */
+  pattern: Schema9.optional(Schema9.String.pipe(FormatAnnotation.set(FormatEnum.Regex))),
+  /**
+  * Serialized from {@link FormatAnnotationId}.
+  */
+  format: Schema9.optional(Schema9.String),
+  //
+  // Arrays
+  //
+  minLength: Schema9.optional(NonNegativeInteger),
+  items: Schema9.optional(Schema9.Union(Schema9.suspend(() => JsonSchemaType), Schema9.Array(Schema9.suspend(() => JsonSchemaType)))),
+  additionalItems: Schema9.optional(Schema9.Union(Schema9.suspend(() => JsonSchemaType), Schema9.Boolean)),
+  maxItems: Schema9.optional(NonNegativeInteger),
+  minItems: Schema9.optional(NonNegativeInteger),
+  uniqueItems: Schema9.optional(Schema9.Boolean),
+  contains: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  //
+  // Objects
+  //
+  maxProperties: Schema9.optional(NonNegativeInteger),
+  minProperties: Schema9.optional(NonNegativeInteger),
+  required: Schema9.optional(StringArray),
+  /**
+  * Non-standard JSON Schema extension.
+  * Defines the order of properties in the object.
+  * The unmentioned properties are placed at the end.
+  *
+  * Related: https://github.com/json-schema/json-schema/issues/119
+  */
+  propertyOrder: Schema9.optional(StringArray),
+  additionalProperties: Schema9.optional(JsonSchemaOrBoolean),
+  properties: Schema9.optional(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.suspend(() => JsonSchemaType)
+  }).pipe(Schema9.mutable)),
+  patternProperties: Schema9.optional(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.suspend(() => JsonSchemaType)
+  }).pipe(Schema9.mutable)),
+  propertyNames: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  definitions: Schema9.optional(Schema9.mutable(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.suspend(() => JsonSchemaType)
+  }))),
+  dependencies: Schema9.optional(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.suspend(() => Schema9.Union(Schema9.String, StringArray, JsonSchemaType)).annotations({
+      identifier: "dependency",
+      description: "Dependency"
+    })
+  })),
+  contentMediaType: Schema9.optional(Schema9.String),
+  contentEncoding: Schema9.optional(Schema9.String),
+  if: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  then: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  else: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  allOf: Schema9.optional(Schema9.Array(Schema9.suspend(() => JsonSchemaType))),
+  anyOf: Schema9.optional(Schema9.Array(Schema9.suspend(() => JsonSchemaType))),
+  oneOf: Schema9.optional(Schema9.Array(Schema9.suspend(() => JsonSchemaType))),
+  not: Schema9.optional(Schema9.suspend(() => JsonSchemaType)),
+  $defs: Schema9.optional(Schema9.mutable(Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.suspend(() => JsonSchemaType)
+  }))),
+  //
+  // ECHO extensions.
+  //
+  currency: Schema9.optional(Schema9.String),
+  reference: Schema9.optional(Schema9.mutable(Schema9.Struct({
+    schema: Schema9.suspend(() => JsonSchemaType),
+    schemaVersion: Schema9.optional(Schema9.String),
+    schemaObject: Schema9.optional(Schema9.String)
+  }))),
+  /**
+  * ECHO-specific annotations.
+  */
+  // TODO(dmaretskyi): Since we are adding a lot of new extensions to the JSON Schema, it is safer to namespace them here.
+  annotations: Schema9.optional(Schema9.mutable(JsonSchemaEchoAnnotations)),
+  /**
+  * @deprecated Use `annotations` instead.
+  */
+  echo: Schema9.optional(Schema9.mutable(JsonSchemaEchoAnnotations))
+}).annotations({
+  identifier: "jsonSchema",
+  description: "JSON Schema"
+});
+var JsonSchemaFields = Object.keys(_JsonSchemaType.fields);
+var JsonSchemaType = _JsonSchemaType.pipe(Schema9.mutable);
+var getSchemaProperty = (schema, property) => {
+  return schema.properties?.[property];
+};
+var setSchemaProperty = (schema, property, value) => {
+  schema.properties ??= {};
+  schema.properties[property] = value;
+  return schema;
+};
+var ECHO_ANNOTATIONS_NS_DEPRECATED_KEY = "echo";
+var ECHO_ANNOTATIONS_NS_KEY = "annotations";
+var getNormalizedEchoAnnotations = (obj) => {
+  if (obj[ECHO_ANNOTATIONS_NS_KEY] != null && obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {
+    return normalizeEchoAnnotations({
+      ...obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY],
+      ...obj[ECHO_ANNOTATIONS_NS_KEY]
+    });
+  } else if (obj[ECHO_ANNOTATIONS_NS_KEY] != null) {
+    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_KEY]);
+  } else if (obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY] != null) {
+    return normalizeEchoAnnotations(obj[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY]);
+  } else {
+    return void 0;
+  }
+};
+var normalizeEchoAnnotations = (obj) => {
+  if (!obj.annotations) {
+    return obj;
+  } else {
+    const res = {
+      ...obj,
+      meta: {
+        ...obj.annotations,
+        ...obj.meta ?? {}
+      }
+    };
+    delete res.annotations;
+    return res;
+  }
+};
+
+// src/internal/json-schema/json-schema-normalize.ts
+var normalizeSchema = (schema) => {
+  const copy = structuredClone(schema);
+  go(copy);
+  return copy;
+};
+var go = (schema) => {
+  if (typeof schema !== "object" || schema === null) {
+    return;
+  }
+  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 = (value) => {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      go(item);
+    }
+  } else if (typeof value === "object" && value !== null) {
+    go(value);
+  }
+};
+var goOnRecord = (record) => {
+  for (const key of Object.keys(record)) {
+    go(record[key]);
+  }
+};
+
+// src/internal/object/common.ts
+import * as Schema11 from "effect/Schema";
+
+// src/internal/object/typename.ts
+import { invariant as invariant3 } from "@dxos/invariant";
+import { DXN as DXN5 } from "@dxos/keys";
+
+// src/internal/object/accessors.ts
+import * as Option3 from "effect/Option";
+import * as Schema10 from "effect/Schema";
+import { getField } from "@dxos/effect";
+import { assertArgument as assertArgument2, invariant as invariant2 } from "@dxos/invariant";
+import { DXN as DXN4, ObjectId as ObjectId2 } from "@dxos/keys";
+import { assumeType as assumeType2 } from "@dxos/util";
+
+// src/internal/object/model.ts
+import { invariant } from "@dxos/invariant";
+import { DXN as DXN3, ObjectId } from "@dxos/keys";
+import { assumeType } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/model.ts";
+var EntityKindId = Symbol.for("@dxos/echo/EntityKind");
+var SelfDXNId = Symbol.for("@dxos/echo/DXN");
+var ATTR_SELF_DXN = "@dxn";
+var TypeId = Symbol.for("@dxos/echo/Type");
+var ATTR_TYPE = "@type";
+var SchemaId = Symbol.for("@dxos/echo/Schema");
+var DeletedId = Symbol.for("@dxos/echo/Deleted");
+var ATTR_DELETED = "@deleted";
+var MetaId = Symbol.for("@dxos/echo/Meta");
+var ATTR_META = "@meta";
+var RelationSourceDXNId = Symbol.for("@dxos/echo/RelationSourceDXN");
+var ATTR_RELATION_SOURCE = "@relationSource";
+var RelationTargetDXNId = Symbol.for("@dxos/echo/RelationTargetDXN");
+var ATTR_RELATION_TARGET = "@relationTarget";
+var RelationSourceId = Symbol.for("@dxos/echo/RelationSource");
+var RelationTargetId = Symbol.for("@dxos/echo/RelationTarget");
+var ObjectVersionId = Symbol.for("@dxos/echo/ObjectVersion");
+function assertObjectModelShape(obj) {
+  invariant(typeof obj === "object" && obj !== null, "Invalid object model: not an object", {
+    F: __dxlog_file,
+    L: 156,
+    S: this,
+    A: [
+      "typeof obj === 'object' && obj !== null",
+      "'Invalid object model: not an object'"
+    ]
+  });
+  assumeType(obj);
+  invariant(ObjectId.isValid(obj.id), "Invalid object model: invalid id", {
+    F: __dxlog_file,
+    L: 158,
+    S: this,
+    A: [
+      "ObjectId.isValid(obj.id)",
+      "'Invalid object model: invalid id'"
+    ]
+  });
+  invariant(obj[TypeId] === void 0 || obj[TypeId] instanceof DXN3, "Invalid object model: invalid type", {
+    F: __dxlog_file,
+    L: 159,
+    S: this,
+    A: [
+      "obj[TypeId] === undefined || obj[TypeId] instanceof DXN",
+      "'Invalid object model: invalid type'"
+    ]
+  });
+  invariant(obj[EntityKindId] === EntityKind.Object || obj[EntityKindId] === EntityKind.Relation, "Invalid object model: invalid entity kind", {
+    F: __dxlog_file,
+    L: 160,
+    S: this,
+    A: [
+      "obj[EntityKindId] === EntityKind.Object || obj[EntityKindId] === EntityKind.Relation",
+      "'Invalid object model: invalid entity kind'"
+    ]
+  });
+  if (obj[EntityKindId] === EntityKind.Relation) {
+    invariant(obj[RelationSourceDXNId] instanceof DXN3, "Invalid object model: invalid relation source", {
+      F: __dxlog_file,
+      L: 165,
+      S: this,
+      A: [
+        "obj[RelationSourceDXNId] instanceof DXN",
+        "'Invalid object model: invalid relation source'"
+      ]
+    });
+    invariant(obj[RelationTargetDXNId] instanceof DXN3, "Invalid object model: invalid relation target", {
+      F: __dxlog_file,
+      L: 166,
+      S: this,
+      A: [
+        "obj[RelationTargetDXNId] instanceof DXN",
+        "'Invalid object model: invalid relation target'"
+      ]
+    });
+    invariant(!(obj[RelationSourceId] instanceof DXN3), "Invalid object model: source pointer is a DXN", {
+      F: __dxlog_file,
+      L: 167,
+      S: this,
+      A: [
+        "!(obj[RelationSourceId] instanceof DXN)",
+        "'Invalid object model: source pointer is a DXN'"
+      ]
+    });
+    invariant(!(obj[RelationTargetId] instanceof DXN3), "Invalid object model: target pointer is a DXN", {
+      F: __dxlog_file,
+      L: 168,
+      S: this,
+      A: [
+        "!(obj[RelationTargetId] instanceof DXN)",
+        "'Invalid object model: target pointer is a DXN'"
+      ]
+    });
+  }
+}
+
+// src/internal/object/accessors.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/accessors.ts";
+var getObjectDXN = (object) => {
+  invariant2(!Schema10.isSchema(object), "schema not allowed in this function", {
+    F: __dxlog_file2,
+    L: 26,
+    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]) {
+    invariant2(object[SelfDXNId] instanceof DXN4, "Invalid object model: invalid self dxn", {
+      F: __dxlog_file2,
+      L: 31,
+      S: void 0,
+      A: [
+        "object[SelfDXNId] instanceof DXN",
+        "'Invalid object model: invalid self dxn'"
+      ]
+    });
+    return object[SelfDXNId];
+  }
+  if (!ObjectId2.isValid(object.id)) {
+    throw new TypeError("Object id is not valid.");
+  }
+  return DXN4.fromLocalObjectId(object.id);
+};
+var getSchema = (obj) => {
+  if (obj) {
+    return obj[SchemaId];
+  }
+};
+var setSchema = (obj, schema) => {
+  Object.defineProperty(obj, SchemaId, {
+    value: schema,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+var getLabelForObject = (obj) => {
+  const schema = getSchema(obj);
+  if (schema) {
+    return getLabel(schema, obj);
+  }
+};
+var getLabel = (schema, object) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option3.getOrElse(() => [
+    "name"
+  ]));
+  for (const accessor of annotation) {
+    assertArgument2(typeof accessor === "string", "accessor", "Label annotation must be a string or an array of strings");
+    const value = getField(object, accessor);
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+      case "symbol":
+        return value.toString();
+      case "undefined":
+      case "object":
+      case "function":
+        continue;
+    }
+  }
+  return void 0;
+};
+var setLabel = (schema, object, label) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option3.map((field) => field[0]), Option3.getOrElse(() => "name"));
+  object[annotation] = label;
+};
+var getDescription = (schema, object) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option3.getOrElse(() => "description"));
+  assertArgument2(typeof accessor === "string", "accessor", "Description annotation must be a string");
+  const value = getField(object, accessor);
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return value.toString();
+    case "undefined":
+    case "object":
+    case "function":
+    default:
+      return void 0;
+  }
+};
+var setDescription = (schema, object, description) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option3.getOrElse(() => "description"));
+  object[accessor] = description;
+};
+
+// src/internal/object/typename.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/typename.ts";
+var getTypename = (obj) => {
+  const schema = getSchema(obj);
+  if (schema != null) {
+    return getSchemaTypename(schema);
+  } else {
+    const type = getType(obj);
+    return type?.asTypeDXN()?.type;
+  }
+};
+var setTypename = (obj, typename) => {
+  invariant3(typename instanceof DXN5, "Invalid type.", {
+    F: __dxlog_file3,
+    L: 35,
+    S: void 0,
+    A: [
+      "typename instanceof DXN",
+      "'Invalid type.'"
+    ]
+  });
+  Object.defineProperty(obj, TypeId, {
+    value: typename,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+var getType = (obj) => {
+  if (!obj) {
+    return void 0;
+  }
+  const type = obj[TypeId];
+  if (!type) {
+    return void 0;
+  }
+  invariant3(type instanceof DXN5, "Invalid object.", {
+    F: __dxlog_file3,
+    L: 59,
+    S: void 0,
+    A: [
+      "type instanceof DXN",
+      "'Invalid object.'"
+    ]
+  });
+  return type;
+};
+
+// src/internal/object/common.ts
+var makeTypedEntityClass = (typename, version, baseSchema) => {
+  return class {
+    // Implement TypedObject properties.
+    static typename = typename;
+    static version = version;
+    // Implement Schema.Schema properties.
+    // TODO(burdon): Comment required.
+    static [Schema11.TypeId] = schemaVariance;
+    static ast = baseSchema.ast;
+    static annotations = baseSchema.annotations.bind(baseSchema);
+    static pipe = baseSchema.pipe.bind(baseSchema);
+    // TODO(burdon): Comment required.
+    static [Symbol.hasInstance](obj) {
+      return obj != null && getTypename(obj) === typename;
+    }
+    // TODO(burdon): Throw APIError.
+    constructor() {
+      throw new Error("Use live(Typename, { ...fields }) to instantiate an object.");
+    }
+  };
+};
+var schemaVariance = {
+  _A: (_) => _,
+  _I: (_) => _,
+  _R: (_) => _
+};
+
+// src/internal/object/create.ts
+import { raise as raise2 } from "@dxos/debug";
+import { assertArgument as assertArgument5, failedInvariant } from "@dxos/invariant";
+import { ObjectId as ObjectId5 } from "@dxos/keys";
+import { defineHiddenProperty as defineHiddenProperty2 } from "@dxos/live-object";
+
+// src/internal/object/inspect.ts
+import { inspectCustom } from "@dxos/debug";
+var attachedTypedObjectInspector = (obj) => {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, inspectCustom);
+  if (descriptor) {
+    return;
+  }
+  Object.defineProperty(obj, inspectCustom, {
+    value: typedObjectInspectFunction,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+};
+var typedObjectInspectFunction = function(depth, options, inspect) {
+  const { id, ...props } = this;
+  return inspect({
+    id,
+    [ATTR_TYPE]: getType(this),
+    ...props,
+    [ATTR_META]: this[MetaId]
+  }, options);
+};
+
+// src/internal/object/json-serializer.ts
+import * as Schema14 from "effect/Schema";
+import { raise } from "@dxos/debug";
+import { isEncodedReference } from "@dxos/echo-protocol";
+import { assertArgument as assertArgument4, invariant as invariant6 } from "@dxos/invariant";
+import { DXN as DXN7, ObjectId as ObjectId4 } from "@dxos/keys";
+import { defineHiddenProperty } from "@dxos/live-object";
+import { assumeType as assumeType3, deepMapValues, visitValues } from "@dxos/util";
+
+// src/internal/ref/ref.ts
+import * as Effect from "effect/Effect";
+import * as Option4 from "effect/Option";
+import * as ParseResult from "effect/ParseResult";
+import * as Schema12 from "effect/Schema";
+import * as SchemaAST6 from "effect/SchemaAST";
+import { Reference } from "@dxos/echo-protocol";
+import { compositeRuntime } from "@dxos/echo-signals/runtime";
+import { assertArgument as assertArgument3, invariant as invariant4 } from "@dxos/invariant";
+import { DXN as DXN6, ObjectId as ObjectId3 } from "@dxos/keys";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/ref/ref.ts";
+var JSON_SCHEMA_ECHO_REF_ID = "/schemas/echo/ref";
+var getSchemaReference = (property) => {
+  const { $id, reference: { schema: { $ref } = {} } = {} } = property;
+  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {
+    return {
+      typename: DXN6.parse($ref).typename
+    };
+  }
+};
+var createSchemaReference = (typename) => {
+  return {
+    $id: JSON_SCHEMA_ECHO_REF_ID,
+    reference: {
+      schema: {
+        $ref: DXN6.fromTypename(typename).toString()
+      }
+    }
+  };
+};
+var getReferenceAst = (ast) => {
+  if (ast._tag !== "Declaration" || !ast.annotations[ReferenceAnnotationId]) {
+    return void 0;
+  }
+  return {
+    typename: ast.annotations[ReferenceAnnotationId].typename,
+    version: ast.annotations[ReferenceAnnotationId].version
+  };
+};
+var RefTypeId = Symbol("@dxos/echo/internal/Ref");
+var Ref = (schema) => {
+  assertArgument3(Schema12.isSchema(schema), "schema", "Must call with an instance of effect-schema");
+  const annotation = getTypeAnnotation(schema);
+  if (annotation == null) {
+    throw new Error("Reference target must be an ECHO schema.");
+  }
+  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version, getSchemaExpectedName(schema.ast));
+};
+Ref.isRef = (obj) => {
+  return obj && typeof obj === "object" && RefTypeId in obj;
+};
+Ref.hasObjectId = (id) => (ref) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;
+Ref.isRefSchema = (schema) => {
+  return Ref.isRefSchemaAST(schema.ast);
+};
+Ref.isRefSchemaAST = (ast) => {
+  return SchemaAST6.getAnnotation(ast, ReferenceAnnotationId).pipe(Option4.isSome);
+};
+Ref.make = (obj) => {
+  if (typeof obj !== "object" || obj === null) {
+    throw new TypeError("Expected: ECHO object.");
+  }
+  const id = obj.id;
+  invariant4(ObjectId3.isValid(id), "Invalid object ID", {
+    F: __dxlog_file4,
+    L: 219,
+    S: void 0,
+    A: [
+      "ObjectId.isValid(id)",
+      "'Invalid object ID'"
+    ]
+  });
+  const dxn = Reference.localObjectReference(id).toDXN();
+  return new RefImpl(dxn, obj);
+};
+Ref.fromDXN = (dxn) => {
+  assertArgument3(dxn instanceof DXN6, "dxn", "Expected DXN");
+  return new RefImpl(dxn);
+};
+var createEchoReferenceSchema = (echoId, typename, version, schemaName) => {
+  if (!echoId && !typename) {
+    throw new TypeError("Either echoId or typename must be provided.");
+  }
+  const referenceInfo = {
+    schema: {
+      // TODO(dmaretskyi): Include version?
+      $ref: echoId ?? DXN6.fromTypename(typename).toString()
+    },
+    schemaVersion: version
+  };
+  const refSchema = Schema12.declare([], {
+    encode: () => {
+      return (value) => {
+        return Effect.succeed({
+          "/": value.dxn.toString()
+        });
+      };
+    },
+    decode: () => {
+      return (value) => {
+        if (Ref.isRef(value)) {
+          return Effect.succeed(value);
+        }
+        if (typeof value !== "object" || value == null || typeof value["/"] !== "string") {
+          return Effect.fail(new ParseResult.Unexpected(value, "reference"));
+        }
+        return Effect.succeed(Ref.fromDXN(DXN6.parse(value["/"])));
+      };
+    }
+  }, {
+    jsonSchema: {
+      // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.
+      $id: JSON_SCHEMA_ECHO_REF_ID,
+      $ref: JSON_SCHEMA_ECHO_REF_ID,
+      reference: referenceInfo
+    },
+    [ReferenceAnnotationId]: {
+      typename: typename ?? "",
+      version
+    }
+  });
+  return refSchema;
+};
+var getSchemaExpectedName = (ast) => {
+  return SchemaAST6.getIdentifierAnnotation(ast).pipe(Option4.orElse(() => SchemaAST6.getTitleAnnotation(ast)), Option4.orElse(() => SchemaAST6.getDescriptionAnnotation(ast)), Option4.getOrElse(() => void 0));
+};
+var RefImpl = class _RefImpl {
+  #dxn;
+  #resolver = void 0;
+  #signal = compositeRuntime.createSignal();
+  /**
+  * Target is set when the reference is created from a specific object.
+  * In this case, the target might not be in the database.
+  */
+  #target = void 0;
+  /**
+  * Callback to issue a reactive notification when object is resolved.
+  */
+  #resolverCallback = () => {
+    this.#signal.notifyWrite();
+  };
+  constructor(dxn, target) {
+    this.#dxn = dxn;
+    this.#target = target;
+  }
+  /**
+  * @inheritdoc
+  */
+  get dxn() {
+    return this.#dxn;
+  }
+  /**
+  * @inheritdoc
+  */
+  get target() {
+    this.#signal.notifyRead();
+    if (this.#target) {
+      return this.#target;
+    }
+    invariant4(this.#resolver, "Resolver is not set", {
+      F: __dxlog_file4,
+      L: 368,
+      S: this,
+      A: [
+        "this.#resolver",
+        "'Resolver is not set'"
+      ]
+    });
+    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback);
+  }
+  /**
+  * @inheritdoc
+  */
+  async load() {
+    if (this.#target) {
+      return this.#target;
+    }
+    invariant4(this.#resolver, "Resolver is not set", {
+      F: __dxlog_file4,
+      L: 379,
+      S: this,
+      A: [
+        "this.#resolver",
+        "'Resolver is not set'"
+      ]
+    });
+    const obj = await this.#resolver.resolve(this.#dxn);
+    if (obj == null) {
+      throw new Error("Object not found");
+    }
+    return obj;
+  }
+  /**
+  * @inheritdoc
+  */
+  async tryLoad() {
+    invariant4(this.#resolver, "Resolver is not set", {
+      F: __dxlog_file4,
+      L: 391,
+      S: this,
+      A: [
+        "this.#resolver",
+        "'Resolver is not set'"
+      ]
+    });
+    return await this.#resolver.resolve(this.#dxn);
+  }
+  /**
+  * Do not inline the target object in the reference.
+  * Makes .target unavailable unless the reference is connected to a database context.
+  * Clones the reference object.
+  */
+  noInline() {
+    const ref = new _RefImpl(this.#dxn, void 0);
+    ref.#resolver = this.#resolver;
+    return ref;
+  }
+  encode() {
+    return {
+      "/": this.#dxn.toString(),
+      ...this.#target ? {
+        target: this.#target
+      } : {}
+    };
+  }
+  /**
+  * Serializes the reference to a JSON object.
+  * The serialization format is compatible with the IPLD-style encoded references.
+  * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),
+  * the target is included in the serialized object.
+  */
+  toJSON() {
+    return this.encode();
+  }
+  toString() {
+    if (this.#target) {
+      return `Ref(${this.#target.toString()})`;
+    }
+    return `Ref(${this.#dxn.toString()})`;
+  }
+  [RefTypeId] = refVariance;
+  /**
+  * Internal method to set the resolver.
+  * @internal
+  */
+  _setResolver(resolver) {
+    this.#resolver = resolver;
+  }
+  /**
+  * Internal method to get the saved target.
+  * Not the same as `target` which is resolved from the resolver.
+  * @internal
+  */
+  _getSavedTarget() {
+    return this.#target;
+  }
+};
+var setRefResolver = (ref, resolver) => {
+  invariant4(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
+    F: __dxlog_file4,
+    L: 455,
+    S: void 0,
+    A: [
+      "ref instanceof RefImpl",
+      "'Ref is not an instance of RefImpl'"
+    ]
+  });
+  ref._setResolver(resolver);
+};
+var getRefSavedTarget = (ref) => {
+  invariant4(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
+    F: __dxlog_file4,
+    L: 463,
+    S: void 0,
+    A: [
+      "ref instanceof RefImpl",
+      "'Ref is not an instance of RefImpl'"
+    ]
+  });
+  return ref._getSavedTarget();
+};
+var refVariance = {
+  _T: null
+};
+var refFromEncodedReference = (encodedReference, resolver) => {
+  const dxn = DXN6.parse(encodedReference["/"]);
+  const ref = new RefImpl(dxn);
+  if (resolver) {
+    setRefResolver(ref, resolver);
+  }
+  return ref;
+};
+var StaticRefResolver = class {
+  objects = /* @__PURE__ */ new Map();
+  schemas = /* @__PURE__ */ new Map();
+  addObject(obj) {
+    this.objects.set(obj.id, obj);
+    return this;
+  }
+  addSchema(schema) {
+    const dxn = getSchemaDXN(schema);
+    invariant4(dxn, "Schema has no DXN", {
+      F: __dxlog_file4,
+      L: 495,
+      S: this,
+      A: [
+        "dxn",
+        "'Schema has no DXN'"
+      ]
+    });
+    this.schemas.set(dxn.toString(), schema);
+    return this;
+  }
+  resolveSync(dxn, _load, _onLoad) {
+    const id = dxn?.asEchoDXN()?.echoId;
+    if (id == null) {
+      return void 0;
+    }
+    return this.objects.get(id);
+  }
+  async resolve(dxn) {
+    const id = dxn?.asEchoDXN()?.echoId;
+    if (id == null) {
+      return void 0;
+    }
+    return this.objects.get(id);
+  }
+  async resolveSchema(dxn) {
+    return this.schemas.get(dxn.toString());
+  }
+};
+
+// src/internal/ref/ref-array.ts
+import { isNonNullable } from "@dxos/util";
+var RefArray = Object.freeze({
+  /**
+  * @returns all resolved targets.
+  */
+  targets: (refs) => {
+    return refs.map((ref) => ref.target).filter(isNonNullable);
+  },
+  /**
+  * Load all referenced objects.
+  */
+  loadAll: (refs) => {
+    return Promise.all(refs.map((ref) => ref.load()));
+  },
+  /**
+  * Removes the ref with the given id.
+  */
+  removeById: (refs, id) => {
+    const index = refs.findIndex(Ref.hasObjectId(id));
+    if (index >= 0) {
+      refs.splice(index, 1);
+    }
+  }
+});
+
+// src/internal/object/meta.ts
+import * as Schema13 from "effect/Schema";
+import { ForeignKey } from "@dxos/echo-protocol";
+import { invariant as invariant5 } from "@dxos/invariant";
+import { intersection } from "@dxos/util";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/meta.ts";
+var ObjectMetaSchema = Schema13.mutable(Schema13.Struct({
+  keys: Schema13.mutable(Schema13.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.
+  tags: Schema13.optional(Schema13.mutable(Schema13.Array(Schema13.String)))
+}));
+var foreignKey = (source, id) => ({
+  source,
+  id
+});
+var foreignKeyEquals = (a, b) => a.source === b.source && a.id === b.id;
+var getObjectMeta = (obj) => {
+  return getMeta(obj);
+};
+var getMeta = (obj) => {
+  const metadata = obj[MetaId];
+  invariant5(metadata, "ObjectMeta not found.", {
+    F: __dxlog_file5,
+    L: 55,
+    S: void 0,
+    A: [
+      "metadata",
+      "'ObjectMeta not found.'"
+    ]
+  });
+  return metadata;
+};
+var compareForeignKeys = (a, b) => intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;
+
+// src/internal/object/json-serializer.ts
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/json-serializer.ts";
+var objectToJSON = (obj) => {
+  const typename = getType(obj)?.toString();
+  invariant6(typename && typeof typename === "string", void 0, {
+    F: __dxlog_file6,
+    L: 50,
+    S: void 0,
+    A: [
+      "typename && typeof typename === 'string'",
+      ""
+    ]
+  });
+  return typedJsonSerializer.call(obj);
+};
+var objectFromJSON = async (jsonData, { refResolver, dxn } = {}) => {
+  assumeType3(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 = DXN7.parse(jsonData[ATTR_TYPE]);
+  const schema = await refResolver?.resolveSchema(type);
+  invariant6(schema === void 0 || Schema14.isSchema(schema), void 0, {
+    F: __dxlog_file6,
+    L: 72,
+    S: void 0,
+    A: [
+      "schema === undefined || Schema.isSchema(schema)",
+      ""
+    ]
+  });
+  let obj;
+  if (schema != null) {
+    obj = await schema.pipe(Schema14.decodeUnknownPromise)(jsonData);
+    if (refResolver) {
+      setRefResolverOnData(obj, refResolver);
+    }
+  } else {
+    obj = decodeGeneric(jsonData, {
+      refResolver
+    });
+  }
+  invariant6(ObjectId4.isValid(obj.id), "Invalid object id", {
+    F: __dxlog_file6,
+    L: 84,
+    S: void 0,
+    A: [
+      "ObjectId.isValid(obj.id)",
+      "'Invalid object id'"
+    ]
+  });
+  setTypename(obj, type);
+  if (schema) {
+    setSchema(obj, schema);
+  }
+  const isRelation = typeof jsonData[ATTR_RELATION_SOURCE] === "string" || typeof jsonData[ATTR_RELATION_TARGET] === "string";
+  if (isRelation) {
+    const sourceDxn = DXN7.parse(jsonData[ATTR_RELATION_SOURCE] ?? raise(new TypeError("Missing relation source")));
+    const targetDxn = DXN7.parse(jsonData[ATTR_RELATION_TARGET] ?? raise(new TypeError("Missing relation target")));
+    const source = await refResolver?.resolve(sourceDxn);
+    const target = await refResolver?.resolve(targetDxn);
+    defineHiddenProperty(obj, EntityKindId, EntityKind.Relation);
+    defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
+    defineHiddenProperty(obj, RelationTargetDXNId, targetDxn);
+    defineHiddenProperty(obj, RelationSourceId, source);
+    defineHiddenProperty(obj, RelationTargetId, target);
+  } else {
+    defineHiddenProperty(obj, EntityKindId, EntityKind.Object);
+  }
+  if (typeof jsonData[ATTR_META] === "object") {
+    const meta = await ObjectMetaSchema.pipe(Schema14.decodeUnknownPromise)(jsonData[ATTR_META]);
+    invariant6(Array.isArray(meta.keys), void 0, {
+      F: __dxlog_file6,
+      L: 114,
+      S: void 0,
+      A: [
+        "Array.isArray(meta.keys)",
+        ""
+      ]
+    });
+    defineHiddenProperty(obj, MetaId, meta);
+  }
+  if (dxn) {
+    defineHiddenProperty(obj, SelfDXNId, dxn);
+  }
+  assertObjectModelShape(obj);
+  invariant6(obj[ATTR_TYPE] === void 0, "Invalid object model", {
+    F: __dxlog_file6,
+    L: 124,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_TYPE] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant6(obj[ATTR_SELF_DXN] === void 0, "Invalid object model", {
+    F: __dxlog_file6,
+    L: 125,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_SELF_DXN] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant6(obj[ATTR_DELETED] === void 0, "Invalid object model", {
+    F: __dxlog_file6,
+    L: 126,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_DELETED] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant6(obj[ATTR_RELATION_SOURCE] === void 0, "Invalid object model", {
+    F: __dxlog_file6,
+    L: 127,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_RELATION_SOURCE] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant6(obj[ATTR_RELATION_TARGET] === void 0, "Invalid object model", {
+    F: __dxlog_file6,
+    L: 128,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_RELATION_TARGET] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  invariant6(obj[ATTR_META] === void 0, "Invalid object model", {
+    F: __dxlog_file6,
+    L: 129,
+    S: void 0,
+    A: [
+      "(obj as any)[ATTR_META] === undefined",
+      "'Invalid object model'"
+    ]
+  });
+  return obj;
+};
+var decodeGeneric = (jsonData, options) => {
+  const { [ATTR_TYPE]: _type, [ATTR_META]: _meta, [ATTR_DELETED]: _deleted, [ATTR_RELATION_SOURCE]: _relationSource, [ATTR_RELATION_TARGET]: _relationTarget, [ATTR_SELF_DXN]: _selfDxn, ...props } = jsonData;
+  return deepMapValues(props, (value, recurse) => {
+    if (isEncodedReference(value)) {
+      return refFromEncodedReference(value, options.refResolver);
+    }
+    return recurse(value);
+  });
+};
+var setRefResolverOnData = (obj, refResolver) => {
+  const go2 = (value) => {
+    if (Ref.isRef(value)) {
+      setRefResolver(value, refResolver);
+    } else {
+      visitValues(value, go2);
+    }
+  };
+  go2(obj);
+};
+var attachTypedJsonSerializer = (obj) => {
+  const descriptor = Object.getOwnPropertyDescriptor(obj, "toJSON");
+  if (descriptor) {
+    return;
+  }
+  Object.defineProperty(obj, "toJSON", {
+    value: typedJsonSerializer,
+    writable: false,
+    enumerable: false,
+    // Setting `configurable` to false breaks proxy invariants, should be fixable.
+    configurable: true
+  });
+};
+var typedJsonSerializer = function() {
+  const { id, ...rest } = this;
+  const result = {
+    id
+  };
+  if (this[TypeId]) {
+    result[ATTR_TYPE] = this[TypeId].toString();
+  }
+  if (this[SelfDXNId]) {
+    result[ATTR_SELF_DXN] = this[SelfDXNId].toString();
+  }
+  if (this[RelationSourceDXNId]) {
+    const sourceDXN = this[RelationSourceDXNId];
+    invariant6(sourceDXN instanceof DXN7, void 0, {
+      F: __dxlog_file6,
+      L: 196,
+      S: this,
+      A: [
+        "sourceDXN instanceof DXN",
+        ""
+      ]
+    });
+    result[ATTR_RELATION_SOURCE] = sourceDXN.toString();
+  }
+  if (this[RelationTargetDXNId]) {
+    const targetDXN = this[RelationTargetDXNId];
+    invariant6(targetDXN instanceof DXN7, void 0, {
+      F: __dxlog_file6,
+      L: 201,
+      S: this,
+      A: [
+        "targetDXN instanceof DXN",
+        ""
+      ]
+    });
+    result[ATTR_RELATION_TARGET] = targetDXN.toString();
+  }
+  if (this[MetaId]) {
+    result[ATTR_META] = serializeMeta(this[MetaId]);
+  }
+  Object.assign(result, serializeData(rest));
+  return result;
+};
+var serializeData = (data) => {
+  return deepMapValues(data, (value, recurse) => {
+    if (Ref.isRef(value)) {
+      return value.noInline().encode();
+    }
+    return recurse(value);
+  });
+};
+var serializeMeta = (meta) => {
+  return deepMapValues(meta, (value, recurse) => recurse(value));
+};
+
+// src/internal/object/create.ts
+var create = (schema, data) => {
+  const annotation = getTypeAnnotation(schema);
+  if (!annotation) {
+    throw new Error("Schema is not an object schema");
+  }
+  assertArgument5(!("@type" in data), "data", "@type is not allowed");
+  assertArgument5(!(RelationSourceDXNId in data), "data", "Relation source DXN is not allowed in the constructor");
+  assertArgument5(!(RelationTargetDXNId in data), "data", "Relation target DXN is not allowed in the constructor");
+  assertArgument5(RelationSourceId in data === RelationTargetId in data, "data", "Relation source and target must be provided together");
+  const obj = {
+    ...data,
+    id: data.id ?? ObjectId5.random()
+  };
+  const kind = RelationSourceId in data ? EntityKind.Relation : EntityKind.Object;
+  defineHiddenProperty2(obj, EntityKindId, kind);
+  setTypename(obj, getSchemaDXN(schema) ?? failedInvariant("Missing schema DXN"));
+  setSchema(obj, schema);
+  attachTypedJsonSerializer(obj);
+  attachedTypedObjectInspector(obj);
+  defineHiddenProperty2(obj, MetaId, {
+    keys: []
+  });
+  if (kind === EntityKind.Relation) {
+    const sourceDXN = getObjectDXN(data[RelationSourceId]) ?? raise2(new Error("Unresolved relation source"));
+    const targetDXN = getObjectDXN(data[RelationTargetId]) ?? raise2(new Error("Unresolved relation target"));
+    defineHiddenProperty2(obj, RelationSourceDXNId, sourceDXN);
+    defineHiddenProperty2(obj, RelationTargetDXNId, targetDXN);
+  }
+  assertObjectModelShape(obj);
+  return obj;
+};
+
+// src/internal/object/entity.ts
+import * as Schema15 from "effect/Schema";
+import * as SchemaAST7 from "effect/SchemaAST";
+import { raise as raise3 } from "@dxos/debug";
+import { assertArgument as assertArgument6, invariant as invariant7 } from "@dxos/invariant";
+import { DXN as DXN8 } from "@dxos/keys";
+var __dxlog_file7 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/entity.ts";
+var EchoObject = ({ typename, version }) => {
+  return (self) => {
+    invariant7(typeof TypeAnnotationId === "symbol", "Sanity.", {
+      F: __dxlog_file7,
+      L: 59,
+      S: void 0,
+      A: [
+        "typeof TypeAnnotationId === 'symbol'",
+        "'Sanity.'"
+      ]
+    });
+    invariant7(SchemaAST7.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+      F: __dxlog_file7,
+      L: 60,
+      S: void 0,
+      A: [
+        "SchemaAST.isTypeLiteral(self.ast)",
+        "'Schema must be a TypeLiteral.'"
+      ]
+    });
+    const schemaWithId = Schema15.extend(Schema15.mutable(self), Schema15.Struct({
+      id: Schema15.String
+    }));
+    const ast = SchemaAST7.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Object,
+        typename,
+        version
+      },
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST7.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version
+      })
+    });
+    return makeEchoObjectSchema(
+      /* self.fields, */
+      ast,
+      typename,
+      version
+    );
+  };
+};
+var EchoRelation = (options) => {
+  assertArgument6(Schema15.isSchema(options.source), "source");
+  assertArgument6(Schema15.isSchema(options.target), "target");
+  const sourceDXN = getDXNForRelationSchemaRef(options.source);
+  const targetDXN = getDXNForRelationSchemaRef(options.target);
+  if (getEntityKind(options.source) !== EntityKind.Object) {
+    raise3(new Error("Source schema must be an echo object schema."));
+  }
+  if (getEntityKind(options.target) !== EntityKind.Object) {
+    raise3(new Error("Target schema must be an echo object schema."));
+  }
+  return (self) => {
+    invariant7(SchemaAST7.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+      F: __dxlog_file7,
+      L: 107,
+      S: void 0,
+      A: [
+        "SchemaAST.isTypeLiteral(self.ast)",
+        "'Schema must be a TypeLiteral.'"
+      ]
+    });
+    const schemaWithId = Schema15.extend(Schema15.mutable(self), Schema15.Struct({
+      id: Schema15.String
+    }));
+    const ast = SchemaAST7.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Relation,
+        typename: options.typename,
+        version: options.version,
+        sourceSchema: sourceDXN,
+        targetSchema: targetDXN
+      },
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST7.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Relation,
+        typename: options.typename,
+        version: options.version,
+        relationSource: sourceDXN,
+        relationTarget: targetDXN
+      })
+    });
+    return makeEchoObjectSchema(
+      /* self.fields, */
+      ast,
+      options.typename,
+      options.version
+    );
+  };
+};
+var makeTypeJsonSchemaAnnotation = (options) => {
+  assertArgument6(!!options.relationSource === (options.kind === EntityKind.Relation), "relationSource");
+  assertArgument6(!!options.relationTarget === (options.kind === EntityKind.Relation), "relationTarget");
+  const obj = {
+    // TODO(dmaretskyi): Should this include the version?
+    $id: options.identifier ?? DXN8.fromTypename(options.typename).toString(),
+    entityKind: options.kind,
+    version: options.version,
+    typename: options.typename
+  };
+  if (options.kind === EntityKind.Relation) {
+    obj.relationSource = {
+      $ref: options.relationSource
+    };
+    obj.relationTarget = {
+      $ref: options.relationTarget
+    };
+  }
+  return obj;
+};
+var getDXNForRelationSchemaRef = (schema) => {
+  assertArgument6(Schema15.isSchema(schema), "schema");
+  const identifier = getTypeIdentifierAnnotation(schema);
+  if (identifier) {
+    return identifier;
+  }
+  const typename = getSchemaTypename(schema);
+  if (!typename) {
+    throw new Error("Schema must have a typename");
+  }
+  return DXN8.fromTypename(typename).toString();
+};
+var makeEchoObjectSchema = (ast, typename, version) => {
+  return class EchoObjectSchemaClass extends Schema15.make(ast) {
+    static typename = typename;
+    static version = version;
+    static annotations(annotations7) {
+      const schema = Schema15.make(ast).annotations(annotations7);
+      return makeEchoObjectSchema(
+        /* fields, */
+        schema.ast,
+        typename,
+        version
+      );
+    }
+    // static make(
+    //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
+    //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
+    //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
+    //   options?: MakeOptions,
+    // ): Simplify<Schema.TypeLiteral.Type<Fields, []>> {
+    //   const propsWithDefaults: any = _lazilyMergeDefaults(fields, { ...(props as any) });
+    //   return _getDisableValidationMakeOption(options)
+    //     ? propsWithDefaults
+    //     : ParseResult.validateSync(this)(propsWithDefaults);
+    // }
+    static instanceOf(value) {
+      return Schema15.is(this)(value);
+    }
+  };
+};
+
+// src/internal/object/expando.ts
+import * as Schema16 from "effect/Schema";
+var EXPANDO_TYPENAME = "dxos.org/type/Expando";
+var ExpandoSchema = Schema16.Struct({}, {
+  key: Schema16.String,
+  value: Schema16.Any
+}).pipe(EchoObject({
+  typename: EXPANDO_TYPENAME,
+  version: "0.1.0"
+}));
+var Expando = ExpandoSchema;
+
+// src/internal/object/ids.ts
+import { DXN as DXN9, ObjectId as ObjectId6, QueueSubspaceTags, SpaceId } from "@dxos/keys";
+var createQueueDXN = (spaceId = SpaceId.random(), queueId = ObjectId6.random()) => new DXN9(DXN9.kind.QUEUE, [
+  QueueSubspaceTags.DATA,
+  spaceId,
+  queueId
+]);
+
+// src/internal/object/typed-object.ts
+import * as Schema17 from "effect/Schema";
+import * as SchemaAST8 from "effect/SchemaAST";
+import { invariant as invariant8 } from "@dxos/invariant";
+var __dxlog_file8 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/typed-object.ts";
+var TypedObject = ({ typename: typenameParam, version: versionParam, disableValidation }) => {
+  const typename = Typename.make(typenameParam, {
+    disableValidation
+  });
+  const version = SchemaVersion.make(versionParam, {
+    disableValidation
+  });
+  return (fields, options) => {
+    const schema = options?.record ? Schema17.Struct(fields, {
+      key: Schema17.String,
+      value: Schema17.Any
+    }) : Schema17.Struct(fields);
+    const typeSchema = Schema17.extend(Schema17.mutable(options?.partial ? Schema17.partial(schema) : schema), Schema17.Struct({
+      id: Schema17.String
+    }));
+    invariant8(typeof EntityKind.Object === "string", void 0, {
+      F: __dxlog_file8,
+      L: 71,
+      S: void 0,
+      A: [
+        "typeof EntityKind.Object === 'string'",
+        ""
+      ]
+    });
+    const annotatedSchema = typeSchema.annotations({
+      [TypeAnnotationId]: {
+        kind: EntityKind.Object,
+        typename,
+        version
+      },
+      [SchemaAST8.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version
+      })
+    });
+    return class TypedObject extends makeTypedEntityClass(typename, version, annotatedSchema) {
+    };
+  };
+};
+
+// src/internal/object/deleted.ts
+var isDeleted = (obj) => {
+  if (obj[DeletedId] === void 0) {
+    return false;
+  }
+  return obj[DeletedId] ?? false;
+};
+
+// src/internal/object/schema-validator.ts
+import * as Schema18 from "effect/Schema";
+import * as SchemaAST9 from "effect/SchemaAST";
+import { invariant as invariant9 } from "@dxos/invariant";
+var __dxlog_file9 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/object/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(Schema18.make(node)));
+    if (SchemaAST9.isUnion(schema.ast)) {
+      const typeAstList = schema.ast.types.filter((type) => SchemaAST9.isTypeLiteral(type));
+      if (typeAstList.length > 1) {
+        getTypeDiscriminators(typeAstList);
+      }
+      visitAll(typeAstList);
+    } else if (SchemaAST9.isTupleType(schema.ast)) {
+      const positionalTypes = schema.ast.elements.map((t) => t.type);
+      const allTypes = positionalTypes.concat(schema.ast.rest.map((t) => t.type));
+      visitAll(allTypes);
+    } else if (SchemaAST9.isTypeLiteral(schema.ast)) {
+      visitAll(SchemaAST9.getPropertySignatures(schema.ast).map((p) => p.type));
+    }
+  }
+  static hasTypeAnnotation(rootObjectSchema, property, annotation) {
+    try {
+      let type = this.getPropertySchema(rootObjectSchema, [
+        property
+      ]);
+      if (SchemaAST9.isTupleType(type.ast)) {
+        type = this.getPropertySchema(rootObjectSchema, [
+          property,
+          "0"
+        ]);
+      }
+      return type.ast.annotations[annotation] != null;
+    } catch (err) {
+      return false;
+    }
+  }
+  static getPropertySchema(rootObjectSchema, propertyPath, getProperty = () => null) {
+    let schema = rootObjectSchema;
+    for (let i = 0; i < propertyPath.length; i++) {
+      const propertyName = propertyPath[i];
+      const tupleAst = unwrapArray(schema.ast);
+      if (tupleAst != null) {
+        schema = getArrayElementSchema(tupleAst, propertyName);
+      } else {
+        const propertyType = getPropertyType(schema.ast, propertyName.toString(), (propertyName2) => getProperty([
+          ...propertyPath.slice(0, i),
+          propertyName2
+        ]));
+        if (propertyType == null) {
+          throw new TypeError(`unknown property: ${String(propertyName)} on object. Path: ${propertyPath}`);
+        }
+        schema = Schema18.make(propertyType).annotations(propertyType.annotations);
+      }
+    }
+    return schema;
+  }
+  static getTargetPropertySchema(target, prop) {
+    const schema = target[SchemaId];
+    invariant9(schema, "target has no schema", {
+      F: __dxlog_file9,
+      L: 82,
+      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 Schema18.Any;
+    }
+    invariant9(propertyType, `invalid property: ${prop.toString()}`, {
+      F: __dxlog_file9,
+      L: 93,
+      S: this,
+      A: [
+        "propertyType",
+        "`invalid property: ${prop.toString()}`"
+      ]
+    });
+    return Schema18.make(propertyType);
+  }
+};
+var getArrayElementSchema = (tupleAst, property) => {
+  const elementIndex = typeof property === "string" ? parseInt(property, 10) : Number.NaN;
+  if (Number.isNaN(elementIndex)) {
+    invariant9(property === "length", `invalid array property: ${String(property)}`, {
+      F: __dxlog_file9,
+      L: 109,
+      S: void 0,
+      A: [
+        "property === 'length'",
+        "`invalid array property: ${String(property)}`"
+      ]
+    });
+    return Schema18.Number;
+  }
+  if (elementIndex < tupleAst.elements.length) {
+    const elementType = tupleAst.elements[elementIndex].type;
+    return Schema18.make(elementType).annotations(elementType.annotations);
+  }
+  const restType = tupleAst.rest;
+  return Schema18.make(restType[0].type).annotations(restType[0].annotations);
+};
+var flattenUnion = (typeAst) => SchemaAST9.isUnion(typeAst) ? typeAst.types.flatMap(flattenUnion) : [
+  typeAst
+];
+var getProperties = (typeAst, getTargetPropertyFn) => {
+  const astCandidates = flattenUnion(typeAst);
+  const typeAstList = astCandidates.filter((type) => SchemaAST9.isTypeLiteral(type));
+  if (typeAstList.length === 0) {
+    return [];
+  }
+  if (typeAstList.length === 1) {
+    return SchemaAST9.getPropertySignatures(typeAstList[0]);
+  }
+  const typeDiscriminators = getTypeDiscriminators(typeAstList);
+  const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
+  const typeIndex = typeDiscriminators.findIndex((p) => targetPropertyValue === p.type.literal);
+  invariant9(typeIndex !== -1, "discriminator field not set on target", {
+    F: __dxlog_file9,
+    L: 140,
+    S: void 0,
+    A: [
+      "typeIndex !== -1",
+      "'discriminator field not set on target'"
+    ]
+  });
+  return SchemaAST9.getPropertySignatures(typeAstList[typeIndex]);
+};
+var getPropertyType = (ast, propertyName, getTargetPropertyFn) => {
+  const anyOrObject = unwrapAst(ast, (candidate) => SchemaAST9.isAnyKeyword(candidate) || SchemaAST9.isObjectKeyword(candidate));
+  if (anyOrObject != null) {
+    return ast;
+  }
+  const typeOrDiscriminatedUnion = unwrapAst(ast, (t) => {
+    return SchemaAST9.isTypeLiteral(t) || SchemaAST9.isUnion(t) && t.types.some((t2) => SchemaAST9.isTypeLiteral(t2));
+  });
+  if (typeOrDiscriminatedUnion == null) {
+    return null;
+  }
+  const targetProperty = getProperties(typeOrDiscriminatedUnion, getTargetPropertyFn).find((p) => p.name === propertyName);
+  if (targetProperty != null) {
+    return unwrapAst(targetProperty.type);
+  }
+  const indexSignatureType = unwrapAst(ast, SchemaAST9.isTypeLiteral);
+  if (indexSignatureType && SchemaAST9.isTypeLiteral(indexSignatureType) && indexSignatureType.indexSignatures.length > 0) {
+    return unwrapAst(indexSignatureType.indexSignatures[0].type);
+  }
+  return null;
+};
+var getTypeDiscriminators = (typeAstList) => {
+  const discriminatorPropCandidates = typeAstList.flatMap(SchemaAST9.getPropertySignatures).filter((p) => SchemaAST9.isLiteral(p.type));
+  const propertyName = discriminatorPropCandidates[0].name;
+  const isValidDiscriminator = discriminatorPropCandidates.every((p) => p.name === propertyName && !p.isOptional);
+  const everyTypeHasDiscriminator = discriminatorPropCandidates.length === typeAstList.length;
+  const isDiscriminatedUnion = isValidDiscriminator && everyTypeHasDiscriminator;
+  invariant9(isDiscriminatedUnion, "type ambiguity: every type in a union must have a single unique-literal field", {
+    F: __dxlog_file9,
+    L: 191,
+    S: void 0,
+    A: [
+      "isDiscriminatedUnion",
+      "'type ambiguity: every type in a union must have a single unique-literal field'"
+    ]
+  });
+  return discriminatorPropCandidates;
+};
+var unwrapAst = (rootAst, predicate) => {
+  let ast = rootAst;
+  while (ast != null) {
+    if (predicate?.(ast)) {
+      return ast;
+    }
+    if (SchemaAST9.isUnion(ast)) {
+      const next = ast.types.find((t) => predicate != null && predicate(t) || SchemaAST9.isSuspend(t));
+      if (next != null) {
+        ast = next;
+        continue;
+      }
+    }
+    if (SchemaAST9.isSuspend(ast)) {
+      ast = ast.f();
+    } else {
+      return predicate == null ? ast : null;
+    }
+  }
+  return null;
+};
+var unwrapArray = (ast) => unwrapAst(ast, SchemaAST9.isTupleType);
+var checkIdNotPresentOnSchema = (schema) => {
+  invariant9(SchemaAST9.isTypeLiteral(schema.ast), void 0, {
+    F: __dxlog_file9,
+    L: 234,
+    S: void 0,
+    A: [
+      "SchemaAST.isTypeLiteral(schema.ast)",
+      ""
+    ]
+  });
+  const idProperty = SchemaAST9.getPropertySignatures(schema.ast).find((prop) => prop.name === "id");
+  if (idProperty != null) {
+    throw new Error('"id" property name is reserved');
+  }
+};
+
+// src/internal/object/version.ts
+var VersionTypeId = Symbol("@dxos/echo/Version");
+
+// src/internal/json/annotations.ts
+import * as SchemaAST10 from "effect/SchemaAST";
+var CustomAnnotations = {
+  format: FormatAnnotationId,
+  currency: CurrencyAnnotationId
+};
+var DecodedAnnotations = {
+  title: SchemaAST10.TitleAnnotationId,
+  description: SchemaAST10.DescriptionAnnotationId
+};
+var EchoAnnotations = {
+  // TODO(dmaretskyi): `FieldLookupAnnotationId` might go here, but lets remove it entirely and use LabelAnnotation instead.
+  meta: PropertyMetaAnnotationId,
+  generator: GeneratorAnnotationId,
+  labelProp: LabelAnnotationId
+};
+
+// src/internal/json/json-schema.ts
+var __dxlog_file10 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/json/json-schema.ts";
+var PropType = /* @__PURE__ */ (function(PropType2) {
+  PropType2[PropType2["NONE"] = 0] = "NONE";
+  PropType2[PropType2["STRING"] = 1] = "STRING";
+  PropType2[PropType2["NUMBER"] = 2] = "NUMBER";
+  PropType2[PropType2["BOOLEAN"] = 3] = "BOOLEAN";
+  PropType2[PropType2["DATE"] = 4] = "DATE";
+  PropType2[PropType2["REF"] = 5] = "REF";
+  PropType2[PropType2["RECORD"] = 6] = "RECORD";
+  PropType2[PropType2["ENUM"] = 7] = "ENUM";
+  return PropType2;
+})({});
+var toPropType = (type) => {
+  switch (type) {
+    case 1:
+      return "string";
+    case 2:
+      return "number";
+    case 3:
+      return "boolean";
+    case 4:
+      return "date";
+    case 5:
+      return "ref";
+    case 6:
+      return "object";
+    default:
+      throw new Error(`Invalid type: ${type}`);
+  }
+};
+var JSON_SCHEMA_URL = "http://json-schema.org/draft-07/schema#";
+var toJsonSchema = (schema, options = {}) => {
+  assertArgument7(Schema19.isSchema(schema), "schema");
+  let jsonSchema = _toJsonSchemaAST(schema.ast);
+  if (options.strict) {
+    jsonSchema = removeProperties(jsonSchema, (key, value) => {
+      if (key === "$id" && value === "/schemas/any") {
+        return true;
+      }
+      if (key === "$ref" && value === "#/$defs/dependency") {
+        return true;
+      }
+      if (key === "$ref" && value === "#/$defs/jsonSchema") {
+        return true;
+      }
+      return false;
+    });
+  }
+  return jsonSchema;
+};
+var _toJsonSchemaAST = (ast) => {
+  const withRefinements = withEchoRefinements(ast, "#");
+  const jsonSchema = JSONSchema.fromAST(withRefinements, {
+    definitions: {}
+  });
+  return normalizeJsonSchema(jsonSchema);
+};
+var withEchoRefinements = (ast, path, suspendCache = /* @__PURE__ */ new Map()) => {
+  if (path) {
+    suspendCache.set(ast, path);
+  }
+  let recursiveResult;
+  if (SchemaAST11.isSuspend(ast)) {
+    const suspendedAst = ast.f();
+    const cachedPath = suspendCache.get(suspendedAst);
+    if (cachedPath) {
+      recursiveResult = new SchemaAST11.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
+        [SchemaAST11.JSONSchemaAnnotationId]: {
+          $ref: cachedPath
+        }
+      });
+    } else {
+      const jsonSchema = _toJsonSchemaAST(suspendedAst);
+      recursiveResult = new SchemaAST11.Suspend(() => withEchoRefinements(suspendedAst, path, suspendCache), {
+        [SchemaAST11.JSONSchemaAnnotationId]: jsonSchema
+      });
+    }
+  } else if (SchemaAST11.isTypeLiteral(ast)) {
+    recursiveResult = mapAst(ast, (ast2, key) => withEchoRefinements(ast2, path && typeof key === "string" ? `${path}/${key}` : void 0, suspendCache));
+    recursiveResult = addJsonSchemaFields(recursiveResult, {
+      propertyOrder: [
+        ...ast.propertySignatures.map((p) => p.name)
+      ]
+    });
+  } else if (SchemaAST11.isUndefinedKeyword(ast)) {
+    return ast;
+  } else {
+    recursiveResult = mapAst(ast, (ast2, key) => withEchoRefinements(ast2, path && (typeof key === "string" || typeof key === "number") ? `${path}/${key}` : void 0, suspendCache));
+  }
+  const annotationFields = annotations_toJsonSchemaFields(ast.annotations);
+  if (Object.keys(annotationFields).length === 0) {
+    return recursiveResult;
+  } else {
+    return addJsonSchemaFields(recursiveResult, annotationFields);
+  }
+};
+var toEffectSchema = (root, _defs) => {
+  const defs = root.$defs ? {
+    ..._defs,
+    ...root.$defs
+  } : _defs ?? {};
+  if ("type" in root && root.type === "object") {
+    return objectToEffectSchema(root, defs);
+  }
+  let result = Schema19.Unknown;
+  if ("$ref" in root) {
+    switch (root.$ref) {
+      case "/schemas/echo/ref": {
+        result = refToEffectSchema(root);
+        break;
+      }
+    }
+  } else if ("$id" in root) {
+    switch (root.$id) {
+      case "/schemas/any": {
+        result = anyToEffectSchema(root);
+        break;
+      }
+      case "/schemas/unknown": {
+        result = Schema19.Unknown;
+        break;
+      }
+      case "/schemas/{}":
+      case "/schemas/object": {
+        result = Schema19.Object;
+        break;
+      }
+      // Custom ECHO object reference.
+      case "/schemas/echo/ref": {
+        result = refToEffectSchema(root);
+        break;
+      }
+    }
+  } else if ("enum" in root) {
+    result = Schema19.Union(...root.enum.map((e) => Schema19.Literal(e)));
+  } else if ("oneOf" in root) {
+    result = Schema19.Union(...root.oneOf.map((v) => toEffectSchema(v, defs)));
+  } else if ("anyOf" in root) {
+    result = Schema19.Union(...root.anyOf.map((v) => toEffectSchema(v, defs)));
+  } else if ("allOf" in root) {
+    if (root.allOf.length === 1) {
+      result = toEffectSchema(root.allOf[0], defs);
+    } else {
+      log.warn("allOf with multiple schemas is not supported", void 0, {
+        F: __dxlog_file10,
+        L: 213,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      result = Schema19.Unknown;
+    }
+  } else if ("type" in root) {
+    switch (root.type) {
+      case "string": {
+        result = Schema19.String;
+        if (root.pattern) {
+          result = result.pipe(Schema19.pattern(new RegExp(root.pattern)));
+        }
+        break;
+      }
+      case "number": {
+        result = Schema19.Number;
+        break;
+      }
+      case "integer": {
+        result = Schema19.Number.pipe(Schema19.int());
+        break;
+      }
+      case "boolean": {
+        result = Schema19.Boolean;
+        break;
+      }
+      case "array": {
+        if (Array4.isArray(root.items)) {
+          const [required, optional6] = Function3.pipe(root.items, Array4.map((v) => toEffectSchema(v, defs)), Array4.splitAt(root.minItems ?? root.items.length));
+          result = Schema19.Tuple(...required, ...optional6.map(Schema19.optionalElement));
+        } else {
+          invariant10(root.items, void 0, {
+            F: __dxlog_file10,
+            L: 246,
+            S: void 0,
+            A: [
+              "root.items",
+              ""
+            ]
+          });
+          const items = root.items;
+          result = Array4.isArray(items) ? Schema19.Tuple(...items.map((v) => toEffectSchema(v, defs))) : Schema19.Array(toEffectSchema(items, defs));
+        }
+        break;
+      }
+      case "null": {
+        result = Schema19.Null;
+        break;
+      }
+    }
+  } else if ("$ref" in root) {
+    const refSegments = root.$ref.split("/");
+    const jsonSchema = defs[refSegments[refSegments.length - 1]];
+    invariant10(jsonSchema, `missing definition for ${root.$ref}`, {
+      F: __dxlog_file10,
+      L: 262,
+      S: void 0,
+      A: [
+        "jsonSchema",
+        "`missing definition for ${root.$ref}`"
+      ]
+    });
+    result = toEffectSchema(jsonSchema, defs).pipe(Schema19.annotations({
+      identifier: refSegments[refSegments.length - 1]
+    }));
+  }
+  const annotations7 = jsonSchemaFieldsToAnnotations(root);
+  result = result.annotations(annotations7);
+  return result;
+};
+var objectToEffectSchema = (root, defs) => {
+  invariant10("type" in root && root.type === "object", `not an object: ${root}`, {
+    F: __dxlog_file10,
+    L: 277,
+    S: void 0,
+    A: [
+      "'type' in root && root.type === 'object'",
+      "`not an object: ${root}`"
+    ]
+  });
+  const echoRefinement = root[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
+  const isEchoObject = echoRefinement != null || "$id" in root && typeof root.$id === "string" && root.$id.startsWith("dxn:");
+  let fields = {};
+  const propertyList = Object.entries(root.properties ?? {});
+  let immutableIdField;
+  for (const [key, value] of propertyList) {
+    if (isEchoObject && key === "id") {
+      immutableIdField = toEffectSchema(value, defs);
+    } else {
+      fields[key] = root.required?.includes(key) ? toEffectSchema(value, defs) : Schema19.optional(toEffectSchema(value, defs));
+    }
+  }
+  if (root.propertyOrder) {
+    fields = orderKeys(fields, root.propertyOrder);
+  }
+  let schema;
+  if (root.patternProperties) {
+    invariant10(propertyList.length === 0, "pattern properties mixed with regular properties are not supported", {
+      F: __dxlog_file10,
+      L: 303,
+      S: void 0,
+      A: [
+        "propertyList.length === 0",
+        "'pattern properties mixed with regular properties are not supported'"
+      ]
+    });
+    invariant10(Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === "", "only one pattern property is supported", {
+      F: __dxlog_file10,
+      L: 304,
+      S: void 0,
+      A: [
+        "Object.keys(root.patternProperties).length === 1 && Object.keys(root.patternProperties)[0] === ''",
+        "'only one pattern property is supported'"
+      ]
+    });
+    schema = Schema19.Record({
+      key: Schema19.String,
+      value: toEffectSchema(root.patternProperties[""], defs)
+    });
+  } else if (typeof root.additionalProperties !== "object") {
+    schema = Schema19.Struct(fields);
+  } else {
+    const indexValue = toEffectSchema(root.additionalProperties, defs);
+    if (propertyList.length > 0) {
+      schema = Schema19.Struct(fields, {
+        key: Schema19.String,
+        value: indexValue
+      });
+    } else {
+      schema = Schema19.Record({
+        key: Schema19.String,
+        value: indexValue
+      });
+    }
+  }
+  if (immutableIdField) {
+    schema = Schema19.extend(Schema19.mutable(schema), Schema19.Struct({
+      id: immutableIdField
+    }));
+  }
+  const annotations7 = jsonSchemaFieldsToAnnotations(root);
+  return schema.annotations(annotations7);
+};
+var anyToEffectSchema = (root) => {
+  const echoRefinement = root[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
+  if (echoRefinement?.reference != null) {
+    const echoId = root.$id.startsWith("dxn:echo:") ? root.$id : void 0;
+    return createEchoReferenceSchema(echoId, echoRefinement.reference.typename, echoRefinement.reference.version);
+  }
+  return Schema19.Any;
+};
+var refToEffectSchema = (root) => {
+  if (!("reference" in root)) {
+    return Ref(Expando);
+  }
+  const reference = root.reference;
+  if (typeof reference !== "object") {
+    throw new Error("Invalid reference field in ref schema");
+  }
+  const targetSchemaDXN = DXN10.parse(reference.schema.$ref);
+  invariant10(targetSchemaDXN.kind === DXN10.kind.TYPE, void 0, {
+    F: __dxlog_file10,
+    L: 355,
+    S: void 0,
+    A: [
+      "targetSchemaDXN.kind === DXN.kind.TYPE",
+      ""
+    ]
+  });
+  return createEchoReferenceSchema(targetSchemaDXN.toString(), targetSchemaDXN.kind === DXN10.kind.TYPE ? targetSchemaDXN.parts[0] : void 0, reference.schemaVersion);
+};
+var annotations_toJsonSchemaFields = (annotations7) => {
+  const schemaFields = {};
+  const echoAnnotations = {};
+  for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
+    if (annotations7[annotationId] != null) {
+      echoAnnotations[key] = annotations7[annotationId];
+    }
+  }
+  if (Object.keys(echoAnnotations).length > 0) {
+    schemaFields[ECHO_ANNOTATIONS_NS_KEY] = echoAnnotations;
+  }
+  const echoIdentifier = annotations7[TypeIdentifierAnnotationId];
+  if (echoIdentifier) {
+    schemaFields[ECHO_ANNOTATIONS_NS_KEY] ??= {};
+    schemaFields[ECHO_ANNOTATIONS_NS_KEY].schemaId = echoIdentifier;
+  }
+  for (const [key, annotationId] of Object.entries(CustomAnnotations)) {
+    const value = annotations7[annotationId];
+    if (value != null) {
+      schemaFields[key] = value;
+    }
+  }
+  return schemaFields;
+};
+var decodeTypeIdentifierAnnotation = (schema) => {
+  if (schema.$id && schema.$id.startsWith("dxn:echo:")) {
+    return schema.$id;
+  } else if (schema.$id && schema.$id.startsWith("dxn:type:") && schema?.echo?.type?.schemaId) {
+    const id = schema?.echo?.type?.schemaId;
+    if (ObjectId7.isValid(id)) {
+      return DXN10.fromLocalObjectId(id).toString();
+    }
+  }
+  return void 0;
+};
+var decodeTypeAnnotation = (schema) => {
+  if (schema.typename) {
+    const annotation = {
+      // TODO(dmaretskyi): Decoding default.
+      kind: schema.entityKind ? Schema19.decodeSync(EntityKindSchema)(schema.entityKind) : EntityKind.Object,
+      typename: schema.typename,
+      version: schema.version ?? "0.1.0"
+    };
+    if (annotation.kind === EntityKind.Relation) {
+      const source = schema.relationSource?.$ref ?? raise4(new Error("Relation source not set"));
+      const target = schema.relationTarget?.$ref ?? raise4(new Error("Relation target not set"));
+      annotation.sourceSchema = DXN10.parse(source).toString();
+      annotation.targetSchema = DXN10.parse(target).toString();
+    }
+    return annotation;
+  }
+  if (!schema.typename && schema?.echo?.type) {
+    return {
+      kind: EntityKind.Object,
+      typename: schema.echo.type.typename,
+      version: schema.echo.type.version
+    };
+  }
+  return void 0;
+};
+var jsonSchemaFieldsToAnnotations = (schema) => {
+  const annotations7 = {};
+  const echoAnnotations = getNormalizedEchoAnnotations(schema) ?? {};
+  if (echoAnnotations) {
+    for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
+      if (echoAnnotations[key]) {
+        annotations7[annotationId] = echoAnnotations[key];
+      }
+    }
+  }
+  annotations7[TypeIdentifierAnnotationId] = decodeTypeIdentifierAnnotation(schema);
+  const typeAnnotation = decodeTypeAnnotation(schema);
+  if (typeAnnotation) {
+    annotations7[TypeAnnotationId] = typeAnnotation;
+    annotations7[SchemaAST11.JSONSchemaAnnotationId] = makeTypeJsonSchemaAnnotation({
+      kind: typeAnnotation.kind,
+      typename: typeAnnotation.typename,
+      version: typeAnnotation.version,
+      relationSource: typeAnnotation.sourceSchema,
+      relationTarget: typeAnnotation.targetSchema
+    });
+  }
+  for (const [key, annotationId] of Object.entries({
+    ...CustomAnnotations,
+    ...DecodedAnnotations
+  })) {
+    if (key in schema) {
+      annotations7[annotationId] = schema[key];
+    }
+  }
+  return clearUndefined(annotations7);
+};
+var makeAnnotatedRefinement = (ast, annotations7) => {
+  return new SchemaAST11.Refinement(ast, () => Option5.none(), annotations7);
+};
+var addJsonSchemaFields = (ast, schema) => makeAnnotatedRefinement(ast, {
+  [SchemaAST11.JSONSchemaAnnotationId]: schema
+});
+var normalizeJsonSchema = (jsonSchema) => {
+  if (jsonSchema.properties && "id" in jsonSchema.properties) {
+    jsonSchema.properties = orderKeys(jsonSchema.properties, [
+      "id"
+    ]);
+  }
+  jsonSchema.$schema = JSON_SCHEMA_URL;
+  jsonSchema = orderKeys(jsonSchema, [
+    "$schema",
+    "$id",
+    "entityKind",
+    "typename",
+    "version",
+    "relationTarget",
+    "relationSource",
+    "type",
+    "enum",
+    "properties",
+    "required",
+    "propertyOrder",
+    "items",
+    "additionalProperties",
+    "anyOf",
+    "oneOf"
+  ]);
+  return jsonSchema;
+};
+
+// src/internal/types/types.ts
+import * as Schema20 from "effect/Schema";
+import * as SchemaAST12 from "effect/SchemaAST";
+import { Reference as Reference2 } from "@dxos/echo-protocol";
+import { splitJsonPath } from "@dxos/effect";
+import { DXN as DXN11 } from "@dxos/keys";
+import { getDeep, setDeep } from "@dxos/util";
+var RawObject = (schema) => {
+  return Schema20.make(SchemaAST12.omit(schema.ast, [
+    "id"
+  ]));
+};
+var splitMeta = (object) => {
+  const meta = object[ATTR_META];
+  delete object[ATTR_META];
+  return {
+    meta,
+    object
+  };
+};
+var getValue = (obj, path) => {
+  return getDeep(obj, splitJsonPath(path).map((p) => p.replace(/[[\]]/g, "")));
+};
+var setValue = (obj, path, value) => {
+  return setDeep(obj, splitJsonPath(path).map((p) => p.replace(/[[\]]/g, "")), value);
+};
+var getTypeReference = (schema) => {
+  if (!schema) {
+    return void 0;
+  }
+  const schemaDXN = getSchemaDXN(schema);
+  if (!schemaDXN) {
+    return void 0;
+  }
+  return Reference2.fromDXN(schemaDXN);
+};
+var requireTypeReference = (schema) => {
+  const typeReference = getTypeReference(schema);
+  if (typeReference == null) {
+    throw new Error("Schema must be defined via TypedObject.");
+  }
+  return typeReference;
+};
+var isInstanceOf = (schema, object) => {
+  if (object == null) {
+    return false;
+  }
+  const schemaDXN = getSchemaDXN(schema);
+  if (!schemaDXN) {
+    throw new Error("Schema must have an object annotation.");
+  }
+  const type = getType(object);
+  if (type && DXN11.equals(type, schemaDXN)) {
+    return true;
+  }
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+  const typeDXN = schemaDXN.asTypeDXN();
+  if (!typeDXN) {
+    return false;
+  }
+  return typeDXN.type === typename;
+};
+
+// src/internal/index.ts
+import { defineHiddenProperty as defineHiddenProperty5 } from "@dxos/live-object";
+
+// src/internal/projection/compose.ts
+import { invariant as invariant14 } from "@dxos/invariant";
+
+// src/internal/schema/echo-schema.ts
+import * as Schema23 from "effect/Schema";
+import * as SchemaAST14 from "effect/SchemaAST";
+import { invariant as invariant12 } from "@dxos/invariant";
+
+// src/internal/schema/manipulation.ts
+import * as Schema21 from "effect/Schema";
+import * as SchemaAST13 from "effect/SchemaAST";
+import { invariant as invariant11 } from "@dxos/invariant";
+import { DXN as DXN12 } from "@dxos/keys";
+var __dxlog_file11 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/schema/manipulation.ts";
+var addFieldsToSchema = (schema, fields) => {
+  const schemaExtension = Schema21.partial(Schema21.Struct(fields));
+  return Schema21.extend(schema, schemaExtension).annotations(schema.ast.annotations);
+};
+var updateFieldsInSchema = (schema, fields) => {
+  const ast = schema.ast;
+  invariant11(SchemaAST13.isTypeLiteral(ast), void 0, {
+    F: __dxlog_file11,
+    L: 29,
+    S: void 0,
+    A: [
+      "SchemaAST.isTypeLiteral(ast)",
+      ""
+    ]
+  });
+  const updatedProperties = [
+    ...ast.propertySignatures
+  ];
+  const propertiesToUpdate = Schema21.partial(Schema21.Struct(fields)).ast.propertySignatures;
+  for (const property of propertiesToUpdate) {
+    const index = updatedProperties.findIndex((p) => p.name === property.name);
+    if (index !== -1) {
+      updatedProperties[index] = property;
+    } else {
+      updatedProperties.push(property);
+    }
+  }
+  return Schema21.make(new SchemaAST13.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
+};
+var removeFieldsFromSchema = (schema, fieldNames) => {
+  return Schema21.make(SchemaAST13.omit(schema.ast, fieldNames)).annotations(schema.ast.annotations);
+};
+var updateFieldNameInSchema = (schema, { before, after }) => {
+  const ast = schema.ast;
+  invariant11(SchemaAST13.isTypeLiteral(ast), void 0, {
+    F: __dxlog_file11,
+    L: 57,
+    S: void 0,
+    A: [
+      "SchemaAST.isTypeLiteral(ast)",
+      ""
+    ]
+  });
+  return Schema21.make(new SchemaAST13.TypeLiteral(ast.propertySignatures.map((p) => p.name === before ? new SchemaAST13.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];
+  invariant11(existingAnnotation, `Missing ${String(TypeAnnotationId)}`, {
+    F: __dxlog_file11,
+    L: 77,
+    S: void 0,
+    A: [
+      "existingAnnotation",
+      "`Missing ${String(TypeAnnotationId)}`"
+    ]
+  });
+  return schema.annotations({
+    ...schema.ast.annotations,
+    [TypeAnnotationId]: {
+      kind: existingAnnotation.kind,
+      typename,
+      version: existingAnnotation.version
+    },
+    [SchemaAST13.JSONSchemaAnnotationId]: {
+      ...schema.ast.annotations[SchemaAST13.JSONSchemaAnnotationId] ?? {},
+      $id: schema.ast.annotations[TypeIdentifierAnnotationId] ?? DXN12.fromTypename(typename).toString(),
+      typename
+    }
+  });
+};
+
+// src/internal/schema/snapshot.ts
+var getSnapshot = (object) => {
+  if (typeof object !== "object") {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return object.map(getSnapshot);
+  }
+  const result = {};
+  for (const key in object) {
+    result[key] = getSnapshot(object[key]);
+  }
+  return result;
+};
+
+// src/internal/schema/stored-schema.ts
+import * as Schema22 from "effect/Schema";
+var StoredSchema = Schema22.Struct({
+  name: Schema22.optional(Schema22.String),
+  typename: Typename,
+  version: SchemaVersion,
+  jsonSchema: JsonSchemaType
+}).pipe(EchoObject({
+  typename: "dxos.org/type/Schema",
+  version: "0.1.0"
+}));
+
+// src/internal/schema/echo-schema.ts
+var __dxlog_file12 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/schema/echo-schema.ts";
+var ImmutableSchema = class {
+  _schema;
+  _objectAnnotation;
+  constructor(_schema) {
+    this._schema = _schema;
+    this._objectAnnotation = getTypeAnnotation(this._schema);
+    invariant12(this._objectAnnotation, void 0, {
+      F: __dxlog_file12,
+      L: 47,
+      S: this,
+      A: [
+        "this._objectAnnotation",
+        ""
+      ]
+    });
+  }
+  //
+  // Effect Schema (push to abstract base class).
+  //
+  get [Schema23.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 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 Schema23.Union(StoredSchema, Schema23.instanceOf(EchoSchema)).annotations(StoredSchema.ast.annotations);
+    }
+    static [Schema23.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() {
+  _storedSchema;
+  _schema;
+  _isDirty = true;
+  constructor(_storedSchema) {
+    super(), this._storedSchema = _storedSchema;
+  }
+  //
+  // Effect Schema (push to abstract base class).
+  //
+  get [Schema23.TypeId]() {
+    return schemaVariance2;
+  }
+  get Type() {
+    return this._storedSchema;
+  }
+  get Encoded() {
+    return this._storedSchema;
+  }
+  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 typename() {
+    return this._storedSchema.typename;
+  }
+  get version() {
+    return this._storedSchema.version;
+  }
+  get readonly() {
+    return false;
+  }
+  /**
+  * Returns an immutable schema snapshot of the current state of the schema.
+  */
+  get snapshot() {
+    return this._getSchema();
+  }
+  /**
+  * @reactive
+  */
+  get jsonSchema() {
+    return this._storedSchema.jsonSchema;
+  }
+  /**
+  * Returns a mutable schema.
+  */
+  get mutable() {
+    invariant12(!this.readonly, "Schema is not mutable", {
+      F: __dxlog_file12,
+      L: 260,
+      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._storedSchema.id;
+  }
+  /**
+  * Short name of the schema.
+  */
+  get name() {
+    return this._storedSchema.name;
+  }
+  get [SchemaMetaSymbol]() {
+    return {
+      id: this.id,
+      typename: this.typename,
+      version: this._storedSchema.version
+    };
+  }
+  /**
+  * Reference to the underlying stored schema object.
+  */
+  get storedSchema() {
+    return this._storedSchema;
+  }
+  getProperties() {
+    const ast = this._getSchema().ast;
+    invariant12(SchemaAST14.isTypeLiteral(ast), void 0, {
+      F: __dxlog_file12,
+      L: 295,
+      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._storedSchema.typename = typename;
+    this._storedSchema.jsonSchema = toJsonSchema(updated);
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  addFields(fields) {
+    const extended = addFieldsToSchema(this._getSchema(), fields);
+    this._storedSchema.jsonSchema = toJsonSchema(extended);
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  updateFields(fields) {
+    const updated = updateFieldsInSchema(this._getSchema(), fields);
+    this._storedSchema.jsonSchema = toJsonSchema(updated);
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  updateFieldPropertyName({ before, after }) {
+    const renamed = updateFieldNameInSchema(this._getSchema(), {
+      before,
+      after
+    });
+    this._storedSchema.jsonSchema = toJsonSchema(renamed);
+  }
+  /**
+  * @throws Error if the schema is readonly.
+  */
+  removeFields(fieldNames) {
+    const removed = removeFieldsFromSchema(this._getSchema(), fieldNames);
+    this._storedSchema.jsonSchema = toJsonSchema(removed);
+  }
+  //
+  // Internals
+  //
+  /**
+  * Called by EchoSchemaRegistry 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._storedSchema.jsonSchema));
+      this._isDirty = false;
+    }
+  }
+  _getSchema() {
+    this._rebuild();
+    return this._schema;
+  }
+};
+var unwrapOptionality = (property) => {
+  if (!SchemaAST14.isUnion(property.type)) {
+    return property;
+  }
+  return {
+    ...property,
+    type: property.type.types.find((type) => !SchemaAST14.isUndefinedKeyword(type))
+  };
+};
+
+// src/internal/schema/runtime-schema-registry.ts
+import { raise as raise5 } from "@dxos/debug";
+import { invariant as invariant13 } from "@dxos/invariant";
+import { defaultMap } from "@dxos/util";
+var __dxlog_file13 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/schema/runtime-schema-registry.ts";
+var RuntimeSchemaRegistry = class {
+  _registry = /* @__PURE__ */ new Map();
+  constructor() {
+    this._registry.set(StoredSchema.typename, [
+      StoredSchema
+    ]);
+  }
+  get schemas() {
+    return Array.from(this._registry.values()).flat();
+  }
+  hasSchema(schema) {
+    const typename = getSchemaTypename(schema);
+    const version = getSchemaVersion(schema);
+    invariant13(typename, "Invalid schema", {
+      F: __dxlog_file13,
+      L: 34,
+      S: this,
+      A: [
+        "typename",
+        "'Invalid schema'"
+      ]
+    });
+    const schemas = this._registry.get(typename);
+    return schemas?.some((schema2) => getSchemaVersion(schema2) === version) ?? false;
+  }
+  getSchemaByDXN(dxn) {
+    const components = dxn.asTypeDXN();
+    if (!components) {
+      return void 0;
+    }
+    const { type, version } = components;
+    const allSchemas = this._registry.get(type) ?? [];
+    if (version) {
+      return allSchemas.find((s) => getSchemaVersion(s) === version);
+    } else {
+      return allSchemas.sort((a, b) => (getSchemaVersion(a) ?? "0.0.0").localeCompare(getSchemaVersion(b) ?? "0.0.0"))[0];
+    }
+  }
+  /**
+  * @deprecated Use getSchemaByDXN.
+  */
+  getSchema(typename) {
+    return this._registry.get(typename)?.[0];
+  }
+  addSchema(types) {
+    types.forEach((schema) => {
+      const typename = getSchemaTypename(schema) ?? raise5(new TypeError("Schema has no typename"));
+      const version = getSchemaVersion(schema) ?? raise5(new TypeError("Schema has no version"));
+      const versions = defaultMap(this._registry, typename, () => []);
+      if (versions.some((schema2) => getSchemaVersion(schema2) === version)) {
+        throw new Error(`Schema version already registered: ${typename}:${version}`);
+      }
+      versions.push(schema);
+    });
+  }
+};
+
+// src/internal/projection/compose.ts
+var __dxlog_file14 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/projection/compose.ts";
+var composeSchema = (source, target) => {
+  const result = getSnapshot(target);
+  invariant14("type" in result && result.type === "object", "source schema must be an object", {
+    F: __dxlog_file14,
+    L: 17,
+    S: void 0,
+    A: [
+      "'type' in result && result.type === 'object'",
+      "'source schema must be an object'"
+    ]
+  });
+  invariant14("type" in source && source.type === "object", "target schema must be an object", {
+    F: __dxlog_file14,
+    L: 18,
+    S: void 0,
+    A: [
+      "'type' in source && source.type === 'object'",
+      "'target schema must be an object'"
+    ]
+  });
+  for (const prop in result.properties) {
+    const propSchema = source.properties[prop];
+    const annotations7 = propSchema?.annotations?.meta;
+    if (annotations7) {
+      result.properties[prop].annotations ??= {};
+      result.properties[prop].annotations.meta ??= {};
+      for (const key in annotations7) {
+        result.properties[prop].annotations.meta[key] ??= {};
+        Object.assign(result.properties[prop].annotations.meta[key], annotations7[key], {
+          ...result.properties[prop].annotations.meta[key]
+        });
+      }
+    }
+  }
+  return result;
+};
+
+// src/internal/proxy/reactive-object.ts
+import { ObjectId as ObjectId8 } from "@dxos/keys";
+import { UntypedReactiveHandler, createProxy as createProxy2, defineHiddenProperty as defineHiddenProperty4, isValidProxyTarget as isValidProxyTarget2 } from "@dxos/live-object";
+
+// src/internal/proxy/typed-handler.ts
+import * as Schema24 from "effect/Schema";
+import * as SchemaAST15 from "effect/SchemaAST";
+import { inspectCustom as inspectCustom2 } from "@dxos/debug";
+import { compositeRuntime as compositeRuntime2 } from "@dxos/echo-signals/runtime";
+import { invariant as invariant15 } from "@dxos/invariant";
+import { ReactiveArray, createProxy, defineHiddenProperty as defineHiddenProperty3, isValidProxyTarget, objectData, symbolIsProxy } from "@dxos/live-object";
+var __dxlog_file15 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/proxy/typed-handler.ts";
+var symbolSignal = Symbol("signal");
+var symbolPropertySignal = Symbol("property-signal");
+var TypedReactiveHandler = class _TypedReactiveHandler {
+  static instance = new _TypedReactiveHandler();
+  _proxyMap = /* @__PURE__ */ new WeakMap();
+  constructor() {
+  }
+  init(target) {
+    invariant15(typeof target === "object" && target !== null, void 0, {
+      F: __dxlog_file15,
+      L: 63,
+      S: this,
+      A: [
+        "typeof target === 'object' && target !== null",
+        ""
+      ]
+    });
+    invariant15(SchemaId in target, "Schema is not defined for the target", {
+      F: __dxlog_file15,
+      L: 64,
+      S: this,
+      A: [
+        "SchemaId in target",
+        "'Schema is not defined for the target'"
+      ]
+    });
+    if (!(symbolSignal in target)) {
+      defineHiddenProperty3(target, symbolSignal, compositeRuntime2.createSignal());
+      defineHiddenProperty3(target, symbolPropertySignal, compositeRuntime2.createSignal());
+    }
+    defineHiddenProperty3(target, DeletedId, false);
+    for (const key of Object.getOwnPropertyNames(target)) {
+      const descriptor = Object.getOwnPropertyDescriptor(target, key);
+      if (descriptor.get) {
+        continue;
+      }
+    }
+    Object.defineProperty(target, inspectCustom2, {
+      enumerable: false,
+      configurable: true,
+      value: this._inspect.bind(target)
+    });
+  }
+  get(target, prop, receiver) {
+    switch (prop) {
+      case objectData: {
+        target[symbolSignal].notifyRead();
+        return toJSON(target);
+      }
+    }
+    if (Object.getOwnPropertyDescriptor(target, prop)?.get) {
+      target[symbolPropertySignal].notifyRead();
+      return Reflect.get(target, prop, receiver);
+    }
+    target[symbolSignal].notifyRead();
+    target[symbolPropertySignal].notifyRead();
+    const value = Reflect.get(target, prop, receiver);
+    if (isValidProxyTarget(value)) {
+      return createProxy(value, this);
+    }
+    return value;
+  }
+  set(target, prop, value, receiver) {
+    if (Array.isArray(value)) {
+      value = ReactiveArray.from(value);
+    }
+    let result = false;
+    compositeRuntime2.batch(() => {
+      const validatedValue = this._validateValue(target, prop, value);
+      result = Reflect.set(target, prop, validatedValue, receiver);
+      target[symbolSignal].notifyWrite();
+    });
+    return result;
+  }
+  ownKeys(target) {
+    target[symbolSignal].notifyRead();
+    target[symbolPropertySignal].notifyRead();
+    return Reflect.ownKeys(target);
+  }
+  defineProperty(target, property, attributes) {
+    const validatedValue = this._validateValue(target, property, attributes.value);
+    const result = Reflect.defineProperty(target, property, {
+      ...attributes,
+      value: validatedValue
+    });
+    target[symbolPropertySignal].notifyWrite();
+    return result;
+  }
+  _validateValue(target, prop, value) {
+    const schema = SchemaValidator.getTargetPropertySchema(target, prop);
+    const _ = Schema24.asserts(schema)(value);
+    if (Array.isArray(value)) {
+      value = new ReactiveArray(...value);
+    }
+    if (isValidProxyTarget(value)) {
+      setSchemaProperties(value, schema);
+    }
+    return value;
+  }
+  _inspect(_, options, inspectFn) {
+    const inspected = inspectFn(this, {
+      ...options,
+      showHidden: false,
+      customInspect: false
+    });
+    return `Typed ${inspected}`;
+  }
+};
+var toJSON = (target) => {
+  return {
+    "@type": "TypedReactiveObject",
+    ...target
+  };
+};
+var setSchemaProperties = (obj, schema) => {
+  const schemaType = getSchemaDXN(schema);
+  if (schemaType != null) {
+    defineHiddenProperty3(obj, TypeId, schemaType);
+  }
+  defineHiddenProperty3(obj, SchemaId, schema);
+  for (const key in obj) {
+    if (isValidProxyTarget(obj[key])) {
+      const elementSchema = SchemaValidator.getTargetPropertySchema(obj, key);
+      if (elementSchema != null) {
+        setSchemaProperties(obj[key], elementSchema);
+      }
+    }
+  }
+};
+var prepareTypedTarget = (target, schema) => {
+  if (!SchemaAST15.isTypeLiteral(schema.ast)) {
+    throw new Error("schema has to describe an object type");
+  }
+  SchemaValidator.validateSchema(schema);
+  const _ = Schema24.asserts(schema)(target);
+  makeArraysReactive(target);
+  setSchemaProperties(target, schema);
+};
+var makeArraysReactive = (target) => {
+  for (const key in target) {
+    if (target[symbolIsProxy]) {
+      continue;
+    }
+    if (Array.isArray(target[key])) {
+      target[key] = ReactiveArray.from(target[key]);
+    }
+    if (typeof target[key] === "object") {
+      makeArraysReactive(target[key]);
+    }
+  }
+};
+
+// src/internal/proxy/reactive-object.ts
+var live = (objOrSchema, obj, meta) => {
+  if (obj && objOrSchema !== Expando) {
+    return createReactiveObject({
+      ...obj
+    }, meta, objOrSchema);
+  } else if (obj && objOrSchema === Expando) {
+    return createReactiveObject({
+      ...obj
+    }, meta, void 0, {
+      expando: true
+    });
+  } else {
+    return createReactiveObject(objOrSchema, meta);
+  }
+};
+var createReactiveObject = (obj, meta, schema, options) => {
+  if (!isValidProxyTarget2(obj)) {
+    throw new Error("Value cannot be made into a reactive object.");
+  }
+  if (schema) {
+    const annotation = getTypeAnnotation(schema);
+    const shouldGenerateId = options?.expando || !!annotation;
+    if (shouldGenerateId) {
+      setIdOnTarget(obj);
+    }
+    if (annotation) {
+      defineHiddenProperty4(obj, EntityKindId, annotation.kind);
+    }
+    initMeta(obj, meta);
+    prepareTypedTarget(obj, schema);
+    attachTypedJsonSerializer(obj);
+    return createProxy2(obj, TypedReactiveHandler.instance);
+  } else {
+    if (options?.expando) {
+      setIdOnTarget(obj);
+    }
+    initMeta(obj, meta);
+    return createProxy2(obj, UntypedReactiveHandler.instance);
+  }
+};
+var setIdOnTarget = (target) => {
+  if ("id" in target && target.id !== void 0 && target.id !== null) {
+    if (!ObjectId8.isValid(target.id)) {
+      throw new Error("Invalid object id format.");
+    }
+  } else {
+    target.id = ObjectId8.random();
+  }
+};
+var initMeta = (obj, meta = {
+  keys: []
+}) => {
+  prepareTypedTarget(meta, ObjectMetaSchema);
+  defineHiddenProperty4(obj, MetaId, createProxy2(meta, TypedReactiveHandler.instance));
+};
+
+export {
+  __export,
+  createAnnotationHelper,
+  EntityKind,
+  EntityKindSchema,
+  unwrapOptional,
+  TypeIdentifierAnnotationId,
+  getTypeIdentifierAnnotation,
+  TypeAnnotationId,
+  Typename,
+  SchemaVersion,
+  TypeAnnotation,
+  getTypeAnnotation,
+  getEntityKind,
+  getSchemaTypename,
+  getSchemaVersion,
+  PropertyMetaAnnotationId,
+  PropertyMeta,
+  getPropertyMetaAnnotation,
+  ReferenceAnnotationId,
+  getReferenceAnnotation,
+  SchemaMetaSymbol,
+  ViewAnnotationId,
+  ViewAnnotation,
+  LabelAnnotationId,
+  LabelAnnotation,
+  DescriptionAnnotationId,
+  DescriptionAnnotation,
+  FormAnnotationId,
+  FormAnnotation,
+  FieldLookupAnnotationId,
+  GeneratorAnnotationId,
+  GeneratorAnnotation,
+  getSchemaDXN,
+  FIELD_PATH_ANNOTATION,
+  FieldPath,
+  TypeEnum,
+  getTypeEnum,
+  FormatAnnotationId,
+  FormatAnnotation,
+  getFormatAnnotation,
+  FormatEnum,
+  FormatEnums,
+  PropertyKind,
+  typeToFormat,
+  formatToType,
+  OptionsAnnotationId,
+  getOptionsAnnotation,
+  DecimalPrecision,
+  CurrencyAnnotationId,
+  Currency,
+  GeoPoint,
+  GeoLocation,
+  Email,
+  Formula,
+  Hostname,
+  JSON,
+  Markdown,
+  Regex,
+  URL,
+  UUID2 as UUID,
+  Format,
+  SelectOptionSchema,
+  JsonSchemaEchoAnnotations,
+  JsonSchemaFields,
+  JsonSchemaType,
+  getSchemaProperty,
+  setSchemaProperty,
+  ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
+  ECHO_ANNOTATIONS_NS_KEY,
+  getNormalizedEchoAnnotations,
+  normalizeSchema,
+  EntityKindId,
+  SelfDXNId,
+  ATTR_SELF_DXN,
+  TypeId,
+  ATTR_TYPE,
+  SchemaId,
+  DeletedId,
+  ATTR_DELETED,
+  MetaId,
+  ATTR_META,
+  RelationSourceDXNId,
+  ATTR_RELATION_SOURCE,
+  RelationTargetDXNId,
+  ATTR_RELATION_TARGET,
+  RelationSourceId,
+  RelationTargetId,
+  ObjectVersionId,
+  assertObjectModelShape,
+  getObjectDXN,
+  getSchema,
+  setSchema,
+  getLabelForObject,
+  getLabel,
+  setLabel,
+  getDescription,
+  setDescription,
+  getTypename,
+  setTypename,
+  getType,
+  makeTypedEntityClass,
+  JSON_SCHEMA_ECHO_REF_ID,
+  getSchemaReference,
+  createSchemaReference,
+  getReferenceAst,
+  RefTypeId,
+  Ref,
+  createEchoReferenceSchema,
+  RefImpl,
+  setRefResolver,
+  getRefSavedTarget,
+  refFromEncodedReference,
+  StaticRefResolver,
+  RefArray,
+  ObjectMetaSchema,
+  foreignKey,
+  foreignKeyEquals,
+  getObjectMeta,
+  getMeta,
+  compareForeignKeys,
+  objectToJSON,
+  objectFromJSON,
+  setRefResolverOnData,
+  attachTypedJsonSerializer,
+  create,
+  EchoObject,
+  EchoRelation,
+  makeTypeJsonSchemaAnnotation,
+  EXPANDO_TYPENAME,
+  Expando,
+  createQueueDXN,
+  TypedObject,
+  isDeleted,
+  SchemaValidator,
+  checkIdNotPresentOnSchema,
+  VersionTypeId,
+  PropType,
+  toPropType,
+  toJsonSchema,
+  toEffectSchema,
+  RawObject,
+  splitMeta,
+  getValue,
+  setValue,
+  getTypeReference,
+  requireTypeReference,
+  isInstanceOf,
+  addFieldsToSchema,
+  updateFieldsInSchema,
+  removeFieldsFromSchema,
+  updateFieldNameInSchema,
+  setTypenameInSchema,
+  getSnapshot,
+  StoredSchema,
+  ImmutableSchema,
+  isMutable,
+  EchoSchema,
+  RuntimeSchemaRegistry,
+  composeSchema,
+  live,
+  JsonPath2 as JsonPath,
+  splitJsonPath2 as splitJsonPath,
+  JsonProp,
+  ObjectId9 as ObjectId,
+  ForeignKey2 as ForeignKey,
+  defineHiddenProperty5 as defineHiddenProperty
+};
+//# sourceMappingURL=chunk-BIDAASFK.mjs.map