@dxos/echo 0.9.0 → 0.9.1-staging.ee54ba693a

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

@@ -0,0 +1,1531 @@
+import {
+  ATTR_META,
+  EntityMetaSchema,
+  TypeMetaSchemaDXN,
+  attachTypedJsonSerializer,
+  defineHiddenProperty,
+  getMeta,
+  getMetaChecked,
+  isEntity,
+  makeEchoTypeSchema,
+  makeObject,
+  snapshotForComparison,
+  typedJsonSerializer
+} from "./chunk-2HKGAQM4.mjs";
+import {
+  JsonSchemaFields,
+  JsonSchemaType,
+  toJsonSchema
+} from "./chunk-4A2NWKRJ.mjs";
+import {
+  Ref,
+  RefTypeId,
+  loadRefTarget,
+  refFromEncodedReference,
+  setRefResolver,
+  subscribe
+} from "./chunk-L3E5IXAE.mjs";
+import {
+  ATTR_DELETED,
+  ATTR_PARENT,
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
+  ATTR_TYPE,
+  IconAnnotation,
+  LabelAnnotation,
+  MetaId,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  ObjectVersionId,
+  ParentId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SchemaId,
+  SelfURIId,
+  TypeAnnotationId,
+  TypeEntityId,
+  TypeId,
+  assertObjectModel,
+  getDatabase,
+  getEntityKind,
+  getLabel,
+  getObjectEchoUri,
+  getSchema,
+  getSchemaTypename,
+  getSchemaURI,
+  getType,
+  getTypeAnnotation,
+  getTypeIdentifierAnnotation,
+  getTypeURI,
+  getTypename,
+  setSchema,
+  setType,
+  setTypename
+} from "./chunk-3TN2VMI4.mjs";
+import {
+  EntityKind,
+  KindId,
+  SnapshotKindId,
+  getStaticTypeSchema,
+  makeTypeJsonSchemaAnnotation
+} from "./chunk-2ZHECXUR.mjs";
+
+// src/internal/common/types/base.ts
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+var RawObject = (schema) => {
+  return Schema.make(SchemaAST.omit(schema.ast, [
+    "id"
+  ]));
+};
+
+// src/internal/common/types/version.ts
+var VersionTypeId = "~@dxos/echo/VersionTypeId";
+
+// src/internal/Annotation/sorting.ts
+var compare = (a, b) => {
+  if (a == null) {
+    return b == null ? 0 : 1;
+  }
+  if (b == null) {
+    return -1;
+  }
+  return a.localeCompare(b);
+};
+var sortByLabel = (a, b) => compare(getLabel(a), getLabel(b));
+var sortByTypename = (a, b) => compare(getTypename(a), getTypename(b));
+var sort = (...comparators) => {
+  return (a, b) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  };
+};
+
+// src/internal/Query/pretty.ts
+var prettyFilter = (filter) => {
+  switch (filter.type) {
+    case "object": {
+      if (filter.typename === null && (filter.id === void 0 || filter.id.length === 0) && Object.keys(filter.props).length === 0 && (filter.foreignKeys === void 0 || filter.foreignKeys.length === 0) && filter.metaKey !== void 0) {
+        return filter.metaVersion !== void 0 ? `Filter.key(${JSON.stringify(filter.metaKey)}, { version: ${JSON.stringify(filter.metaVersion)} })` : `Filter.key(${JSON.stringify(filter.metaKey)})`;
+      }
+      const parts = [];
+      if (filter.typename !== null) {
+        parts.push(String(filter.typename));
+      }
+      if (filter.id !== void 0 && filter.id.length > 0) {
+        parts.push(`id: [${filter.id.join(", ")}]`);
+      }
+      const propEntries = Object.entries(filter.props);
+      if (propEntries.length > 0) {
+        const propsStr = propEntries.map(([k, v]) => `${k}: ${prettyFilter(v)}`).join(", ");
+        parts.push(`{ ${propsStr} }`);
+      }
+      if (filter.foreignKeys !== void 0 && filter.foreignKeys.length > 0) {
+        parts.push(`foreignKeys: [${filter.foreignKeys.map((fk) => JSON.stringify(fk)).join(", ")}]`);
+      }
+      if (filter.metaKey !== void 0) {
+        parts.push(filter.metaVersion !== void 0 ? `metaKey: ${JSON.stringify(filter.metaKey)} (${filter.metaVersion})` : `metaKey: ${JSON.stringify(filter.metaKey)}`);
+      }
+      return parts.length > 0 ? `Filter.type(${parts.join(", ")})` : "Filter.everything()";
+    }
+    case "compare":
+      return `Filter.${filter.operator}(${JSON.stringify(filter.value)})`;
+    case "in":
+      return `Filter.in([${filter.values.map((v) => JSON.stringify(v)).join(", ")}])`;
+    case "contains":
+      return `Filter.contains(${JSON.stringify(filter.value)})`;
+    case "tag":
+      return `Filter.tag(${JSON.stringify(filter.tag)})`;
+    case "range":
+      return `Filter.range(${JSON.stringify(filter.from)}, ${JSON.stringify(filter.to)})`;
+    case "text-search":
+      return filter.searchKind ? `Filter.textSearch(${JSON.stringify(filter.text)}, ${JSON.stringify(filter.searchKind)})` : `Filter.textSearch(${JSON.stringify(filter.text)})`;
+    case "timestamp":
+      return `Filter.${filter.field}.${filter.operator}(${filter.value})`;
+    case "child-of":
+      return `Filter.childOf([${filter.parents.map((p) => JSON.stringify(p)).join(", ")}], { transitive: ${filter.transitive} })`;
+    case "not":
+      return `Filter.not(${prettyFilter(filter.filter)})`;
+    case "and":
+      return `Filter.and(${filter.filters.map(prettyFilter).join(", ")})`;
+    case "or":
+      return `Filter.or(${filter.filters.map(prettyFilter).join(", ")})`;
+  }
+};
+var prettyQuery = (query) => {
+  switch (query.type) {
+    case "select":
+      return `Query.select(${prettyFilter(query.filter)})`;
+    case "filter":
+      return `${prettyQuery(query.selection)}.select(${prettyFilter(query.filter)})`;
+    case "reference-traversal":
+      return `${prettyQuery(query.anchor)}.reference(${JSON.stringify(query.property)})`;
+    case "incoming-references": {
+      const args = [];
+      if (query.typename !== null) {
+        args.push(String(query.typename));
+      }
+      if (query.property !== null) {
+        args.push(JSON.stringify(query.property));
+      }
+      return `${prettyQuery(query.anchor)}.referencedBy(${args.join(", ")})`;
+    }
+    case "relation": {
+      const method = query.direction === "outgoing" ? "sourceOf" : query.direction === "incoming" ? "targetOf" : "relationOf";
+      const filterStr = query.filter !== void 0 ? prettyFilter(query.filter) : "";
+      return `${prettyQuery(query.anchor)}.${method}(${filterStr})`;
+    }
+    case "relation-traversal":
+      return `${prettyQuery(query.anchor)}.${query.direction}()`;
+    case "hierarchy-traversal":
+      return query.direction === "to-parent" ? `${prettyQuery(query.anchor)}.parent()` : `${prettyQuery(query.anchor)}.children()`;
+    case "union":
+      return `Query.all(${query.queries.map(prettyQuery).join(", ")})`;
+    case "set-difference":
+      return `Query.without(${prettyQuery(query.source)}, ${prettyQuery(query.exclude)})`;
+    case "order": {
+      const orders = query.order.map((o) => {
+        if (o.kind === "natural") {
+          return "Order.natural()";
+        } else if (o.kind === "rank") {
+          return `Order.rank(${JSON.stringify(o.direction)})`;
+        } else if (o.kind === "timestamp") {
+          const fn = o.field === "updatedAt" ? "updated" : "created";
+          return `Order.${fn}(${JSON.stringify(o.direction)})`;
+        } else {
+          return `Order.property(${JSON.stringify(o.property)}, ${JSON.stringify(o.direction)})`;
+        }
+      });
+      return `${prettyQuery(query.query)}.orderBy(${orders.join(", ")})`;
+    }
+    case "options": {
+      const opts = query.options;
+      const parts = [];
+      if (opts.deleted !== void 0) {
+        parts.push(`deleted: ${JSON.stringify(opts.deleted)}`);
+      }
+      if (opts.debugLabel !== void 0) {
+        parts.push(`debugLabel: ${JSON.stringify(opts.debugLabel)}`);
+      }
+      return `${prettyQuery(query.query)}.options({ ${parts.join(", ")} })`;
+    }
+    case "from": {
+      if (query.from._tag === "scope") {
+        if (query.from.scopes.length === 0) {
+          return `${prettyQuery(query.query)}.from('all-accessible-spaces')`;
+        }
+        const scopeStrs = query.from.scopes.map((scope) => {
+          if (scope._tag === "space") {
+            return scope.includeAllFeeds ? `{ space: ${JSON.stringify(scope.spaceId)}, includeAllFeeds: true }` : `{ space: ${JSON.stringify(scope.spaceId)} }`;
+          }
+          if (scope._tag === "feed") {
+            return `{ feed: ${JSON.stringify(String(scope.feedUri))} }`;
+          }
+          return `{ registry: ${JSON.stringify(scope.location)} }`;
+        });
+        return `${prettyQuery(query.query)}.from([${scopeStrs.join(", ")}])`;
+      }
+      return `${prettyQuery(query.query)}.from(${prettyQuery(query.from.query)})`;
+    }
+    case "limit":
+      return `${prettyQuery(query.query)}.limit(${query.limit})`;
+  }
+};
+
+// src/internal/Ref/strong-deps.ts
+import { EID } from "@dxos/keys";
+var getStrongDependencyUris = (refs, owningSpaceId) => {
+  const res = [];
+  if (refs.type != null && EID.tryParse(refs.type) != null) {
+    res.push(qualifyToSpace(refs.type, owningSpaceId));
+  }
+  if (refs.kind === EntityKind.Relation) {
+    if (refs.source != null) {
+      res.push(qualifyToSpace(refs.source, owningSpaceId));
+    }
+    if (refs.target != null) {
+      res.push(qualifyToSpace(refs.target, owningSpaceId));
+    }
+  }
+  if (refs.parent != null) {
+    res.push(qualifyToSpace(refs.parent, owningSpaceId));
+  }
+  return res;
+};
+var qualifyToSpace = (uri, owningSpaceId) => {
+  if (owningSpaceId == null) {
+    return uri;
+  }
+  const eid = EID.tryParse(uri);
+  if (eid == null || !EID.isLocal(eid)) {
+    return uri;
+  }
+  const entityId = EID.getEntityId(eid);
+  return entityId != null ? EID.make({
+    spaceId: owningSpaceId,
+    entityId
+  }) : uri;
+};
+var getStrongDependencies = (entity) => {
+  if (entity == null || typeof entity !== "object") {
+    return [];
+  }
+  const props = entity;
+  const kind = props[RelationSourceDXNId] != null || props[RelationTargetDXNId] != null ? EntityKind.Relation : EntityKind.Object;
+  const parent = props[ParentId];
+  const selfUri = getObjectEchoUri(entity);
+  const owningSpaceId = selfUri != null ? EID.getSpaceId(selfUri) : void 0;
+  return getStrongDependencyUris({
+    kind,
+    type: typeof props[TypeId] === "string" ? props[TypeId] : void 0,
+    source: props[RelationSourceDXNId],
+    target: props[RelationTargetDXNId],
+    // A parent is held as the resolved entity; derive its absolute URI for the dependency edge.
+    parent: parent != null ? getObjectEchoUri(parent) : void 0
+  }, owningSpaceId);
+};
+
+// src/internal/Entity/object.ts
+import * as Schema2 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+import { invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+
+// src/internal/JsonSchema/json-schema-normalize.ts
+var normalizeSchema = (schema) => {
+  const copy = structuredClone(schema);
+  go(copy);
+  return copy;
+};
+var go = (schema) => {
+  if (typeof schema !== "object" || schema === null) {
+    return;
+  }
+  if (schema.exclusiveMaximum === true) {
+    schema.exclusiveMaximum = schema.maximum;
+    delete schema.exclusiveMaximum;
+  } else if (schema.exclusiveMaximum === false) {
+    delete schema.exclusiveMaximum;
+  }
+  if (schema.exclusiveMinimum === true) {
+    schema.exclusiveMinimum = schema.minimum;
+    delete schema.exclusiveMinimum;
+  } else if (schema.exclusiveMinimum === false) {
+    delete schema.exclusiveMinimum;
+  }
+  for (const key of Object.keys(schema)) {
+    if (!JsonSchemaFields.includes(key)) {
+      delete schema[key];
+    }
+  }
+  if (schema.properties) {
+    goOnRecord(schema.properties);
+  }
+  if (schema.patternProperties) {
+    goOnRecord(schema.patternProperties);
+  }
+  if (schema.propertyNames) {
+    go(schema.propertyNames);
+  }
+  if (schema.definitions) {
+    goOnRecord(schema.definitions);
+  }
+  if (schema.items) {
+    maybeGoOnArray(schema.items);
+  }
+  if (schema.additionalItems) {
+    maybeGoOnArray(schema.additionalItems);
+  }
+  if (schema.contains) {
+    go(schema.contains);
+  }
+  if (schema.if) {
+    go(schema.if);
+  }
+  if (schema.then) {
+    go(schema.then);
+  }
+  if (schema.else) {
+    go(schema.else);
+  }
+  if (schema.allOf) {
+    maybeGoOnArray(schema.allOf);
+  }
+  if (schema.anyOf) {
+    maybeGoOnArray(schema.anyOf);
+  }
+  if (schema.oneOf) {
+    maybeGoOnArray(schema.oneOf);
+  }
+  if (schema.not) {
+    go(schema.not);
+  }
+  if (schema.$defs) {
+    goOnRecord(schema.$defs);
+  }
+  if (schema.reference) {
+    go(schema.reference.schema);
+  }
+};
+var maybeGoOnArray = (value2) => {
+  if (Array.isArray(value2)) {
+    for (const item of value2) {
+      go(item);
+    }
+  } else if (typeof value2 === "object" && value2 !== null) {
+    go(value2);
+  }
+};
+var goOnRecord = (record) => {
+  for (const key of Object.keys(record)) {
+    go(record[key]);
+  }
+};
+
+// src/internal/Entity/object.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/object.ts";
+var EchoObjectSchema = (dxn, options) => {
+  const typename = DXN.getName(dxn);
+  const version2 = DXN.getVersion(dxn);
+  invariant(version2, `Type.makeObject requires a versioned DXN: ${dxn}`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 19, S: void 0, A: ["version", "`Type.makeObject requires a versioned DXN: ${dxn}`"] });
+  return (self) => {
+    invariant(typeof TypeAnnotationId === "symbol", "Sanity.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 21, S: void 0, A: ["typeof TypeAnnotationId === 'symbol'", "'Sanity.'"] });
+    invariant(SchemaAST2.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 22, S: void 0, A: ["SchemaAST.isTypeLiteral(self.ast)", "'Schema must be a TypeLiteral.'"] });
+    const fields = self.fields ?? {};
+    const schemaWithId = Schema2.extend(self, Schema2.Struct({
+      id: Schema2.String
+    }));
+    const ast = SchemaAST2.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Object,
+        typename,
+        version: version2
+      },
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST2.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version: version2
+      })
+    });
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Object, () => toJsonSchema(Schema2.make(ast)), options?.id);
+  };
+};
+var makeObjectType = (dxn, schema, options) => {
+  const type = EchoObjectSchema(dxn, options)(schema);
+  const constructor = function ObjectType() {
+  };
+  Object.setPrototypeOf(constructor, type);
+  return constructor;
+};
+
+// src/internal/Entity/relation.ts
+import * as Schema3 from "effect/Schema";
+import * as SchemaAST3 from "effect/SchemaAST";
+import { raise } from "@dxos/debug";
+import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
+import { DXN as DXN2 } from "@dxos/keys";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/relation.ts";
+var EchoRelationSchema = ({ dxn, source, target, id: explicitId }) => {
+  const sourceSchema = source != null ? getStaticTypeSchema(source) ?? source : source;
+  const targetSchema = target != null ? getStaticTypeSchema(target) ?? target : target;
+  assertArgument(Schema3.isSchema(sourceSchema), "source");
+  assertArgument(Schema3.isSchema(targetSchema), "target");
+  const typename = DXN2.getName(dxn);
+  const version2 = DXN2.getVersion(dxn);
+  invariant2(version2, `Type.makeRelation requires a versioned DXN: ${dxn}`, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 27, S: void 0, A: ["version", "`Type.makeRelation requires a versioned DXN: ${dxn}`"] });
+  const sourceDXN = getDXNForRelationSchemaRef(sourceSchema);
+  const targetDXN = getDXNForRelationSchemaRef(targetSchema);
+  if (getEntityKind(sourceSchema) !== EntityKind.Object) {
+    raise(new Error("Source schema must be an echo object schema."));
+  }
+  if (getEntityKind(targetSchema) !== EntityKind.Object) {
+    raise(new Error("Target schema must be an echo object schema."));
+  }
+  return (self) => {
+    invariant2(SchemaAST3.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 37, S: void 0, A: ["SchemaAST.isTypeLiteral(self.ast)", "'Schema must be a TypeLiteral.'"] });
+    const fields = self.fields ?? {};
+    const schemaWithId = Schema3.extend(self, Schema3.Struct({
+      id: Schema3.String
+    }));
+    const ast = SchemaAST3.annotations(schemaWithId.ast, {
+      // TODO(dmaretskyi): `extend` kills the annotations.
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Relation,
+        typename,
+        version: version2,
+        sourceSchema: sourceDXN,
+        targetSchema: targetDXN
+      },
+      // TODO(dmaretskyi): TypeIdentifierAnnotationId?
+      [SchemaAST3.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Relation,
+        typename,
+        version: version2,
+        relationSource: sourceDXN,
+        relationTarget: targetDXN
+      })
+    });
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Relation, () => toJsonSchema(Schema3.make(ast)), explicitId);
+  };
+};
+var getDXNForRelationSchemaRef = (schema) => {
+  assertArgument(Schema3.isSchema(schema), "schema");
+  const identifier = getTypeIdentifierAnnotation(schema);
+  if (identifier) {
+    return DXN2.tryMake(identifier) ?? raise(new Error(`Invalid schema identifier: ${identifier}`));
+  }
+  const typename = getSchemaTypename(schema);
+  if (!typename) {
+    throw new Error("Schema must have a typename");
+  }
+  return DXN2.make(typename);
+};
+var makeRelationType = (options) => {
+  const type = EchoRelationSchema({
+    dxn: options.dxn,
+    source: options.source,
+    target: options.target,
+    id: options.id
+  })(options.schema);
+  const constructor = function RelationType() {
+  };
+  Object.setPrototypeOf(constructor, type);
+  return constructor;
+};
+
+// src/internal/Entity/type-kind.ts
+import * as Schema4 from "effect/Schema";
+import * as SchemaAST4 from "effect/SchemaAST";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { DXN as DXN3 } from "@dxos/keys";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/type-kind.ts";
+var EchoTypeKindSchema = (dxn, options) => {
+  const typename = DXN3.getName(dxn);
+  const version2 = DXN3.getVersion(dxn);
+  invariant3(version2, `Type-kind schemas require a versioned DXN: ${dxn}`, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 22, S: void 0, A: ["version", "`Type-kind schemas require a versioned DXN: ${dxn}`"] });
+  return (self) => {
+    invariant3(SchemaAST4.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 24, S: void 0, A: ["SchemaAST.isTypeLiteral(self.ast)", "'Schema must be a TypeLiteral.'"] });
+    const fields = self.fields ?? {};
+    const schemaWithId = Schema4.extend(self, Schema4.Struct({
+      id: Schema4.String
+    }));
+    const ast = SchemaAST4.annotations(schemaWithId.ast, {
+      ...self.ast.annotations,
+      [TypeAnnotationId]: {
+        kind: EntityKind.Type,
+        typename,
+        version: version2
+      },
+      [SchemaAST4.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Type,
+        typename,
+        version: version2
+      })
+    });
+    return makeEchoTypeSchema(fields, ast, typename, version2, EntityKind.Type, () => toJsonSchema(Schema4.make(ast)), options?.id);
+  };
+};
+
+// src/internal/Entity/version.ts
+import { assertArgument as assertArgument2 } from "@dxos/invariant";
+var unversioned = {
+  [VersionTypeId]: {},
+  versioned: false
+};
+var isVersion = (entity) => {
+  return entity != null && typeof entity === "object" && VersionTypeId in entity;
+};
+var version = (entity) => {
+  const ver = entity[ObjectVersionId];
+  if (ver === void 0) {
+    return unversioned;
+  }
+  return ver;
+};
+var versionValid = (ver) => {
+  assertArgument2(isVersion(ver), "version", "Invalid version object");
+  return !!ver.versioned;
+};
+var compareVersions = (version1, version2) => {
+  assertArgument2(isVersion(version1), "version1", "Invalid version object");
+  assertArgument2(isVersion(version2), "version2", "Invalid version object");
+  if (!versionValid(version1) || !versionValid(version2)) {
+    return "unversioned";
+  }
+  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return "different";
+  }
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return "different";
+  }
+  return "equal";
+};
+var encodeVersion = (ver) => {
+  return JSON.stringify(ver);
+};
+var decodeVersion = (ver) => {
+  const parsed = JSON.parse(ver);
+  parsed[VersionTypeId] = {};
+  return parsed;
+};
+
+// src/internal/Filter/match.ts
+import * as semver from "semver";
+import { EncodedReference, isEncodedReference as isEncodedReference2 } from "@dxos/echo-protocol";
+import { DXN as DXN4, EID as EID3 } from "@dxos/keys";
+
+// src/internal/Obj/json-serializer.ts
+import * as Schema5 from "effect/Schema";
+import { raise as raise2 } from "@dxos/debug";
+import { EntityStructure, isEncodedReference } from "@dxos/echo-protocol";
+import { assertArgument as assertArgument3, invariant as invariant4 } from "@dxos/invariant";
+import { EID as EID2, EntityId, URI } from "@dxos/keys";
+import { assumeType, decodeUint8ArrayFromJson, deepMapValues, isEncodedUint8Array, visitValues } from "@dxos/util";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/json-serializer.ts";
+var objectToJSON = (obj) => {
+  const typename = getTypeURI(obj);
+  invariant4(typename && typeof typename === "string", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 23, S: void 0, A: ["typename && typeof typename === 'string'", ""] });
+  return typedJsonSerializer.call(obj);
+};
+var objectFromJSON = async (jsonData, { refResolver, uri, database, parent } = {}) => {
+  assumeType(jsonData);
+  assertArgument3(typeof jsonData === "object" && jsonData !== null, "jsonData", "expect object");
+  assertArgument3(typeof jsonData[ATTR_TYPE] === "string", "jsonData[ATTR_TYPE]", "expected object to have a type");
+  assertArgument3(typeof jsonData.id === "string", "jsonData.id", "expected object to have an id");
+  const type = URI.make(jsonData[ATTR_TYPE]);
+  const schema = await refResolver?.resolveSchema(type);
+  invariant4(schema === void 0 || Schema5.isSchema(schema), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 43, S: void 0, A: ["schema === undefined || Schema.isSchema(schema)", ""] });
+  const decodedInput = restoreUint8Arrays(stripInternalJsonKeys(jsonData));
+  let obj;
+  if (schema != null) {
+    obj = await schema.pipe(Schema5.decodeUnknownPromise)(decodedInput);
+    if (refResolver) {
+      setRefResolverOnData(obj, refResolver);
+    }
+  } else {
+    obj = decodeGeneric(decodedInput, {
+      refResolver
+    });
+  }
+  invariant4(EntityId.isValid(obj.id), "Invalid object id", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 56, S: void 0, A: ["EntityId.isValid(obj.id)", "'Invalid object id'"] });
+  setTypename(obj, type);
+  if (schema) {
+    setSchema(obj, schema);
+  }
+  if (refResolver?.resolveType) {
+    const typeEntity = await refResolver.resolveType(type);
+    if (typeEntity != null) {
+      setType(obj, typeEntity);
+    }
+  }
+  const isRelation = typeof jsonData[ATTR_RELATION_SOURCE] === "string" || typeof jsonData[ATTR_RELATION_TARGET] === "string";
+  if (isRelation) {
+    const sourceDxn = jsonData[ATTR_RELATION_SOURCE] ?? raise2(new TypeError("Missing relation source"));
+    const targetDxn = jsonData[ATTR_RELATION_TARGET] ?? raise2(new TypeError("Missing relation target"));
+    const source = await refResolver?.resolveLegacy(sourceDxn);
+    const target = await refResolver?.resolveLegacy(targetDxn);
+    defineHiddenProperty(obj, KindId, EntityKind.Relation);
+    defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
+    defineHiddenProperty(obj, RelationTargetDXNId, targetDxn);
+    defineHiddenProperty(obj, RelationSourceId, source);
+    defineHiddenProperty(obj, RelationTargetId, target);
+  } else {
+    const annotationKind = schema != null ? getTypeAnnotation(schema)?.kind : void 0;
+    defineHiddenProperty(obj, KindId, annotationKind === EntityKind.Type ? EntityKind.Type : EntityKind.Object);
+  }
+  if (typeof jsonData[ATTR_META] === "object") {
+    const meta = await EntityMetaSchema.pipe(Schema5.decodeUnknownPromise)(normalizeMeta(jsonData[ATTR_META]));
+    invariant4(Array.isArray(meta.keys), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 92, S: void 0, A: ["Array.isArray(meta.keys)", ""] });
+    defineHiddenProperty(obj, MetaId, meta);
+  } else {
+    defineHiddenProperty(obj, MetaId, {
+      keys: [],
+      tags: [],
+      annotations: {}
+    });
+  }
+  if (jsonData[ATTR_PARENT]) {
+    const parentDxn = jsonData[ATTR_PARENT];
+    const resolvedParent = await refResolver?.resolveLegacy(parentDxn);
+    defineHiddenProperty(obj, ParentId, resolvedParent);
+  } else if (parent) {
+    defineHiddenProperty(obj, ParentId, parent);
+  }
+  if (uri) {
+    defineHiddenProperty(obj, SelfURIId, uri);
+  }
+  if (database) {
+    defineHiddenProperty(obj, ObjectDatabaseId, database);
+  }
+  assertObjectModel(obj);
+  invariant4(obj[ATTR_TYPE] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 115, S: void 0, A: ["obj[ATTR_TYPE] === undefined", "'Invalid object model'"] });
+  invariant4(obj[ATTR_META] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 116, S: void 0, A: ["obj[ATTR_META] === undefined", "'Invalid object model'"] });
+  invariant4(obj[ATTR_DELETED] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 117, S: void 0, A: ["obj[ATTR_DELETED] === undefined", "'Invalid object model'"] });
+  invariant4(obj[ATTR_SELF_URI] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 118, S: void 0, A: ["obj[ATTR_SELF_URI] === undefined", "'Invalid object model'"] });
+  invariant4(obj[ATTR_SELF_URI_LEGACY] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 119, S: void 0, A: ["obj[ATTR_SELF_URI_LEGACY] === undefined", "'Invalid object model'"] });
+  invariant4(obj[ATTR_RELATION_SOURCE] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 120, S: void 0, A: ["obj[ATTR_RELATION_SOURCE] === undefined", "'Invalid object model'"] });
+  invariant4(obj[ATTR_RELATION_TARGET] === void 0, "Invalid object model", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 121, S: void 0, A: ["obj[ATTR_RELATION_TARGET] === undefined", "'Invalid object model'"] });
+  return obj;
+};
+var normalizeMeta = (meta) => {
+  const tags = Array.isArray(meta?.tags) ? meta.tags.map((tag) => typeof tag === "string" ? {
+    "/": URI.make(tag)
+  } : tag) : [];
+  return {
+    ...meta,
+    keys: Array.isArray(meta?.keys) ? meta.keys : [],
+    tags,
+    annotations: meta?.annotations ?? {}
+  };
+};
+var decodeGeneric = (jsonData, options) => {
+  const props = stripInternalJsonKeys(jsonData);
+  return deepMapValues(props, (value2, visitor) => {
+    if (isEncodedReference(value2)) {
+      return refFromEncodedReference(value2, options.refResolver);
+    }
+    if (isEncodedUint8Array(value2)) {
+      return decodeUint8ArrayFromJson(value2);
+    }
+    return visitor(value2);
+  });
+};
+var restoreUint8Arrays = (data) => deepMapValues(data, (value2, recurse) => {
+  if (isEncodedUint8Array(value2)) {
+    return decodeUint8ArrayFromJson(value2);
+  }
+  return recurse(value2);
+});
+var stripInternalJsonKeys = (jsonData) => {
+  const { [ATTR_TYPE]: _type, [ATTR_META]: _meta, [ATTR_DELETED]: _deleted, [ATTR_SELF_URI]: _selfUri, [ATTR_SELF_URI_LEGACY]: _legacySelfUri, [ATTR_RELATION_SOURCE]: _relationSource, [ATTR_RELATION_TARGET]: _relationTarget, ...props } = jsonData;
+  return props;
+};
+var setRefResolverOnData = (obj, refResolver) => {
+  const visitor = (value2) => {
+    if (Ref.isRef(value2)) {
+      setRefResolver(value2, refResolver);
+    } else {
+      visitValues(value2, visitor);
+    }
+  };
+  visitor(obj);
+};
+var objectStructureToJson = (objectId, structure) => {
+  const typeRef = EntityStructure.getTypeReference(structure)?.["/"];
+  const parent = EntityStructure.getParent(structure)?.["/"];
+  const source = EntityStructure.getRelationSource(structure)?.["/"];
+  const target = EntityStructure.getRelationTarget(structure)?.["/"];
+  return {
+    ...structure.data,
+    id: objectId,
+    [ATTR_TYPE]: typeRef ? URI.make(typeRef) : void 0,
+    [ATTR_DELETED]: EntityStructure.isDeleted(structure),
+    [ATTR_PARENT]: parent !== void 0 ? EID2.tryParse(parent) : void 0,
+    [ATTR_RELATION_SOURCE]: source !== void 0 ? EID2.tryParse(source) : void 0,
+    [ATTR_RELATION_TARGET]: target !== void 0 ? EID2.tryParse(target) : void 0
+  };
+};
+
+// src/internal/Filter/match.ts
+var matchesTag = (tags, filterTag) => {
+  const canonical = (uri) => {
+    const eid = EID3.tryParse(uri);
+    return eid && EID3.getEntityId(eid) || uri;
+  };
+  const normalize = (tag) => canonical(isEncodedReference2(tag) ? EncodedReference.toURI(tag) : tag);
+  const target = canonical(filterTag);
+  return tags.some((tag) => normalize(tag) === target);
+};
+var matchMetaKey = (key, versionRange, objKey, objVersion) => {
+  if (objKey !== key) {
+    return false;
+  }
+  if (versionRange === void 0) {
+    return true;
+  }
+  if (objVersion === void 0 || semver.valid(objVersion) === null) {
+    return false;
+  }
+  if (semver.validRange(versionRange) === null) {
+    return false;
+  }
+  return semver.satisfies(objVersion, versionRange, {
+    includePrerelease: true
+  });
+};
+var compareTypenameStrings = (expectedStr, actualStr) => {
+  const expectedEid = EID3.tryParse(expectedStr);
+  if (expectedEid) {
+    const actualEid = EID3.tryParse(actualStr);
+    if (!actualEid) {
+      return false;
+    }
+    if (EID3.getEntityId(expectedEid) !== EID3.getEntityId(actualEid)) {
+      return false;
+    }
+    const expectedSpaceId = EID3.getSpaceId(expectedEid);
+    const actualSpaceId = EID3.getSpaceId(actualEid);
+    return expectedSpaceId === void 0 || actualSpaceId === void 0 || expectedSpaceId === actualSpaceId;
+  }
+  const expectedDxn = DXN4.tryMake(expectedStr);
+  if (expectedDxn) {
+    const actualDxn = DXN4.tryMake(actualStr);
+    if (!actualDxn) {
+      return false;
+    }
+    if (DXN4.getName(expectedDxn) !== DXN4.getName(actualDxn)) {
+      return false;
+    }
+    const expectedVersion = DXN4.getVersion(expectedDxn);
+    const actualVersion = DXN4.getVersion(actualDxn);
+    return expectedVersion === void 0 || actualVersion === void 0 || expectedVersion === actualVersion;
+  }
+  return expectedStr === actualStr;
+};
+var structuralMatch = (filterObj, targetObj, strict = true) => {
+  if (typeof filterObj !== "object" || filterObj === null) {
+    return filterObj === targetObj;
+  }
+  if (typeof targetObj !== "object" || targetObj === null) {
+    return false;
+  }
+  const filterKeys = Object.keys(filterObj);
+  const targetKeys = Object.keys(targetObj);
+  if (strict && filterKeys.length !== targetKeys.length) {
+    return false;
+  }
+  return filterKeys.every((key) => {
+    if (!(key in targetObj)) {
+      return false;
+    }
+    const filterValue = filterObj[key];
+    const targetValue = targetObj[key];
+    if (typeof filterValue === "object" && filterValue !== null) {
+      return structuralMatch(filterValue, targetValue);
+    }
+    return filterValue === targetValue;
+  });
+};
+var filterMatchValue = (filter, value2) => {
+  switch (filter.type) {
+    case "compare": {
+      const compareValue = filter.value;
+      switch (filter.operator) {
+        case "eq":
+          if (isEncodedReference2(compareValue)) {
+            if (!isEncodedReference2(value2)) {
+              return false;
+            }
+            return EncodedReference.toURI(value2) === EncodedReference.toURI(compareValue);
+          }
+          return value2 === compareValue;
+        case "neq":
+          return value2 !== compareValue;
+        case "gt":
+          return value2 > compareValue;
+        case "gte":
+          return value2 >= compareValue;
+        case "lt":
+          return value2 < compareValue;
+        case "lte":
+          return value2 <= compareValue;
+        default:
+          return false;
+      }
+    }
+    case "object": {
+      if (typeof value2 !== "object" || value2 === null) {
+        return false;
+      }
+      if (filter.props) {
+        for (const [key, valueFilter] of Object.entries(filter.props)) {
+          const nestedValue = value2[key];
+          if (!filterMatchValue(valueFilter, nestedValue)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+    case "in": {
+      return filter.values.includes(value2);
+    }
+    case "contains": {
+      if (!Array.isArray(value2)) {
+        return false;
+      }
+      return value2.some((element) => {
+        if (typeof filter.value === "object" && filter.value !== null && !Array.isArray(filter.value)) {
+          return structuralMatch(filter.value, element);
+        }
+        return element === filter.value;
+      });
+    }
+    case "range": {
+      return value2 >= filter.from && value2 <= filter.to;
+    }
+    case "not": {
+      return !filterMatchValue(filter.filter, value2);
+    }
+    case "and": {
+      return filter.filters.every((f) => filterMatchValue(f, value2));
+    }
+    case "or": {
+      return filter.filters.some((f) => filterMatchValue(f, value2));
+    }
+    default:
+      return false;
+  }
+};
+var filterMatchEntity = (filter, entity) => {
+  switch (filter.type) {
+    case "object": {
+      if (filter.typename !== null) {
+        const typeURI = getTypeURI(entity);
+        if (!typeURI || !compareTypenameStrings(filter.typename, typeURI)) {
+          return false;
+        }
+      }
+      if (filter.id && filter.id.length > 0 && !filter.id.includes(entity.id)) {
+        return false;
+      }
+      if (filter.props) {
+        let json = null;
+        try {
+          json = objectToJSON(entity);
+        } catch {
+        }
+        if (json === null) {
+          return false;
+        }
+        for (const [key, valueFilter] of Object.entries(filter.props)) {
+          if (key.startsWith("@")) {
+            continue;
+          }
+          if (!filterMatchValue(valueFilter, json[key])) {
+            return false;
+          }
+        }
+      }
+      const meta = getMetaChecked(entity);
+      if (filter.foreignKeys && filter.foreignKeys.length > 0) {
+        const hasKey = filter.foreignKeys.some((fk) => meta.keys.some((k) => k.source === fk.source && k.id === fk.id));
+        if (!hasKey) {
+          return false;
+        }
+      }
+      if (filter.metaKey !== void 0) {
+        if (!matchMetaKey(filter.metaKey, filter.metaVersion, meta.key, meta.version)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case "tag": {
+      const rawTags = getMetaChecked(entity).tags;
+      const tags = rawTags.map((tag) => typeof tag?.encode === "function" ? tag.encode() : tag);
+      return matchesTag(tags, filter.tag);
+    }
+    case "text-search": {
+      return false;
+    }
+    case "timestamp": {
+      throw new Error("Timestamp filters must be handled at the index level, not in-memory matching.");
+    }
+    case "child-of": {
+      throw new Error("child-of filters must be handled at the executor level, not in-memory matching.");
+    }
+    case "not": {
+      return !filterMatchEntity(filter.filter, entity);
+    }
+    case "and": {
+      return filter.filters.every((f) => filterMatchEntity(f, entity));
+    }
+    case "or": {
+      return filter.filters.some((f) => filterMatchEntity(f, entity));
+    }
+    default:
+      return false;
+  }
+};
+
+// src/internal/Obj/common.ts
+import * as Schema6 from "effect/Schema";
+var makeTypedEntityClass = (typename, version2, baseSchema) => {
+  return class {
+    // Implement TypedObject properties.
+    static typename = typename;
+    static version = version2;
+    // Implement Schema.Schema properties.
+    // TODO(burdon): Comment required.
+    static [Schema6.TypeId] = schemaVariance;
+    static ast = baseSchema.ast;
+    static annotations = baseSchema.annotations.bind(baseSchema);
+    static pipe = baseSchema.pipe.bind(baseSchema);
+    // TODO(burdon): Comment required.
+    static [Symbol.hasInstance](obj) {
+      return obj != null && getTypename(obj) === typename;
+    }
+    // TODO(burdon): Throw APIError.
+    constructor() {
+      throw new Error("Use live(Typename, { ...fields }) to instantiate an object.");
+    }
+  };
+};
+var schemaVariance = {
+  _A: (_) => _,
+  _I: (_) => _,
+  _R: (_) => _
+};
+
+// src/internal/Obj/create-object.ts
+import { raise as raise3 } from "@dxos/debug";
+import { assertArgument as assertArgument4, failedInvariant } from "@dxos/invariant";
+import { EntityId as EntityId2 } from "@dxos/keys";
+
+// src/internal/Obj/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]: getTypeURI(this),
+    ...props,
+    [ATTR_META]: this[MetaId]
+  }, options);
+};
+
+// src/internal/Obj/create-object.ts
+var createObject = (input, props) => {
+  const schema = getStaticTypeSchema(input) ?? failedInvariant("Type entity is missing its source schema");
+  const annotation = getTypeAnnotation(schema);
+  if (!annotation) {
+    throw new Error("Schema is not an ECHO schema");
+  }
+  assertArgument4(!("@type" in props), "data", "@type is not allowed");
+  assertArgument4(!(RelationSourceDXNId in props), "data", "Relation source DXN is not allowed in the constructor");
+  assertArgument4(!(RelationTargetDXNId in props), "data", "Relation target DXN is not allowed in the constructor");
+  assertArgument4(RelationSourceId in props === RelationTargetId in props, "data", "Relation source and target must be provided together");
+  const metaOverride = props[MetaId];
+  if (metaOverride !== void 0) {
+    delete props[MetaId];
+  }
+  const obj = {
+    ...props,
+    id: props.id ?? EntityId2.random()
+  };
+  const kind = annotation.kind === EntityKind.Type ? EntityKind.Type : annotation.kind === EntityKind.Relation || RelationSourceId in props ? EntityKind.Relation : EntityKind.Object;
+  defineHiddenProperty(obj, KindId, kind);
+  defineHiddenProperty(obj, MetaId, {
+    ...metaOverride,
+    keys: metaOverride?.keys ?? [],
+    tags: metaOverride?.tags ?? [],
+    annotations: metaOverride?.annotations ?? {}
+  });
+  setSchema(obj, schema);
+  if (input !== schema) {
+    setType(obj, input);
+  }
+  setTypename(obj, getSchemaURI(schema) ?? failedInvariant("Missing schema URI"));
+  attachTypedJsonSerializer(obj);
+  attachedTypedObjectInspector(obj);
+  if (kind === EntityKind.Relation) {
+    const sourceDXN = getObjectEchoUri(props[RelationSourceId]) ?? raise3(new Error("Unresolved relation source"));
+    const targetDXN = getObjectEchoUri(props[RelationTargetId]) ?? raise3(new Error("Unresolved relation target"));
+    defineHiddenProperty(obj, RelationSourceDXNId, sourceDXN);
+    defineHiddenProperty(obj, RelationTargetDXNId, targetDXN);
+  }
+  assertObjectModel(obj);
+  return obj;
+};
+
+// src/internal/Obj/deleted.ts
+var isDeleted = (obj) => {
+  if (obj[ObjectDeletedId] === void 0) {
+    return false;
+  }
+  return obj[ObjectDeletedId] ?? false;
+};
+
+// src/internal/Obj/set-value.ts
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as SchemaAST5 from "effect/SchemaAST";
+import { SchemaEx } from "@dxos/effect";
+import { invariant as invariant5 } from "@dxos/invariant";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/set-value.ts";
+var setValue = (obj, path, value2) => {
+  invariant5(path.length > 0, "Path must not be empty", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 14, S: void 0, A: ["path.length > 0", "'Path must not be empty'"] });
+  const schema = getSchema(obj);
+  invariant5(schema != null, "Object must have a schema", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 16, S: void 0, A: ["schema != null", "'Object must have a schema'"] });
+  let parent = obj;
+  let currentAST = schema.ast;
+  for (let i = 0; i < path.length - 1; i++) {
+    const part = path[i];
+    const key = typeof part === "number" ? part : String(part);
+    if (parent[key] === void 0) {
+      const propertyAST = getPropertyAST(currentAST, String(part));
+      const shouldBeArray = propertyAST ? SchemaEx.isArrayType(propertyAST) : false;
+      if (shouldBeArray) {
+        parent[key] = [];
+      } else {
+        const objWithDefaults = createObjectWithDefaults(propertyAST);
+        parent[key] = objWithDefaults;
+      }
+    }
+    parent = parent[key];
+    currentAST = getPropertyAST(currentAST, String(part));
+  }
+  const finalKey = path[path.length - 1];
+  parent[finalKey] = value2;
+  return value2;
+};
+var getPropertyAST = (ast, propertyName) => {
+  if (!ast) {
+    return void 0;
+  }
+  if (SchemaEx.isNestedType(ast)) {
+    const properties = SchemaEx.getProperties(ast);
+    const property = properties.find((p) => p.name.toString() === propertyName);
+    if (property) {
+      return SchemaEx.getBaseType(property).type;
+    }
+  }
+  if (SchemaEx.isArrayType(ast)) {
+    const elementType = SchemaEx.getArrayElementType(ast);
+    return elementType;
+  }
+  return void 0;
+};
+var getRequiredProperties = (ast) => {
+  if (!ast) {
+    return [];
+  }
+  if (!SchemaEx.isNestedType(ast)) {
+    return [];
+  }
+  const properties = SchemaEx.getProperties(ast);
+  return properties.filter((p) => !p.isOptional);
+};
+var getDefaultValueForType = (ast) => {
+  if (!ast) {
+    return void 0;
+  }
+  const defaultValue = SchemaAST5.getDefaultAnnotation(ast);
+  if (Option.isSome(defaultValue)) {
+    return defaultValue.value;
+  }
+  return Match.value(ast).pipe(Match.when({
+    _tag: "StringKeyword"
+  }, () => ""), Match.when({
+    _tag: "NumberKeyword"
+  }, () => 0), Match.when({
+    _tag: "BooleanKeyword"
+  }, () => false), Match.orElse(() => void 0));
+};
+var createObjectWithDefaults = (ast) => {
+  if (!ast) {
+    return {};
+  }
+  const requiredProps = getRequiredProperties(ast);
+  const obj = {};
+  for (const prop of requiredProps) {
+    const defaultValue = getDefaultValueForType(prop.type);
+    if (defaultValue !== void 0) {
+      obj[prop.name] = defaultValue;
+    } else if (SchemaEx.isNestedType(prop.type)) {
+      obj[prop.name] = createObjectWithDefaults(prop.type);
+    }
+  }
+  return obj;
+};
+
+// src/internal/Obj/snapshot.ts
+import { assertArgument as assertArgument5 } from "@dxos/invariant";
+import { deepMapValues as deepMapValues2 } from "@dxos/util";
+var copySymbolProperty = (source, target, symbol, transform) => {
+  let value2;
+  try {
+    value2 = source[symbol];
+  } catch {
+    return;
+  }
+  if (value2 !== void 0) {
+    const finalValue = transform ? transform(value2) : value2;
+    Object.defineProperty(target, symbol, {
+      value: finalValue,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+};
+var getSnapshot = (obj) => {
+  assertArgument5(typeof obj === "object" && obj !== null && KindId in obj, "obj", "must be an entity");
+  const snapshot = deepMapValues2(obj, (value2, recurse) => {
+    if (typeof value2 === "object" && value2 !== null && Object.getPrototypeOf(value2) !== Object.prototype && !Array.isArray(value2)) {
+      return value2;
+    }
+    return recurse(value2);
+  });
+  if (obj != null && typeof obj === "object" && KindId in obj) {
+    snapshot[SnapshotKindId] = obj[KindId];
+  }
+  const source = obj;
+  copySymbolProperty(source, snapshot, TypeId);
+  copySymbolProperty(source, snapshot, SchemaId);
+  copySymbolProperty(source, snapshot, TypeEntityId);
+  copySymbolProperty(source, snapshot, SelfURIId);
+  copySymbolProperty(source, snapshot, ObjectDatabaseId);
+  copySymbolProperty(source, snapshot, ObjectDeletedId);
+  copySymbolProperty(source, snapshot, ParentId);
+  copySymbolProperty(source, snapshot, MetaId, (meta) => ({
+    keys: [
+      ...meta?.keys ?? []
+    ],
+    tags: [
+      ...meta?.tags ?? []
+    ],
+    ...meta?.key != null ? {
+      key: meta.key
+    } : {},
+    ...meta?.version != null ? {
+      version: meta.version
+    } : {},
+    ...meta?.annotations ? {
+      annotations: {
+        ...meta.annotations
+      }
+    } : {}
+  }));
+  copySymbolProperty(source, snapshot, RelationSourceDXNId);
+  copySymbolProperty(source, snapshot, RelationTargetDXNId);
+  copySymbolProperty(source, snapshot, RelationSourceId);
+  copySymbolProperty(source, snapshot, RelationTargetId);
+  return Object.freeze(snapshot);
+};
+
+// src/internal/Obj/atoms.ts
+import * as Atom from "@effect-atom/atom/Atom";
+import * as Result from "@effect-atom/atom/Result";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Option2 from "effect/Option";
+import { assertArgument as assertArgument6 } from "@dxos/invariant";
+var isRef = (obj) => obj != null && typeof obj === "object" && RefTypeId in obj;
+var getReactiveOption = (snapshot) => Effect.gen(function* () {
+  const db = getDatabase(snapshot);
+  if (!db) {
+    return Option2.none();
+  }
+  const obj = db.getObjectById(snapshot.id);
+  return obj ? Option2.some(obj) : Option2.none();
+});
+var objectFamily = Atom.family((obj) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(obj, () => {
+      get.setSelf(getSnapshot(obj));
+    });
+    get.addFinalizer(() => unsubscribe());
+    return getSnapshot(obj);
+  }).pipe(Atom.keepAlive);
+});
+var refFamily = Atom.family((ref) => {
+  return Atom.make((get) => {
+    let unsubscribeTarget;
+    const setupTargetSubscription = (target) => {
+      unsubscribeTarget?.();
+      unsubscribeTarget = subscribe(target, () => {
+        get.setSelf(isDeleted(target) ? void 0 : getSnapshot(target));
+      });
+      return getSnapshot(target);
+    };
+    get.addFinalizer(() => {
+      unsubscribeTarget?.();
+    });
+    return loadRefTarget(ref, get, setupTargetSubscription);
+  }).pipe(Atom.keepAlive);
+});
+var propertyFamily = Atom.family((obj) => Atom.family((key) => {
+  return Atom.make((get) => {
+    let previousSnapshot = snapshotForComparison(obj[key]);
+    const unsubscribe2 = subscribe(obj, () => {
+      const newValue = obj[key];
+      const newSnapshot = snapshotForComparison(newValue);
+      if (newSnapshot !== previousSnapshot) {
+        previousSnapshot = newSnapshot;
+        get.setSelf(newSnapshot);
+      }
+    });
+    get.addFinalizer(() => unsubscribe2());
+    return snapshotForComparison(obj[key]);
+  }).pipe(Atom.keepAlive);
+}));
+var objectWithReactiveFamily = Atom.family((obj) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(obj, () => {
+      get.setSelf(obj);
+    });
+    get.addFinalizer(() => unsubscribe());
+    return obj;
+  }).pipe(Atom.keepAlive);
+});
+var refWithReactiveFamily = Atom.family((ref) => {
+  const effect = (get) => Effect.gen(function* () {
+    const snapshot = get(makeAtom(ref));
+    if (snapshot == null) {
+      return void 0;
+    }
+    const option = yield* getReactiveOption(snapshot);
+    return Option2.getOrElse(option, () => void 0);
+  });
+  return Function.pipe(Atom.make(effect), Atom.map((result) => Result.getOrElse(result, () => void 0)));
+});
+var refPropertyFamily = Atom.family((ref) => Atom.family((key) => {
+  return Atom.make((get) => {
+    const target = get(refWithReactiveFamily(ref));
+    return target ? get(propertyFamily(target)(key)) : void 0;
+  }).pipe(Atom.keepAlive);
+}));
+var entityFamily = Atom.family((entity) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(entity, () => {
+      get.setSelf(getSnapshot(entity));
+    });
+    get.addFinalizer(() => unsubscribe());
+    return getSnapshot(entity);
+  }).pipe(Atom.keepAlive);
+});
+var relationFamily = Atom.family((relation) => {
+  return Atom.make((get) => {
+    const unsubscribe = subscribe(relation, () => {
+      get.setSelf(getSnapshot(relation));
+    });
+    get.addFinalizer(() => unsubscribe());
+    return getSnapshot(relation);
+  }).pipe(Atom.keepAlive);
+});
+var makeAtom = (objOrRef) => {
+  if (isRef(objOrRef)) {
+    return refFamily(objOrRef);
+  }
+  const obj = objOrRef;
+  assertArgument6(isEntity(obj), "obj", "Object must be a reactive object");
+  return objectFamily(obj);
+};
+var makeProperty = (objOrRef, key) => {
+  if (isRef(objOrRef)) {
+    return refPropertyFamily(objOrRef)(key);
+  }
+  const obj = objOrRef;
+  assertArgument6(isEntity(obj), "obj", "Object must be a reactive object");
+  return propertyFamily(obj)(key);
+};
+var makeWithReactive = (objOrRef) => {
+  if (isRef(objOrRef)) {
+    return refWithReactiveFamily(objOrRef);
+  }
+  const obj = objOrRef;
+  assertArgument6(isEntity(obj), "obj", "Object must be a reactive object");
+  return objectWithReactiveFamily(obj);
+};
+var makeEntity = (entity) => {
+  assertArgument6(isEntity(entity), "entity", "Must be a reactive ECHO entity");
+  return entityFamily(entity);
+};
+var makeRelation = (relation) => {
+  assertArgument6(isEntity(relation), "relation", "Must be a reactive ECHO relation");
+  return relationFamily(relation);
+};
+var labelAtomFamily = Atom.family((entity) => {
+  return Atom.make((get) => {
+    let previous = getLabel(entity);
+    const unsubscribe = subscribe(entity, () => {
+      const next = getLabel(entity);
+      if (next !== previous) {
+        previous = next;
+        get.setSelf(next);
+      }
+    });
+    get.addFinalizer(() => unsubscribe());
+    return previous;
+  }).pipe(Atom.keepAlive);
+});
+var makeLabelAtom = (entity) => {
+  assertArgument6(isEntity(entity), "entity", "Must be a reactive ECHO entity");
+  return labelAtomFamily(entity);
+};
+
+// src/internal/Obj/clone.ts
+import { invariant as invariant6 } from "@dxos/invariant";
+import { assumeType as assumeType2, deepMapValues as deepMapValues3 } from "@dxos/util";
+var __dxlog_file6 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/clone.ts";
+var clone = (obj, opts) => cloneInner(obj, opts, obj, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+var cloneInner = (obj, opts, root, cache, inProgress) => {
+  if (cache.has(obj.id)) {
+    return cache.get(obj.id);
+  }
+  inProgress.add(obj.id);
+  const { id, ...data } = obj;
+  const typeEntity = getType(obj);
+  const schema = typeEntity != null ? getStaticTypeSchema(typeEntity) : getSchema(obj);
+  invariant6(schema != null, "Object should have a type or schema", { "~LogMeta": "~LogMeta", F: __dxlog_file6, L: 32, S: void 0, A: ["schema != null", "'Object should have a type or schema'"] });
+  const mapRef = (value2, recurse) => {
+    if (Ref.isRef(value2)) {
+      const target = value2.target;
+      if (target != null && !inProgress.has(target.id) && (opts?.deep === "all" || opts?.deep === "parent" && isChildOf(target, root))) {
+        return Ref.make(cloneInner(target, opts, root, cache, inProgress));
+      }
+      return value2;
+    }
+    return recurse(value2);
+  };
+  const props = deepMapValues3(data, mapRef);
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = deepMapValues3(getMeta(obj), mapRef);
+  const result = makeObject(schema, props, meta, typeEntity);
+  inProgress.delete(obj.id);
+  cache.set(obj.id, result);
+  return result;
+};
+var isChildOf = (entity, root) => {
+  const seen = /* @__PURE__ */ new Set();
+  assumeType2(entity);
+  let parent = entity[ParentId];
+  while (parent != null && !seen.has(parent)) {
+    if (parent.id === root.id) {
+      return true;
+    }
+    seen.add(parent);
+    parent = parent[ParentId];
+  }
+  return false;
+};
+
+// src/internal/Type/manipulation.ts
+import * as Schema7 from "effect/Schema";
+import * as SchemaAST6 from "effect/SchemaAST";
+import { invariant as invariant7 } from "@dxos/invariant";
+var __dxlog_file7 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Type/manipulation.ts";
+var addFieldsToSchema = (schema, fields) => {
+  const schemaExtension = Schema7.partial(Schema7.Struct(fields));
+  return Schema7.extend(schema, schemaExtension).annotations(schema.ast.annotations);
+};
+var updateFieldsInSchema = (schema, fields) => {
+  const ast = schema.ast;
+  invariant7(SchemaAST6.isTypeLiteral(ast), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 14, S: void 0, A: ["SchemaAST.isTypeLiteral(ast)", ""] });
+  const updatedProperties = [
+    ...ast.propertySignatures
+  ];
+  const propertiesToUpdate = Schema7.partial(Schema7.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 Schema7.make(new SchemaAST6.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
+};
+var removeFieldsFromSchema = (schema, fieldNames) => {
+  return Schema7.make(SchemaAST6.omit(schema.ast, fieldNames)).annotations(schema.ast.annotations);
+};
+var updateFieldNameInSchema = (schema, { before, after }) => {
+  const ast = schema.ast;
+  invariant7(SchemaAST6.isTypeLiteral(ast), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file7, L: 34, S: void 0, A: ["SchemaAST.isTypeLiteral(ast)", ""] });
+  return Schema7.make(new SchemaAST6.TypeLiteral(ast.propertySignatures.map((p) => p.name === before ? new SchemaAST6.PropertySignature(after, p.type, p.isOptional, p.isReadonly, p.annotations) : p), ast.indexSignatures, ast.annotations));
+};
+
+// src/internal/Type/type-schema.ts
+import * as Schema8 from "effect/Schema";
+var TypeSchemaStruct = Schema8.Struct({
+  name: Schema8.optional(Schema8.String),
+  jsonSchema: JsonSchemaType
+});
+var TypeSchema = TypeSchemaStruct.pipe(LabelAnnotation.set([
+  "name"
+]), IconAnnotation.set({
+  icon: "ph--database--regular",
+  hue: "green"
+}), EchoTypeKindSchema(TypeMetaSchemaDXN));
+
+export {
+  RawObject,
+  VersionTypeId,
+  compare,
+  sortByLabel,
+  sortByTypename,
+  sort,
+  prettyFilter,
+  prettyQuery,
+  getStrongDependencyUris,
+  getStrongDependencies,
+  normalizeSchema,
+  EchoObjectSchema,
+  makeObjectType,
+  EchoRelationSchema,
+  getDXNForRelationSchemaRef,
+  makeRelationType,
+  EchoTypeKindSchema,
+  isVersion,
+  version,
+  versionValid,
+  compareVersions,
+  encodeVersion,
+  decodeVersion,
+  objectToJSON,
+  objectFromJSON,
+  setRefResolverOnData,
+  objectStructureToJson,
+  matchesTag,
+  matchMetaKey,
+  compareTypenameStrings,
+  filterMatchValue,
+  filterMatchEntity,
+  makeTypedEntityClass,
+  createObject,
+  isDeleted,
+  setValue,
+  getSnapshot,
+  makeAtom,
+  makeProperty,
+  makeWithReactive,
+  makeEntity,
+  makeRelation,
+  makeLabelAtom,
+  clone,
+  addFieldsToSchema,
+  updateFieldsInSchema,
+  removeFieldsFromSchema,
+  updateFieldNameInSchema,
+  TypeSchema
+};
+//# sourceMappingURL=chunk-ACFAOTKJ.mjs.map