@dxos/echo 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

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

@@ -0,0 +1,1111 @@
+import "@dxos/node-std/globals";
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  Currency,
+  CurrencyAnnotationId,
+  DecimalPrecision,
+  DescriptionAnnotation,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  EchoSchema,
+  Email,
+  EntityKind,
+  EntityKindSchema,
+  Expando,
+  FormInputAnnotation,
+  Format,
+  FormatAnnotation,
+  FormatAnnotationId,
+  FormatEnums,
+  Formula,
+  GeneratorAnnotation,
+  GeoLocation,
+  GeoPoint,
+  Hostname,
+  JSON as JSON2,
+  JsonSchemaType,
+  KindId,
+  LabelAnnotation,
+  Markdown,
+  MetaId,
+  ObjectVersionId,
+  OptionsAnnotationId,
+  PersistentSchema,
+  PropertyKind,
+  Ref,
+  RefArray,
+  Regex,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SelectOptionSchema,
+  SystemTypeAnnotation,
+  TypeAnnotation,
+  TypeEnum,
+  TypeFormat,
+  URL,
+  UUID,
+  VersionTypeId,
+  __export,
+  formatToType,
+  getDescription,
+  getEntityKind,
+  getFormatAnnotation,
+  getLabel,
+  getMeta,
+  getObjectDXN,
+  getOptionsAnnotation,
+  getSchema,
+  getSchemaDXN,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypeEnum,
+  getTypeReference,
+  isDeleted,
+  isInstanceOf,
+  isMutable,
+  makeObject,
+  objectFromJSON,
+  objectToJSON,
+  setDescription,
+  setLabel,
+  toEffectSchema,
+  toJsonSchema,
+  typeToFormat
+} from "./chunk-7GH6RXJ3.mjs";
+
+// src/index.ts
+import { DXN as DXN4 } from "@dxos/keys";
+
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var SchemaNotFoundError = class extends BaseError.extend("SCHEMA_NOT_FOUND", "Schema not found") {
+  constructor(schema, options) {
+    super({
+      context: {
+        schema
+      },
+      ...options
+    });
+  }
+};
+var ObjectNotFoundError = class extends BaseError.extend("OBJECT_NOT_FOUND", "Object not found") {
+  constructor(dxn, options) {
+    super({
+      context: {
+        dxn
+      },
+      ...options
+    });
+  }
+};
+
+// src/query/index.ts
+import { QueryAST } from "@dxos/echo-protocol";
+
+// src/query/filter.ts
+import * as Match from "effect/Match";
+import * as Schema2 from "effect/Schema";
+import { assertArgument as assertArgument2 } from "@dxos/invariant";
+import { DXN as DXN2, ObjectId } from "@dxos/keys";
+
+// src/Ref.ts
+var Ref_exports = {};
+__export(Ref_exports, {
+  Array: () => Array2,
+  fromDXN: () => fromDXN,
+  isRef: () => isRef,
+  make: () => make
+});
+var Array2 = RefArray;
+var isRef = Ref.isRef;
+var make = Ref.make;
+var fromDXN = Ref.fromDXN;
+
+// src/query/util.ts
+import * as Schema from "effect/Schema";
+import { raise } from "@dxos/debug";
+import { assertArgument } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var getTypeDXNFromSpecifier = (input) => {
+  if (Schema.isSchema(input)) {
+    return getTypeReference(input)?.toDXN() ?? raise(new TypeError("Schema has no DXN"));
+  } else {
+    assertArgument(typeof input === "string", "input");
+    assertArgument(!input.startsWith("dxn:"), "input");
+    return DXN.fromTypename(input);
+  }
+};
+
+// src/query/filter.ts
+var FilterClass = class _FilterClass {
+  ast;
+  static variance = {};
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Filter" in value2;
+  }
+  static fromAst(ast) {
+    return new _FilterClass(ast);
+  }
+  static everything() {
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      props: {}
+    });
+  }
+  static nothing() {
+    return new _FilterClass({
+      type: "not",
+      filter: {
+        type: "object",
+        typename: null,
+        props: {}
+      }
+    });
+  }
+  static relation() {
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      props: {}
+    });
+  }
+  static ids(...ids) {
+    assertArgument2(ids.every((id) => ObjectId.isValid(id)), "ids", "ids must be valid");
+    if (ids.length === 0) {
+      return Filter.nothing();
+    }
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      id: ids,
+      props: {}
+    });
+  }
+  static type(schema, props) {
+    const dxn = getTypeDXNFromSpecifier(schema);
+    return new _FilterClass({
+      type: "object",
+      typename: dxn.toString(),
+      ...propsFilterToAst(props ?? {})
+    });
+  }
+  static typename(typename) {
+    assertArgument2(!typename.startsWith("dxn:"), "typename", "Typename must no be qualified");
+    return new _FilterClass({
+      type: "object",
+      typename: DXN2.fromTypename(typename).toString(),
+      props: {}
+    });
+  }
+  static typeDXN(dxn) {
+    return new _FilterClass({
+      type: "object",
+      typename: dxn.toString(),
+      props: {}
+    });
+  }
+  static tag(tag) {
+    return new _FilterClass({
+      type: "tag",
+      tag
+    });
+  }
+  static props(props) {
+    return new _FilterClass({
+      type: "object",
+      typename: null,
+      ...propsFilterToAst(props)
+    });
+  }
+  static text(text, options) {
+    return new _FilterClass({
+      type: "text-search",
+      text,
+      searchKind: options?.type
+    });
+  }
+  static foreignKeys(schema, keys) {
+    const dxn = getTypeDXNFromSpecifier(schema);
+    return new _FilterClass({
+      type: "object",
+      typename: dxn.toString(),
+      props: {},
+      foreignKeys: keys
+    });
+  }
+  static eq(value2) {
+    if (!isRef(value2) && typeof value2 === "object" && value2 !== null) {
+      throw new TypeError("Cannot use object as a value for eq filter");
+    }
+    return new _FilterClass({
+      type: "compare",
+      operator: "eq",
+      value: isRef(value2) ? value2.noInline().encode() : value2
+    });
+  }
+  static neq(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "neq",
+      value: value2
+    });
+  }
+  static gt(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "gt",
+      value: value2
+    });
+  }
+  static gte(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "gte",
+      value: value2
+    });
+  }
+  static lt(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "lt",
+      value: value2
+    });
+  }
+  static lte(value2) {
+    return new _FilterClass({
+      type: "compare",
+      operator: "lte",
+      value: value2
+    });
+  }
+  static in(...values) {
+    return new _FilterClass({
+      type: "in",
+      values
+    });
+  }
+  static contains(value2) {
+    return new _FilterClass({
+      type: "contains",
+      value: value2
+    });
+  }
+  static between(from, to) {
+    return new _FilterClass({
+      type: "range",
+      from,
+      to
+    });
+  }
+  static not(filter) {
+    return new _FilterClass({
+      type: "not",
+      filter: filter.ast
+    });
+  }
+  static and(...filters) {
+    return new _FilterClass({
+      type: "and",
+      filters: filters.map((f) => f.ast)
+    });
+  }
+  static or(...filters) {
+    return new _FilterClass({
+      type: "or",
+      filters: filters.map((f) => f.ast)
+    });
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Filter" = _FilterClass.variance;
+};
+var Filter = FilterClass;
+var propsFilterToAst = (predicates) => {
+  let idFilter;
+  if ("id" in predicates) {
+    assertArgument2(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
+    idFilter = typeof predicates.id === "string" ? [
+      predicates.id
+    ] : predicates.id;
+    Schema2.Array(ObjectId).pipe(Schema2.validateSync)(idFilter);
+  }
+  return {
+    id: idFilter,
+    props: Object.fromEntries(Object.entries(predicates).filter(([prop, _value]) => prop !== "id").map(([prop, predicate]) => [
+      prop,
+      processPredicate(predicate)
+    ]))
+  };
+};
+var processPredicate = (predicate) => {
+  return Match.value(predicate).pipe(
+    Match.withReturnType(),
+    Match.when(Filter.is, (predicate2) => predicate2.ast),
+    // TODO(wittjosiah): Add support for array predicates.
+    Match.when(Array.isArray, (_predicate) => {
+      throw new Error("Array predicates are not yet supported.");
+    }),
+    Match.when((predicate2) => !isRef(predicate2) && typeof predicate2 === "object" && predicate2 !== null, (predicate2) => {
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key, value2]) => [
+        key,
+        processPredicate(value2)
+      ]));
+      return {
+        type: "object",
+        typename: null,
+        props: nestedProps
+      };
+    }),
+    Match.orElse((value2) => Filter.eq(value2).ast)
+  );
+};
+
+// src/query/order.ts
+var OrderClass = class _OrderClass {
+  ast;
+  static variance = {};
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Order" in value2;
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Order" = _OrderClass.variance;
+};
+(function(Order2) {
+  Order2.natural = new OrderClass({
+    kind: "natural"
+  });
+  Order2.property = (property, direction) => new OrderClass({
+    kind: "property",
+    property,
+    direction
+  });
+})(Order || (Order = {}));
+var Order;
+
+// src/query/query.ts
+var QueryClass = class _QueryClass {
+  ast;
+  static variance = {};
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Query" in value2;
+  }
+  static fromAst(ast) {
+    return new _QueryClass(ast);
+  }
+  static select(filter) {
+    return new _QueryClass({
+      type: "select",
+      filter: filter.ast
+    });
+  }
+  static type(schema, predicates) {
+    return new _QueryClass({
+      type: "select",
+      filter: FilterClass.type(schema, predicates).ast
+    });
+  }
+  static all(...queries) {
+    if (queries.length === 0) {
+      throw new TypeError("Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())");
+    }
+    return new _QueryClass({
+      type: "union",
+      queries: queries.map((q) => q.ast)
+    });
+  }
+  static without(source, exclude) {
+    return new _QueryClass({
+      type: "set-difference",
+      source: source.ast,
+      exclude: exclude.ast
+    });
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Query" = _QueryClass.variance;
+  select(filter) {
+    if (Filter.is(filter)) {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: filter.ast
+      });
+    } else {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: FilterClass.props(filter).ast
+      });
+    }
+  }
+  reference(key) {
+    return new _QueryClass({
+      type: "reference-traversal",
+      anchor: this.ast,
+      property: key
+    });
+  }
+  referencedBy(target, key) {
+    const dxn = getTypeDXNFromSpecifier(target);
+    return new _QueryClass({
+      type: "incoming-references",
+      anchor: this.ast,
+      property: key,
+      typename: dxn.toString()
+    });
+  }
+  sourceOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "outgoing",
+      filter: FilterClass.type(relation, predicates).ast
+    });
+  }
+  targetOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "incoming",
+      filter: FilterClass.type(relation, predicates).ast
+    });
+  }
+  source() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "source"
+    });
+  }
+  target() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "target"
+    });
+  }
+  orderBy(...order) {
+    return new _QueryClass({
+      type: "order",
+      query: this.ast,
+      order: order.map((o) => o.ast)
+    });
+  }
+  options(options) {
+    return new _QueryClass({
+      type: "options",
+      query: this.ast,
+      options
+    });
+  }
+};
+var Query = QueryClass;
+
+// src/Annotation.ts
+var Annotation_exports = {};
+__export(Annotation_exports, {
+  DescriptionAnnotation: () => DescriptionAnnotation,
+  FormInputAnnotation: () => FormInputAnnotation,
+  GeneratorAnnotation: () => GeneratorAnnotation,
+  LabelAnnotation: () => LabelAnnotation,
+  SystemTypeAnnotation: () => SystemTypeAnnotation,
+  TypeAnnotation: () => TypeAnnotation,
+  getDescription: () => getDescription,
+  getLabel: () => getLabel,
+  getTypeAnnotation: () => getTypeAnnotation,
+  setDescription: () => setDescription,
+  setLabel: () => setLabel
+});
+
+// src/Database.ts
+var Database_exports = {};
+
+// src/Entity.ts
+var Entity_exports = {};
+__export(Entity_exports, {
+  Kind: () => Kind,
+  KindId: () => KindId,
+  KindSchema: () => KindSchema,
+  getKind: () => getKind
+});
+var Kind = EntityKind;
+var KindSchema = EntityKindSchema;
+var getKind = getEntityKind;
+
+// src/Format.ts
+var Format_exports = {};
+__export(Format_exports, {
+  Currency: () => Currency,
+  CurrencyAnnotationId: () => CurrencyAnnotationId,
+  DecimalPrecision: () => DecimalPrecision,
+  Email: () => Email,
+  Format: () => Format,
+  FormatAnnotation: () => FormatAnnotation,
+  FormatAnnotationId: () => FormatAnnotationId,
+  FormatEnums: () => FormatEnums,
+  Formula: () => Formula,
+  GeoLocation: () => GeoLocation,
+  GeoPoint: () => GeoPoint,
+  Hostname: () => Hostname,
+  JSON: () => JSON2,
+  Markdown: () => Markdown,
+  OptionsAnnotationId: () => OptionsAnnotationId,
+  PropertyKind: () => PropertyKind,
+  Regex: () => Regex,
+  SelectOptionSchema: () => SelectOptionSchema,
+  TypeEnum: () => TypeEnum,
+  TypeFormat: () => TypeFormat,
+  URL: () => URL,
+  UUID: () => UUID,
+  formatToType: () => formatToType,
+  getFormatAnnotation: () => getFormatAnnotation,
+  getOptionsAnnotation: () => getOptionsAnnotation,
+  getTypeEnum: () => getTypeEnum,
+  typeToFormat: () => typeToFormat
+});
+
+// src/JsonSchema.ts
+var JsonSchema_exports = {};
+__export(JsonSchema_exports, {
+  JsonSchema: () => JsonSchema,
+  toEffectSchema: () => toEffectSchema,
+  toJsonSchema: () => toJsonSchema
+});
+var JsonSchema = JsonSchemaType;
+
+// src/Key.ts
+var Key_exports = {};
+__export(Key_exports, {
+  ForeignKey: () => ForeignKey,
+  ObjectId: () => ObjectId2,
+  SpaceId: () => SpaceId
+});
+import { ForeignKey } from "@dxos/echo-protocol";
+import { SpaceId, ObjectId as ObjectId2 } from "@dxos/keys";
+
+// src/Obj.ts
+var Obj_exports = {};
+__export(Obj_exports, {
+  Any: () => Any,
+  ID: () => ID,
+  Meta: () => Meta,
+  VersionTypeId: () => VersionTypeId,
+  addTag: () => addTag,
+  clone: () => clone,
+  compareVersions: () => compareVersions,
+  decodeVersion: () => decodeVersion,
+  deleteKeys: () => deleteKeys,
+  encodeVersion: () => encodeVersion,
+  fromJSON: () => fromJSON,
+  getDXN: () => getDXN2,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta3,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename2,
+  instanceOf: () => instanceOf,
+  isDeleted: () => isDeleted2,
+  isObject: () => isObject,
+  isVersion: () => isVersion,
+  make: () => make2,
+  removeTag: () => removeTag,
+  setDescription: () => setDescription2,
+  setLabel: () => setLabel2,
+  sort: () => sort,
+  sortByLabel: () => sortByLabel,
+  sortByTypename: () => sortByTypename,
+  toJSON: () => toJSON,
+  version: () => version,
+  versionValid: () => versionValid
+});
+import * as Function from "effect/Function";
+import * as Schema3 from "effect/Schema";
+import { assertArgument as assertArgument3, invariant as invariant2 } from "@dxos/invariant";
+import { ObjectId as ObjectId3 } from "@dxos/keys";
+import { getSnapshot as getSnapshot$ } from "@dxos/live-object";
+import { assumeType, deepMapValues } from "@dxos/util";
+
+// src/Type.ts
+var Type_exports = {};
+__export(Type_exports, {
+  Expando: () => Expando2,
+  Obj: () => Obj,
+  PersistentType: () => PersistentType,
+  Ref: () => Ref2,
+  Relation: () => Relation,
+  RuntimeType: () => EchoSchema,
+  getDXN: () => getDXN,
+  getMeta: () => getMeta2,
+  getTypename: () => getTypename,
+  getVersion: () => getVersion,
+  isMutable: () => isMutable2,
+  toEffectSchema: () => toEffectSchema,
+  toJsonSchema: () => toJsonSchema
+});
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Type.ts";
+var Obj = EchoObjectSchema;
+var Expando2 = Expando;
+var PersistentType = PersistentSchema;
+var Relation = EchoRelationSchema;
+var Ref2 = Ref;
+var getDXN = (schema) => {
+  return getSchemaDXN(schema);
+};
+var getTypename = (schema) => {
+  const typename = getSchemaTypename(schema);
+  invariant(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", {
+    F: __dxlog_file,
+    L: 229,
+    S: void 0,
+    A: [
+      "typeof typename === 'string' && !typename.startsWith('dxn:')",
+      "'Invalid typename'"
+    ]
+  });
+  return typename;
+};
+var getVersion = (schema) => {
+  const version2 = getSchemaVersion(schema);
+  invariant(typeof version2 === "string" && version2.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
+    F: __dxlog_file,
+    L: 239,
+    S: void 0,
+    A: [
+      "typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)",
+      "'Invalid version'"
+    ]
+  });
+  return version2;
+};
+var isMutable2 = isMutable;
+var getMeta2 = (schema) => {
+  return getTypeAnnotation(schema);
+};
+
+// src/Obj.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
+var Any = Schema3.Struct({}).pipe(Obj({
+  typename: "dxos.org/type/Any",
+  version: "0.1.0"
+}));
+var defaultMeta = {
+  keys: []
+};
+var make2 = (schema, props, meta) => {
+  assertArgument3(getTypeAnnotation(schema)?.kind === Kind.Object, "schema", "Expected an object schema");
+  if (props[MetaId] != null) {
+    meta = {
+      ...structuredClone(defaultMeta),
+      ...props[MetaId]
+    };
+    delete props[MetaId];
+  }
+  const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== void 0));
+  return makeObject(schema, filterUndefined, {
+    ...defaultMeta,
+    ...meta
+  });
+};
+var isObject = (obj) => {
+  assumeType(obj);
+  return typeof obj === "object" && obj !== null && obj[KindId] === Kind.Object;
+};
+var getSnapshot = getSnapshot$;
+var clone = (obj, opts) => {
+  const { id, ...data } = obj;
+  const schema = getSchema(obj);
+  invariant2(schema != null, "Object should have a schema", {
+    F: __dxlog_file2,
+    L: 157,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object should have a schema'"
+    ]
+  });
+  const props = deepMapValues(data, (value2, recurse) => {
+    if (isRef(value2)) {
+      return value2;
+    }
+    return recurse(value2);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = getMeta3(obj);
+  props[MetaId] = deepMapValues(meta, (value2, recurse) => {
+    if (isRef(value2)) {
+      return value2;
+    }
+    return recurse(value2);
+  });
+  return make2(schema, props);
+};
+var ID = ObjectId3;
+var instanceOf = (...args) => {
+  if (args.length === 1) {
+    return (entity) => isInstanceOf(args[0], entity);
+  }
+  return isInstanceOf(args[0], args[1]);
+};
+var getDXN2 = (entity) => {
+  assertArgument3(!Schema3.isSchema(entity), "obj", "Object should not be a schema.");
+  const dxn = getObjectDXN(entity);
+  invariant2(dxn != null, "Invalid object.", {
+    F: __dxlog_file2,
+    L: 213,
+    S: void 0,
+    A: [
+      "dxn != null",
+      "'Invalid object.'"
+    ]
+  });
+  return dxn;
+};
+var getTypeDXN2 = getTypeDXN;
+var getSchema2 = getSchema;
+var getTypename2 = (entity) => {
+  const schema = getSchema(entity);
+  if (schema == null) {
+    return getTypeDXN(entity)?.asTypeDXN()?.type;
+  }
+  return getSchemaTypename(schema);
+};
+var Meta = MetaId;
+var getMeta3 = (entity) => {
+  const meta = getMeta(entity);
+  invariant2(meta != null, "Invalid object.", {
+    F: __dxlog_file2,
+    L: 253,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta;
+};
+var getKeys = Function.dual(2, (entity, source) => {
+  const meta = getMeta3(entity);
+  invariant2(meta != null, "Invalid object.", {
+    F: __dxlog_file2,
+    L: 265,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta.keys.filter((key) => key.source === source);
+});
+var deleteKeys = (entity, source) => {
+  const meta = getMeta3(entity);
+  for (let i = 0; i < meta.keys.length; i++) {
+    if (meta.keys[i].source === source) {
+      meta.keys.splice(i, 1);
+      i--;
+    }
+  }
+};
+var addTag = (entity, tag) => {
+  const meta = getMeta3(entity);
+  meta.tags ??= [];
+  meta.tags.push(tag);
+};
+var removeTag = (entity, tag) => {
+  const meta = getMeta3(entity);
+  if (!meta.tags) {
+    return;
+  }
+  for (let i = 0; i < meta.tags.length; i++) {
+    if (meta.tags[i] === tag) {
+      meta.tags.splice(i, 1);
+      i--;
+    }
+  }
+};
+var isDeleted2 = (entity) => {
+  const deleted = isDeleted(entity);
+  invariant2(typeof deleted === "boolean", "Invalid object.", {
+    F: __dxlog_file2,
+    L: 306,
+    S: void 0,
+    A: [
+      "typeof deleted === 'boolean'",
+      "'Invalid object.'"
+    ]
+  });
+  return deleted;
+};
+var getLabel2 = (entity) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getLabel(schema, entity);
+  }
+};
+var setLabel2 = (entity, label) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setLabel(schema, entity, label);
+  }
+};
+var getDescription2 = (entity) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getDescription(schema, entity);
+  }
+};
+var setDescription2 = (entity, description) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setDescription(schema, entity, description);
+  }
+};
+var toJSON = (entity) => objectToJSON(entity);
+var fromJSON = objectFromJSON;
+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(getLabel2(a), getLabel2(b));
+var sortByTypename = (a, b) => compare(getTypename2(a), getTypename2(b));
+var sort = (...comparators) => {
+  return (a, b) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  };
+};
+var unversioned = {
+  [VersionTypeId]: {},
+  versioned: false
+};
+var isVersion = (entity) => {
+  return entity != null && typeof entity === "object" && VersionTypeId in entity;
+};
+var version = (entity) => {
+  const version2 = entity[ObjectVersionId];
+  if (version2 === void 0) {
+    return unversioned;
+  }
+  return version2;
+};
+var versionValid = (version2) => {
+  assertArgument3(isVersion(version2), "version", "Invalid version object");
+  return !!version2.versioned;
+};
+var compareVersions = (version1, version2) => {
+  assertArgument3(isVersion(version1), "version1", "Invalid version object");
+  assertArgument3(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 = (version2) => {
+  return JSON.stringify(version2);
+};
+var decodeVersion = (version2) => {
+  const parsed = JSON.parse(version2);
+  parsed[VersionTypeId] = {};
+  return parsed;
+};
+
+// src/Relation.ts
+var Relation_exports = {};
+__export(Relation_exports, {
+  Any: () => Any2,
+  Source: () => Source,
+  Target: () => Target,
+  getSource: () => getSource,
+  getSourceDXN: () => getSourceDXN,
+  getTarget: () => getTarget,
+  getTargetDXN: () => getTargetDXN,
+  isRelation: () => isRelation,
+  make: () => make3
+});
+import * as Schema4 from "effect/Schema";
+import { raise as raise2 } from "@dxos/debug";
+import { assertArgument as assertArgument4, invariant as invariant3 } from "@dxos/invariant";
+import { DXN as DXN3 } from "@dxos/keys";
+import { assumeType as assumeType2 } from "@dxos/util";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
+var Any2 = Schema4.Struct({}).pipe(Relation({
+  typename: "dxos.org/type/Any",
+  version: "0.1.0",
+  source: Any,
+  target: Any
+}));
+var Source = RelationSourceId;
+var Target = RelationTargetId;
+var make3 = (schema, props, meta) => {
+  assertArgument4(getTypeAnnotation(schema)?.kind === EntityKind.Relation, "schema", "Expected a relation schema");
+  if (props[MetaId] != null) {
+    meta = props[MetaId];
+    delete props[MetaId];
+  }
+  const sourceDXN = getObjectDXN(props[Source]) ?? raise2(new Error("Unresolved relation source"));
+  const targetDXN = getObjectDXN(props[Target]) ?? raise2(new Error("Unresolved relation target"));
+  props[RelationSourceDXNId] = sourceDXN;
+  props[RelationTargetDXNId] = targetDXN;
+  return makeObject(schema, props, meta);
+};
+var isRelation = (value2) => {
+  if (typeof value2 !== "object" || value2 === null) {
+    return false;
+  }
+  if (ATTR_RELATION_SOURCE in value2 || ATTR_RELATION_TARGET in value2) {
+    return true;
+  }
+  const kind = value2[KindId];
+  return kind === EntityKind.Relation;
+};
+var getSourceDXN = (value2) => {
+  assertArgument4(isRelation(value2), "Expected a relation");
+  assumeType2(value2);
+  const dxn = value2[RelationSourceDXNId];
+  invariant3(dxn instanceof DXN3, void 0, {
+    F: __dxlog_file3,
+    L: 124,
+    S: void 0,
+    A: [
+      "dxn instanceof DXN",
+      ""
+    ]
+  });
+  return dxn;
+};
+var getTargetDXN = (value2) => {
+  assertArgument4(isRelation(value2), "Expected a relation");
+  assumeType2(value2);
+  const dxn = value2[RelationTargetDXNId];
+  invariant3(dxn instanceof DXN3, void 0, {
+    F: __dxlog_file3,
+    L: 136,
+    S: void 0,
+    A: [
+      "dxn instanceof DXN",
+      ""
+    ]
+  });
+  return dxn;
+};
+var getSource = (relation) => {
+  assertArgument4(isRelation(relation), "Expected a relation");
+  assumeType2(relation);
+  const obj = relation[RelationSourceId];
+  invariant3(obj !== void 0, `Invalid source: ${relation.id}`, {
+    F: __dxlog_file3,
+    L: 148,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid source: ${relation.id}`"
+    ]
+  });
+  return obj;
+};
+var getTarget = (relation) => {
+  assertArgument4(isRelation(relation), "Expected a relation");
+  assumeType2(relation);
+  const obj = relation[RelationTargetId];
+  invariant3(obj !== void 0, `Invalid target: ${relation.id}`, {
+    F: __dxlog_file3,
+    L: 160,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid target: ${relation.id}`"
+    ]
+  });
+  return obj;
+};
+
+// src/Tag.ts
+var Tag_exports = {};
+__export(Tag_exports, {
+  Tag: () => Tag,
+  createTagList: () => createTagList,
+  findTagByLabel: () => findTagByLabel,
+  make: () => make4,
+  sortTags: () => sortTags
+});
+import * as Schema5 from "effect/Schema";
+var Tag = Schema5.Struct({
+  label: Schema5.String,
+  hue: Schema5.optional(Schema5.String)
+}).pipe(Obj({
+  typename: "dxos.org/type/Tag",
+  version: "0.1.0"
+}), LabelAnnotation.set([
+  "label"
+]), SystemTypeAnnotation.set(true));
+var make4 = (props) => make2(Tag, props);
+var sortTags = ({ label: a }, { label: b }) => a.localeCompare(b);
+var createTagList = (tags) => Object.entries(tags).map(([id, tag]) => ({
+  ...tag,
+  id
+})).sort(sortTags);
+var findTagByLabel = (tags, name) => {
+  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());
+  return entry ? {
+    ...entry[1],
+    id: entry[0]
+  } : void 0;
+};
+
+export {
+  SchemaNotFoundError,
+  ObjectNotFoundError,
+  Ref_exports,
+  FilterClass,
+  Filter,
+  Order,
+  Query,
+  QueryAST,
+  Annotation_exports,
+  Database_exports,
+  Entity_exports,
+  Format_exports,
+  JsonSchema_exports,
+  Key_exports,
+  Obj,
+  Relation,
+  Ref2 as Ref,
+  Type_exports,
+  Any,
+  Obj_exports,
+  Relation_exports,
+  Tag_exports,
+  DXN4 as DXN
+};
+//# sourceMappingURL=chunk-E4UTVJNF.mjs.map