@dxos/echo 0.8.4-main.70d3990 → 0.8.4-main.74a063c4e0

package/dist/lib/node-esm/chunk-JE5RXM2I.mjs

@@ -1,1111 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-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-M4B6BMD2.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-JE5RXM2I.mjs.map