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

package/dist/lib/node-esm/{chunk-TCY7IVTS.mjs → chunk-5NWDGIBT.mjs}

@@ -1,254 +1,48 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// 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
-    });
-  }
-};
+import {
+  EchoObject,
+  EchoRelation,
+  EntityKind,
+  EntityKindId,
+  Expando,
+  Format,
+  JsonSchemaType,
+  LabelAnnotation,
+  MetaId,
+  ObjectVersionId,
+  Ref,
+  RefArray,
+  VersionTypeId,
+  __export,
+  getDescription,
+  getLabel,
+  getMeta,
+  getObjectDXN,
+  getSchema,
+  getSchemaDXN,
+  getSchemaTypename,
+  getSchemaVersion,
+  getType,
+  getTypeAnnotation,
+  getTypeReference,
+  isDeleted,
+  isInstanceOf,
+  isMutable,
+  live,
+  objectFromJSON,
+  objectToJSON,
+  setDescription,
+  setLabel,
+  toEffectSchema,
+  toJsonSchema
+} from "./chunk-BQRA4VLX.mjs";
 
-// src/Key.ts
-var Key_exports = {};
-__export(Key_exports, {
-  ObjectId: () => ObjectId,
-  SpaceId: () => SpaceId
-});
-import { SpaceId, ObjectId } from "@dxos/keys";
-
-// src/Obj.ts
-var Obj_exports = {};
-__export(Obj_exports, {
-  Meta: () => Meta,
-  VersionTypeId: () => VersionTypeId2,
-  clone: () => clone,
-  compareVersions: () => compareVersions,
-  decodeVersion: () => decodeVersion,
-  deleteKeys: () => deleteKeys,
-  encodeVersion: () => encodeVersion,
-  fromJSON: () => fromJSON,
-  getDXN: () => getDXN,
-  getKeys: () => getKeys,
-  getLabel: () => getLabel2,
-  getMeta: () => getMeta2,
-  getSchema: () => getSchema2,
-  getSnapshot: () => getSnapshot2,
-  getTypeDXN: () => getTypeDXN,
-  getTypename: () => getTypename,
-  instanceOf: () => instanceOf,
-  isDeleted: () => isDeleted2,
-  isObject: () => isObject,
-  isVersion: () => isVersion,
-  make: () => make,
-  setLabel: () => setLabel2,
-  toJSON: () => toJSON,
-  version: () => version,
-  versionValid: () => versionValid
-});
-import { Schema } from "effect";
-import { dual } from "effect/Function";
-import * as EchoSchema from "@dxos/echo-schema";
-import { assertArgument, invariant } from "@dxos/invariant";
-import * as LiveObject from "@dxos/live-object";
-import { live } from "@dxos/live-object";
-import { assumeType, deepMapValues } from "@dxos/util";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
-var Meta = EchoSchema.MetaId;
-var make = (schema, props, meta) => {
-  assertArgument(EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Object, "schema", "Expected an object schema");
-  if (props[EchoSchema.MetaId] != null) {
-    meta = props[EchoSchema.MetaId];
-    delete props[EchoSchema.MetaId];
-  }
-  return live(schema, props, meta);
-};
-var isObject = (obj) => {
-  assumeType(obj);
-  return typeof obj === "object" && obj !== null && obj[EchoSchema.EntityKindId] === EchoSchema.EntityKind.Object;
-};
-var instanceOf = (...args) => {
-  if (args.length === 1) {
-    return (obj) => EchoSchema.isInstanceOf(args[0], obj);
-  }
-  return EchoSchema.isInstanceOf(args[0], args[1]);
-};
-var getSchema2 = EchoSchema.getSchema;
-var getDXN = (obj) => {
-  assertArgument(!Schema.isSchema(obj), "obj", "Object should not be a schema.");
-  const dxn = EchoSchema.getObjectDXN(obj);
-  invariant(dxn != null, "Invalid object.", {
-    F: __dxlog_file,
-    L: 113,
-    S: void 0,
-    A: [
-      "dxn != null",
-      "'Invalid object.'"
-    ]
-  });
-  return dxn;
-};
-var getTypeDXN = EchoSchema.getType;
-var getTypename = (obj) => {
-  const schema = getSchema2(obj);
-  if (schema == null) {
-    return EchoSchema.getType(obj)?.asTypeDXN()?.type;
-  }
-  return EchoSchema.getSchemaTypename(schema);
-};
-var getMeta2 = (obj) => {
-  const meta = EchoSchema.getMeta(obj);
-  invariant(meta != null, "Invalid object.", {
-    F: __dxlog_file,
-    L: 141,
-    S: void 0,
-    A: [
-      "meta != null",
-      "'Invalid object.'"
-    ]
-  });
-  return meta;
-};
-var getKeys = dual(2, (obj, source) => {
-  const meta = EchoSchema.getMeta(obj);
-  invariant(meta != null, "Invalid object.", {
-    F: __dxlog_file,
-    L: 153,
-    S: void 0,
-    A: [
-      "meta != null",
-      "'Invalid object.'"
-    ]
-  });
-  return meta.keys.filter((key) => key.source === source);
-});
-var deleteKeys = (obj, source) => {
-  const meta = EchoSchema.getMeta(obj);
-  for (let i = 0; i < meta.keys.length; i++) {
-    if (meta.keys[i].source === source) {
-      meta.keys.splice(i, 1);
-      i--;
-    }
-  }
-};
-var isDeleted2 = (obj) => {
-  const deleted = EchoSchema.isDeleted(obj);
-  invariant(typeof deleted === "boolean", "Invalid object.", {
-    F: __dxlog_file,
-    L: 175,
-    S: void 0,
-    A: [
-      "typeof deleted === 'boolean'",
-      "'Invalid object.'"
-    ]
-  });
-  return deleted;
-};
-var getLabel2 = (obj) => {
-  const schema = getSchema2(obj);
-  if (schema != null) {
-    return EchoSchema.getLabel(schema, obj);
-  }
-};
-var setLabel2 = (obj, label) => {
-  const schema = getSchema2(obj);
-  if (schema != null) {
-    EchoSchema.setLabel(schema, obj, label);
-  }
-};
-var toJSON = (obj) => EchoSchema.objectToJSON(obj);
-var fromJSON = EchoSchema.objectFromJSON;
-var getSnapshot2 = LiveObject.getSnapshot;
-var clone = (obj, opts) => {
-  const { id, ...data } = obj;
-  const schema = getSchema2(obj);
-  invariant(schema != null, "Object should have a schema", {
-    F: __dxlog_file,
-    L: 240,
-    S: void 0,
-    A: [
-      "schema != null",
-      "'Object should have a schema'"
-    ]
-  });
-  const props = deepMapValues(data, (value, recurse) => {
-    if (EchoSchema.Ref.isRef(value)) {
-      return value;
-    }
-    return recurse(value);
-  });
-  if (opts?.retainId) {
-    props.id = id;
-  }
-  const meta = getMeta2(obj);
-  props[EchoSchema.MetaId] = deepMapValues(meta, (value, recurse) => {
-    if (EchoSchema.Ref.isRef(value)) {
-      return value;
-    }
-    return recurse(value);
-  });
-  return make(schema, props);
-};
-var VersionTypeId2 = EchoSchema.VersionTypeId;
-var unversioned = {
-  [VersionTypeId2]: {},
-  versioned: false
-};
-var isVersion = (obj) => {
-  return obj != null && typeof obj === "object" && VersionTypeId2 in obj;
-};
-var version = (obj) => {
-  const version2 = obj[EchoSchema.ObjectVersionId];
-  if (version2 === void 0) {
-    return unversioned;
-  }
-  return version2;
-};
-var versionValid = (version2) => {
-  assertArgument(isVersion(version2), "version", "Invalid version object");
-  return !!version2.versioned;
-};
-var compareVersions = (version1, version2) => {
-  assertArgument(isVersion(version1), "version1", "Invalid version object");
-  assertArgument(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[VersionTypeId2] = {};
-  return parsed;
-};
+// src/query/query.ts
+import * as Match from "effect/Match";
+import * as Schema from "effect/Schema";
+import { raise } from "@dxos/debug";
+import { assertArgument } from "@dxos/invariant";
+import { DXN, ObjectId } from "@dxos/keys";
 
 // src/Ref.ts
 var Ref_exports = {};
@@ -256,210 +50,30 @@ __export(Ref_exports, {
   Array: () => Array2,
   fromDXN: () => fromDXN,
   isRef: () => isRef,
-  make: () => make2
-});
-import * as EchoSchema2 from "@dxos/echo-schema";
-var Array2 = EchoSchema2.RefArray;
-var isRef = EchoSchema2.Ref.isRef;
-var make2 = EchoSchema2.Ref.make;
-var fromDXN = EchoSchema2.Ref.fromDXN;
-
-// src/Relation.ts
-var Relation_exports = {};
-__export(Relation_exports, {
-  Source: () => Source,
-  Target: () => Target,
-  getSource: () => getSource,
-  getSourceDXN: () => getSourceDXN,
-  getTarget: () => getTarget,
-  getTargetDXN: () => getTargetDXN,
-  isRelation: () => isRelation,
-  make: () => make3
-});
-import { raise } from "@dxos/debug";
-import * as EchoSchema3 from "@dxos/echo-schema";
-import { assertArgument as assertArgument2, invariant as invariant2 } from "@dxos/invariant";
-import { DXN } from "@dxos/keys";
-import { live as live2 } from "@dxos/live-object";
-import { assumeType as assumeType2 } from "@dxos/util";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
-var Source = EchoSchema3.RelationSourceId;
-var Target = EchoSchema3.RelationTargetId;
-var make3 = (schema, props, meta) => {
-  assertArgument2(EchoSchema3.getTypeAnnotation(schema)?.kind === EchoSchema3.EntityKind.Relation, "schema", "Expected a relation schema");
-  if (props[EchoSchema3.MetaId] != null) {
-    meta = props[EchoSchema3.MetaId];
-    delete props[EchoSchema3.MetaId];
-  }
-  const sourceDXN = EchoSchema3.getObjectDXN(props[Source]) ?? raise(new Error("Unresolved relation source"));
-  const targetDXN = EchoSchema3.getObjectDXN(props[Target]) ?? raise(new Error("Unresolved relation target"));
-  props[EchoSchema3.RelationSourceDXNId] = sourceDXN;
-  props[EchoSchema3.RelationTargetDXNId] = targetDXN;
-  return live2(schema, props, meta);
-};
-var isRelation = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  if (EchoSchema3.ATTR_RELATION_SOURCE in value || EchoSchema3.ATTR_RELATION_TARGET in value) {
-    return true;
-  }
-  const kind = value[EchoSchema3.EntityKindId];
-  return kind === EchoSchema3.EntityKind.Relation;
-};
-var getSourceDXN = (value) => {
-  assertArgument2(isRelation(value), "Expected a relation");
-  assumeType2(value);
-  const dxn = value[EchoSchema3.RelationSourceDXNId];
-  invariant2(dxn instanceof DXN, void 0, {
-    F: __dxlog_file2,
-    L: 100,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
-  return dxn;
-};
-var getTargetDXN = (value) => {
-  assertArgument2(isRelation(value), "Expected a relation");
-  assumeType2(value);
-  const dxn = value[EchoSchema3.RelationTargetDXNId];
-  invariant2(dxn instanceof DXN, void 0, {
-    F: __dxlog_file2,
-    L: 112,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
-  return dxn;
-};
-var getSource = (relation) => {
-  assertArgument2(isRelation(relation), "Expected a relation");
-  assumeType2(relation);
-  const obj = relation[EchoSchema3.RelationSourceId];
-  invariant2(obj !== void 0, `Invalid source: ${relation.id}`, {
-    F: __dxlog_file2,
-    L: 124,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid source: ${relation.id}`"
-    ]
-  });
-  return obj;
-};
-var getTarget = (relation) => {
-  assertArgument2(isRelation(relation), "Expected a relation");
-  assumeType2(relation);
-  const obj = relation[EchoSchema3.RelationTargetId];
-  invariant2(obj !== void 0, `Invalid target: ${relation.id}`, {
-    F: __dxlog_file2,
-    L: 136,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid target: ${relation.id}`"
-    ]
-  });
-  return obj;
-};
-
-// src/Type.ts
-var Type_exports = {};
-__export(Type_exports, {
-  DXN: () => DXN2,
-  Expando: () => Expando2,
-  Format: () => Format,
-  JsonSchema: () => JsonSchemaType,
-  Kind: () => Kind,
-  KindId: () => KindId,
-  Obj: () => Obj,
-  ObjectId: () => ObjectId2,
-  Ref: () => Ref4,
-  Relation: () => Relation,
-  SpaceId: () => SpaceId2,
-  getDXN: () => getDXN2,
-  getMeta: () => getMeta3,
-  getTypename: () => getTypename2,
-  getVersion: () => getVersion,
-  isMutable: () => isMutable2,
-  toEffectSchema: () => toEffectSchema,
-  toJsonSchema: () => toJsonSchema
+  make: () => make
 });
-import * as EchoSchema4 from "@dxos/echo-schema";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { SpaceId as SpaceId2, ObjectId as ObjectId2, DXN as DXN2 } from "@dxos/keys";
-import { Format, JsonSchemaType, toEffectSchema, toJsonSchema } from "@dxos/echo-schema";
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/Type.ts";
-var KindId = EchoSchema4.EntityKindId;
-var Kind = EchoSchema4.EntityKind;
-var Obj = EchoSchema4.EchoObject;
-var Expando2 = EchoSchema4.Expando;
-var Relation = EchoSchema4.EchoRelation;
-var Ref4 = EchoSchema4.Ref;
-var getDXN2 = (schema) => {
-  return EchoSchema4.getSchemaDXN(schema);
-};
-var getTypename2 = (schema) => {
-  const typename = EchoSchema4.getSchemaTypename(schema);
-  invariant3(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", {
-    F: __dxlog_file3,
-    L: 212,
-    S: void 0,
-    A: [
-      "typeof typename === 'string' && !typename.startsWith('dxn:')",
-      "'Invalid typename'"
-    ]
-  });
-  return typename;
-};
-var getVersion = (schema) => {
-  const version2 = EchoSchema4.getSchemaVersion(schema);
-  invariant3(typeof version2 === "string" && version2.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
-    F: __dxlog_file3,
-    L: 222,
-    S: void 0,
-    A: [
-      "typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)",
-      "'Invalid version'"
-    ]
-  });
-  return version2;
-};
-var isMutable2 = EchoSchema4.isMutable;
-var getMeta3 = (schema) => {
-  return EchoSchema4.getTypeAnnotation(schema);
-};
-
-// src/index.ts
-import { DXN as DXN4 } from "@dxos/keys";
+var Array2 = RefArray;
+var isRef = Ref.isRef;
+var make = Ref.make;
+var fromDXN = Ref.fromDXN;
 
-// src/query/dsl.ts
-import { Match, Schema as Schema2 } from "effect";
-import { raise as raise2 } from "@dxos/debug";
-import { getTypeReference } from "@dxos/echo-schema";
-import { assertArgument as assertArgument3 } from "@dxos/invariant";
-import { DXN as DXN3, ObjectId as ObjectId3 } from "@dxos/keys";
-function _define_property(obj, key, value) {
+// src/query/query.ts
+function _define_property(obj, key, value2) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
-      value,
+      value: value2,
       enumerable: true,
       configurable: true,
       writable: true
     });
   } else {
-    obj[key] = value;
+    obj[key] = value2;
   }
   return obj;
 }
 var OrderClass = class _OrderClass {
-  static is(value) {
-    return typeof value === "object" && value !== null && "~Order" in value;
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Order" in value2;
   }
   constructor(ast) {
     _define_property(this, "ast", void 0);
@@ -480,8 +94,11 @@ _define_property(OrderClass, "variance", {});
   });
 })(Order || (Order = {}));
 var FilterClass = class _FilterClass {
-  static is(value) {
-    return typeof value === "object" && value !== null && "~Filter" in value;
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Filter" in value2;
+  }
+  static fromAst(ast) {
+    return new _FilterClass(ast);
   }
   static everything() {
     return new _FilterClass({
@@ -508,7 +125,7 @@ var FilterClass = class _FilterClass {
     });
   }
   static ids(...ids) {
-    assertArgument3(ids.every((id) => ObjectId3.isValid(id)), "ids", "ids must be valid");
+    assertArgument(ids.every((id) => ObjectId.isValid(id)), "ids", "ids must be valid");
     if (ids.length === 0) {
       return Filter.nothing();
     }
@@ -520,7 +137,7 @@ var FilterClass = class _FilterClass {
     });
   }
   static type(schema, props) {
-    const dxn = getTypeReference(schema)?.toDXN() ?? raise2(new TypeError("Schema has no DXN"));
+    const dxn = getTypeDXNFromSpecifier(schema);
     return new _FilterClass({
       type: "object",
       typename: dxn.toString(),
@@ -528,10 +145,10 @@ var FilterClass = class _FilterClass {
     });
   }
   static typename(typename) {
-    assertArgument3(!typename.startsWith("dxn:"), "typename", "Typename must no be qualified");
+    assertArgument(!typename.startsWith("dxn:"), "typename", "Typename must no be qualified");
     return new _FilterClass({
       type: "object",
-      typename: DXN3.fromTypename(typename).toString(),
+      typename: DXN.fromTypename(typename).toString(),
       props: {}
     });
   }
@@ -542,10 +159,13 @@ var FilterClass = class _FilterClass {
       props: {}
     });
   }
-  /**
-  * @internal
-  */
-  static _props(props) {
+  static tag(tag) {
+    return new _FilterClass({
+      type: "tag",
+      tag
+    });
+  }
+  static props(props) {
     return new _FilterClass({
       type: "object",
       typename: null,
@@ -560,7 +180,7 @@ var FilterClass = class _FilterClass {
     });
   }
   static foreignKeys(schema, keys) {
-    const dxn = getTypeReference(schema)?.toDXN() ?? raise2(new TypeError("Schema has no DXN"));
+    const dxn = getTypeDXNFromSpecifier(schema);
     return new _FilterClass({
       type: "object",
       typename: dxn.toString(),
@@ -568,49 +188,49 @@ var FilterClass = class _FilterClass {
       foreignKeys: keys
     });
   }
-  static eq(value) {
-    if (!isRef(value) && typeof value === "object" && value !== null) {
+  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(value) ? value.noInline().encode() : value
+      value: isRef(value2) ? value2.noInline().encode() : value2
     });
   }
-  static neq(value) {
+  static neq(value2) {
     return new _FilterClass({
       type: "compare",
       operator: "neq",
-      value
+      value: value2
     });
   }
-  static gt(value) {
+  static gt(value2) {
     return new _FilterClass({
       type: "compare",
       operator: "gt",
-      value
+      value: value2
     });
   }
-  static gte(value) {
+  static gte(value2) {
     return new _FilterClass({
       type: "compare",
       operator: "gte",
-      value
+      value: value2
     });
   }
-  static lt(value) {
+  static lt(value2) {
     return new _FilterClass({
       type: "compare",
       operator: "lt",
-      value
+      value: value2
     });
   }
-  static lte(value) {
+  static lte(value2) {
     return new _FilterClass({
       type: "compare",
       operator: "lte",
-      value
+      value: value2
     });
   }
   static in(...values) {
@@ -619,10 +239,10 @@ var FilterClass = class _FilterClass {
       values
     });
   }
-  static contains(value) {
+  static contains(value2) {
     return new _FilterClass({
       type: "contains",
-      value
+      value: value2
     });
   }
   static between(from, to) {
@@ -662,11 +282,11 @@ var Filter = FilterClass;
 var propsFilterToAst = (predicates) => {
   let idFilter;
   if ("id" in predicates) {
-    assertArgument3(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
+    assertArgument(typeof predicates.id === "string" || Array.isArray(predicates.id), "predicates.id", "invalid id filter");
     idFilter = typeof predicates.id === "string" ? [
       predicates.id
     ] : predicates.id;
-    Schema2.Array(ObjectId3).pipe(Schema2.validateSync)(idFilter);
+    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);
   }
   return {
     id: idFilter,
@@ -685,9 +305,9 @@ var processPredicate = (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, value]) => [
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key, value2]) => [
         key,
-        processPredicate(value)
+        processPredicate(value2)
       ]));
       return {
         type: "object",
@@ -695,12 +315,12 @@ var processPredicate = (predicate) => {
         props: nestedProps
       };
     }),
-    Match.orElse((value) => Filter.eq(value).ast)
+    Match.orElse((value2) => Filter.eq(value2).ast)
   );
 };
 var QueryClass = class _QueryClass {
-  static is(value) {
-    return typeof value === "object" && value !== null && "~Query" in value;
+  static is(value2) {
+    return typeof value2 === "object" && value2 !== null && "~Query" in value2;
   }
   static fromAst(ast) {
     return new _QueryClass(ast);
@@ -744,7 +364,7 @@ var QueryClass = class _QueryClass {
       return new _QueryClass({
         type: "filter",
         selection: this.ast,
-        filter: FilterClass._props(filter).ast
+        filter: FilterClass.props(filter).ast
       });
     }
   }
@@ -756,7 +376,7 @@ var QueryClass = class _QueryClass {
     });
   }
   referencedBy(target, key) {
-    const dxn = getTypeReference(target)?.toDXN() ?? raise2(new TypeError("Target schema has no DXN"));
+    const dxn = getTypeDXNFromSpecifier(target);
     return new _QueryClass({
       type: "incoming-references",
       anchor: this.ast,
@@ -817,23 +437,394 @@ var QueryClass = class _QueryClass {
 };
 _define_property(QueryClass, "variance", {});
 var Query = QueryClass;
+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);
+  }
+};
 var Order;
 
-// src/index.ts
-import { QueryAST } from "@dxos/echo-protocol";
+// src/query/tag.ts
+var tag_exports = {};
+__export(tag_exports, {
+  Tag: () => Tag,
+  createTagList: () => createTagList,
+  findTagByLabel: () => findTagByLabel,
+  make: () => make3,
+  sortTags: () => sortTags
+});
+import * as Schema3 from "effect/Schema";
+
+// src/Obj.ts
+var Obj_exports = {};
+__export(Obj_exports, {
+  Any: () => Any,
+  Meta: () => Meta,
+  VersionTypeId: () => VersionTypeId2,
+  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: () => getSnapshot2,
+  getTypeDXN: () => getTypeDXN,
+  getTypename: () => getTypename2,
+  instanceOf: () => instanceOf,
+  isDeleted: () => isDeleted2,
+  isObject: () => isObject,
+  isVersion: () => isVersion,
+  make: () => make2,
+  setDescription: () => setDescription2,
+  setLabel: () => setLabel2,
+  sort: () => sort,
+  sortByLabel: () => sortByLabel,
+  sortByTypename: () => sortByTypename,
+  toJSON: () => toJSON,
+  version: () => version,
+  versionValid: () => versionValid
+});
+import * as Function from "effect/Function";
+import * as Schema2 from "effect/Schema";
+import { assertArgument as assertArgument2, invariant as invariant2 } from "@dxos/invariant";
+import * as LiveObject from "@dxos/live-object";
+import { assumeType, deepMapValues } from "@dxos/util";
+
+// src/Type.ts
+var Type_exports = {};
+__export(Type_exports, {
+  DXN: () => DXN2,
+  Expando: () => Expando2,
+  Format: () => Format,
+  JsonSchema: () => JsonSchemaType,
+  Kind: () => Kind,
+  KindId: () => KindId,
+  Obj: () => Obj,
+  ObjectId: () => ObjectId2,
+  Ref: () => Ref2,
+  Relation: () => Relation,
+  SpaceId: () => SpaceId,
+  getDXN: () => getDXN,
+  getMeta: () => getMeta2,
+  getTypename: () => getTypename,
+  getVersion: () => getVersion,
+  isMutable: () => isMutable2,
+  toEffectSchema: () => toEffectSchema,
+  toJsonSchema: () => toJsonSchema
+});
+import { invariant } from "@dxos/invariant";
+import { SpaceId, ObjectId as ObjectId2, DXN as DXN2 } from "@dxos/keys";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Type.ts";
+var KindId = EntityKindId;
+var Kind = EntityKind;
+var Obj = EchoObject;
+var Expando2 = Expando;
+var Relation = EchoRelation;
+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: 211,
+    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: 221,
+    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 = Schema2.Struct({}).pipe(Obj({
+  typename: "dxos.org/types/Any",
+  version: "0.1.0"
+}));
+var Meta = MetaId;
+var DEFAULT_META = {
+  keys: []
+};
+var make2 = (schema, props, meta) => {
+  assertArgument2(getTypeAnnotation(schema)?.kind === EntityKind.Object, "schema", "Expected an object schema");
+  if (props[MetaId] != null) {
+    meta = {
+      ...structuredClone(DEFAULT_META),
+      ...props[MetaId]
+    };
+    delete props[MetaId];
+  }
+  const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== void 0));
+  return live(schema, filterUndefined, {
+    keys: [],
+    ...meta
+  });
+};
+var isObject = (obj) => {
+  assumeType(obj);
+  return typeof obj === "object" && obj !== null && obj[EntityKindId] === EntityKind.Object;
+};
+var instanceOf = (...args) => {
+  if (args.length === 1) {
+    return (obj) => isInstanceOf(args[0], obj);
+  }
+  return isInstanceOf(args[0], args[1]);
+};
+var getSchema2 = getSchema;
+var getDXN2 = (obj) => {
+  assertArgument2(!Schema2.isSchema(obj), "obj", "Object should not be a schema.");
+  const dxn = getObjectDXN(obj);
+  invariant2(dxn != null, "Invalid object.", {
+    F: __dxlog_file2,
+    L: 136,
+    S: void 0,
+    A: [
+      "dxn != null",
+      "'Invalid object.'"
+    ]
+  });
+  return dxn;
+};
+var getTypeDXN = getType;
+var getTypename2 = (obj) => {
+  const schema = getSchema2(obj);
+  if (schema == null) {
+    return getType(obj)?.asTypeDXN()?.type;
+  }
+  return getSchemaTypename(schema);
+};
+var getMeta3 = (obj) => {
+  const meta = getMeta(obj);
+  invariant2(meta != null, "Invalid object.", {
+    F: __dxlog_file2,
+    L: 164,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta;
+};
+var getKeys = Function.dual(2, (obj, source) => {
+  const meta = getMeta(obj);
+  invariant2(meta != null, "Invalid object.", {
+    F: __dxlog_file2,
+    L: 176,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta.keys.filter((key) => key.source === source);
+});
+var deleteKeys = (obj, source) => {
+  const meta = getMeta(obj);
+  for (let i = 0; i < meta.keys.length; i++) {
+    if (meta.keys[i].source === source) {
+      meta.keys.splice(i, 1);
+      i--;
+    }
+  }
+};
+var isDeleted2 = (obj) => {
+  const deleted = isDeleted(obj);
+  invariant2(typeof deleted === "boolean", "Invalid object.", {
+    F: __dxlog_file2,
+    L: 198,
+    S: void 0,
+    A: [
+      "typeof deleted === 'boolean'",
+      "'Invalid object.'"
+    ]
+  });
+  return deleted;
+};
+var getLabel2 = (obj) => {
+  const schema = getSchema2(obj);
+  if (schema != null) {
+    return getLabel(schema, obj);
+  }
+};
+var setLabel2 = (obj, label) => {
+  const schema = getSchema2(obj);
+  if (schema != null) {
+    setLabel(schema, obj, label);
+  }
+};
+var getDescription2 = (obj) => {
+  const schema = getSchema2(obj);
+  if (schema != null) {
+    return getDescription(schema, obj);
+  }
+};
+var setDescription2 = (obj, description) => {
+  const schema = getSchema2(obj);
+  if (schema != null) {
+    setDescription(schema, obj, description);
+  }
+};
+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 toJSON = (obj) => objectToJSON(obj);
+var fromJSON = objectFromJSON;
+var getSnapshot2 = LiveObject.getSnapshot;
+var clone = (obj, opts) => {
+  const { id, ...data } = obj;
+  const schema = getSchema2(obj);
+  invariant2(schema != null, "Object should have a schema", {
+    F: __dxlog_file2,
+    L: 305,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object should have a schema'"
+    ]
+  });
+  const props = deepMapValues(data, (value2, recurse) => {
+    if (Ref.isRef(value2)) {
+      return value2;
+    }
+    return recurse(value2);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = getMeta3(obj);
+  props[MetaId] = deepMapValues(meta, (value2, recurse) => {
+    if (Ref.isRef(value2)) {
+      return value2;
+    }
+    return recurse(value2);
+  });
+  return make2(schema, props);
+};
+var VersionTypeId2 = VersionTypeId;
+var unversioned = {
+  [VersionTypeId2]: {},
+  versioned: false
+};
+var isVersion = (obj) => {
+  return obj != null && typeof obj === "object" && VersionTypeId2 in obj;
+};
+var version = (obj) => {
+  const version2 = obj[ObjectVersionId];
+  if (version2 === void 0) {
+    return unversioned;
+  }
+  return version2;
+};
+var versionValid = (version2) => {
+  assertArgument2(isVersion(version2), "version", "Invalid version object");
+  return !!version2.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 = (version2) => {
+  return JSON.stringify(version2);
+};
+var decodeVersion = (version2) => {
+  const parsed = JSON.parse(version2);
+  parsed[VersionTypeId2] = {};
+  return parsed;
+};
+
+// src/query/tag.ts
+var Tag = Schema3.Struct({
+  label: Schema3.String,
+  hue: Schema3.optional(Schema3.String)
+}).pipe(Obj({
+  typename: "dxos.org/type/Tag",
+  version: "0.1.0"
+}), LabelAnnotation.set([
+  "label"
+]));
+var make3 = (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,
-  Key_exports,
-  Obj_exports,
   Ref_exports,
-  Relation_exports,
-  Type_exports,
   Filter,
   Query,
   Order,
-  DXN4 as DXN,
-  QueryAST
+  Relation,
+  Type_exports,
+  Any,
+  Obj_exports,
+  tag_exports
 };
-//# sourceMappingURL=chunk-TCY7IVTS.mjs.map
+//# sourceMappingURL=chunk-5NWDGIBT.mjs.map