@dxos/echo 0.8.4-main.c1de068 → 0.8.4-main.c4373fc

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

@@ -0,0 +1,514 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  EchoObject,
+  EchoRelation,
+  EntityKind,
+  EntityKindId,
+  Expando,
+  Format,
+  JsonSchemaType,
+  MetaId,
+  ObjectVersionId,
+  Ref,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  VersionTypeId,
+  __export,
+  getLabel,
+  getMeta,
+  getObjectDXN,
+  getSchema,
+  getSchemaDXN,
+  getSchemaTypename,
+  getSchemaVersion,
+  getType,
+  getTypeAnnotation,
+  isDeleted,
+  isInstanceOf,
+  isMutable,
+  live,
+  objectFromJSON,
+  objectToJSON,
+  setLabel,
+  toEffectSchema,
+  toJsonSchema
+} from "./chunk-YTNLFBIK.mjs";
+
+// 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/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, {
+  Any: () => Any,
+  Meta: () => Meta,
+  VersionTypeId: () => VersionTypeId2,
+  clone: () => clone,
+  compareVersions: () => compareVersions,
+  decodeVersion: () => decodeVersion,
+  deleteKeys: () => deleteKeys,
+  encodeVersion: () => encodeVersion,
+  fromJSON: () => fromJSON,
+  getDXN: () => getDXN2,
+  getKeys: () => getKeys,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta3,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot2,
+  getTypeDXN: () => getTypeDXN,
+  getTypename: () => getTypename2,
+  instanceOf: () => instanceOf,
+  isDeleted: () => isDeleted2,
+  isObject: () => isObject,
+  isVersion: () => isVersion,
+  make: () => make,
+  setLabel: () => setLabel2,
+  sort: () => sort,
+  sortByLabel: () => sortByLabel,
+  sortByTypename: () => sortByTypename,
+  toJSON: () => toJSON,
+  version: () => version,
+  versionValid: () => versionValid
+});
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import { assertArgument, 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: () => DXN,
+  Expando: () => Expando2,
+  Format: () => Format,
+  JsonSchema: () => JsonSchemaType,
+  Kind: () => Kind,
+  KindId: () => KindId,
+  Obj: () => Obj,
+  ObjectId: () => ObjectId2,
+  Ref: () => Ref2,
+  Relation: () => Relation,
+  SpaceId: () => SpaceId2,
+  getDXN: () => getDXN,
+  getMeta: () => getMeta2,
+  getTypename: () => getTypename,
+  getVersion: () => getVersion,
+  isMutable: () => isMutable2,
+  toEffectSchema: () => toEffectSchema,
+  toJsonSchema: () => toJsonSchema
+});
+import { invariant } from "@dxos/invariant";
+import { SpaceId as SpaceId2, ObjectId as ObjectId2, DXN } 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 = Schema.Struct({}).pipe(Obj({
+  typename: "dxos.org/types/Any",
+  version: "0.1.0"
+}));
+var Meta = MetaId;
+var DEFAULT_META = {
+  keys: []
+};
+var make = (schema, props, meta) => {
+  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Object, "schema", "Expected an object schema");
+  if (props[MetaId] != null) {
+    meta = {
+      ...structuredClone(DEFAULT_META),
+      ...props[MetaId]
+    };
+    delete props[MetaId];
+  }
+  return live(schema, props, {
+    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) => {
+  assertArgument(!Schema.isSchema(obj), "obj", "Object should not be a schema.");
+  const dxn = getObjectDXN(obj);
+  invariant2(dxn != null, "Invalid object.", {
+    F: __dxlog_file2,
+    L: 123,
+    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: 151,
+    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: 163,
+    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: 185,
+    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 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: 278,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object should have a schema'"
+    ]
+  });
+  const props = deepMapValues(data, (value, recurse) => {
+    if (Ref.isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = getMeta3(obj);
+  props[MetaId] = deepMapValues(meta, (value, recurse) => {
+    if (Ref.isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  return make(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) => {
+  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/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: () => make2
+});
+import * as Schema2 from "effect/Schema";
+import { raise } from "@dxos/debug";
+import { assertArgument as assertArgument2, invariant as invariant3 } from "@dxos/invariant";
+import { DXN as DXN2 } 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 = Schema2.Struct({}).pipe(Relation({
+  typename: "dxos.org/types/Any",
+  version: "0.1.0",
+  source: Any,
+  target: Any
+}));
+var Source = RelationSourceId;
+var Target = RelationTargetId;
+var make2 = (schema, props, meta) => {
+  assertArgument2(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]) ?? raise(new Error("Unresolved relation source"));
+  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error("Unresolved relation target"));
+  props[RelationSourceDXNId] = sourceDXN;
+  props[RelationTargetDXNId] = targetDXN;
+  return live(schema, props, meta);
+};
+var isRelation = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {
+    return true;
+  }
+  const kind = value[EntityKindId];
+  return kind === EntityKind.Relation;
+};
+var getSourceDXN = (value) => {
+  assertArgument2(isRelation(value), "Expected a relation");
+  assumeType2(value);
+  const dxn = value[RelationSourceDXNId];
+  invariant3(dxn instanceof DXN2, void 0, {
+    F: __dxlog_file3,
+    L: 110,
+    S: void 0,
+    A: [
+      "dxn instanceof DXN",
+      ""
+    ]
+  });
+  return dxn;
+};
+var getTargetDXN = (value) => {
+  assertArgument2(isRelation(value), "Expected a relation");
+  assumeType2(value);
+  const dxn = value[RelationTargetDXNId];
+  invariant3(dxn instanceof DXN2, void 0, {
+    F: __dxlog_file3,
+    L: 122,
+    S: void 0,
+    A: [
+      "dxn instanceof DXN",
+      ""
+    ]
+  });
+  return dxn;
+};
+var getSource = (relation) => {
+  assertArgument2(isRelation(relation), "Expected a relation");
+  assumeType2(relation);
+  const obj = relation[RelationSourceId];
+  invariant3(obj !== void 0, `Invalid source: ${relation.id}`, {
+    F: __dxlog_file3,
+    L: 134,
+    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[RelationTargetId];
+  invariant3(obj !== void 0, `Invalid target: ${relation.id}`, {
+    F: __dxlog_file3,
+    L: 146,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid target: ${relation.id}`"
+    ]
+  });
+  return obj;
+};
+
+// src/index.ts
+import { QueryAST } from "@dxos/echo-protocol";
+import { DXN as DXN3 } from "@dxos/keys";
+
+export {
+  SchemaNotFoundError,
+  ObjectNotFoundError,
+  Key_exports,
+  Type_exports,
+  Obj_exports,
+  Relation_exports,
+  QueryAST,
+  DXN3 as DXN
+};
+//# sourceMappingURL=chunk-L4PBAJDP.mjs.map

package/dist/lib/node-esm/chunk-L4PBAJDP.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors.ts", "../../../src/Key.ts", "../../../src/Obj.ts", "../../../src/Type.ts", "../../../src/Relation.ts", "../../../src/index.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\nimport { type DXN } from '@dxos/keys';\n\nexport class SchemaNotFoundError extends BaseError.extend('SCHEMA_NOT_FOUND', 'Schema not found') {\n  constructor(schema: string, options?: BaseErrorOptions) {\n    super({ context: { schema }, ...options });\n  }\n}\n\nexport class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND', 'Object not found') {\n  constructor(dxn: DXN, options?: BaseErrorOptions) {\n    super({ context: { dxn }, ...options });\n  }\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nexport { SpaceId, ObjectId } from '@dxos/keys';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Schema from 'effect/Schema';\n\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { type DXN } from '@dxos/keys';\nimport * as LiveObject from '@dxos/live-object';\nimport { assumeType, deepMapValues } from '@dxos/util';\n\nimport { live } from './internal';\nimport * as EchoSchema from './internal';\nimport type * as Ref from './Ref';\nimport type * as Relation from './Relation';\nimport * as Type from './Type';\n\n/**\n * NOTE: Don't export: Obj.Any and Obj.Obj form the public API.\n */\ninterface BaseObj extends EchoSchema.HasId, Type.OfKind<EchoSchema.EntityKind.Object> {}\n\n/**\n * Object type with specific properties.\n */\nexport type Obj<Props> = BaseObj & Props;\n\n/**\n * Base type for all ECHO objects.\n */\nexport interface Any extends BaseObj {}\n\nexport const Any = Schema.Struct({}).pipe(\n  Type.Obj({\n    typename: 'dxos.org/types/Any',\n    version: '0.1.0',\n  }),\n);\n\ntype Props<T = any> = { id?: EchoSchema.ObjectId } & Type.Properties<T>;\n\nexport type MakeProps<T extends Type.Obj.Any> = NoInfer<Props<Schema.Schema.Type<T>>> & {\n  [Meta]?: Partial<EchoSchema.ObjectMeta>;\n};\n\nexport const Meta: unique symbol = EchoSchema.MetaId as any;\n\nconst DEFAULT_META: EchoSchema.ObjectMeta = {\n  keys: [],\n};\n\n/**\n * Creates new object.\n * @param schema - Object schema.\n * @param props - Object properties.\n * @param meta - Object metadata (deprecated) -- pass with Obj.Meta.\n *\n * Meta can be passed as a symbol in `props`.\n *\n * Example:\n * ```ts\n * const obj = Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' });\n * ```\n */\nexport const make = <S extends Type.Obj.Any>(\n  schema: S,\n  props: MakeProps<S>,\n  meta?: Partial<EchoSchema.ObjectMeta>,\n): LiveObject.Live<Schema.Schema.Type<S>> => {\n  assertArgument(\n    EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Object,\n    'schema',\n    'Expected an object schema',\n  );\n\n  if (props[EchoSchema.MetaId] != null) {\n    // Set default fields on meta on creation.\n    meta = { ...structuredClone(DEFAULT_META), ...props[EchoSchema.MetaId] };\n    delete props[EchoSchema.MetaId];\n  }\n\n  return live<Schema.Schema.Type<S>>(schema, props as any, { keys: [], ...meta });\n};\n\nexport const isObject = (obj: unknown): obj is Any => {\n  assumeType<EchoSchema.InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && obj[EchoSchema.EntityKindId] === EchoSchema.EntityKind.Object;\n};\n\n/**\n * Test if object or relation is an instance of a schema.\n * @example\n * ```ts\n * const john = Obj.make(Person, { name: 'John' });\n * const johnIsPerson = Obj.instanceOf(Person)(john);\n *\n * const isPerson = Obj.instanceOf(Person);\n * if (isPerson(john)) {\n *   // john is Person\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.Relation.Any | Type.Obj.Any>(schema: S): (value: unknown) => value is Schema.Schema.Type<S>;\n  <S extends Type.Relation.Any | Type.Obj.Any>(schema: S, value: unknown): value is Schema.Schema.Type<S>;\n} = ((\n  ...args: [schema: Type.Relation.Any | Type.Obj.Any, value: unknown] | [schema: Type.Relation.Any | Type.Obj.Any]\n) => {\n  if (args.length === 1) {\n    return (obj: unknown) => EchoSchema.isInstanceOf(args[0], obj);\n  }\n\n  return EchoSchema.isInstanceOf(args[0], args[1]);\n}) as any;\n\nexport const getSchema = EchoSchema.getSchema;\n\n// TODO(dmaretskyi): Allow returning undefined.\nexport const getDXN = (obj: Any | Relation.Any): DXN => {\n  assertArgument(!Schema.isSchema(obj), 'obj', 'Object should not be a schema.');\n  const dxn = EchoSchema.getObjectDXN(obj);\n  invariant(dxn != null, 'Invalid object.');\n  return dxn;\n};\n\n/**\n * @returns The DXN of the object's type.\n * @example dxn:example.com/type/Contact:1.0.0\n */\n// TODO(burdon): Expando does not have a type.\nexport const getTypeDXN = EchoSchema.getType;\n\n/**\n * @returns The typename of the object's type.\n * @example `example.com/type/Contact`\n */\nexport const getTypename = (obj: Any | Relation.Any): string | undefined => {\n  const schema = getSchema(obj);\n  if (schema == null) {\n    // Try to extract typename from DXN.\n    return EchoSchema.getType(obj)?.asTypeDXN()?.type;\n  }\n\n  return EchoSchema.getSchemaTypename(schema);\n};\n\n// TODO(dmaretskyi): Allow returning undefined.\nexport const getMeta = (obj: Any | Relation.Any): EchoSchema.ObjectMeta => {\n  const meta = EchoSchema.getMeta(obj);\n  invariant(meta != null, 'Invalid object.');\n  return meta;\n};\n\n/**\n * @returns Foreign keys for the object from the specified source.\n */\nexport const getKeys: {\n  (obj: Any | Relation.Any, source: string): EchoSchema.ForeignKey[];\n  (source: string): (obj: Any | Relation.Any) => EchoSchema.ForeignKey[];\n} = Function.dual(2, (obj: Any | Relation.Any, source?: string): EchoSchema.ForeignKey[] => {\n  const meta = EchoSchema.getMeta(obj);\n  invariant(meta != null, 'Invalid object.');\n  return meta.keys.filter((key) => key.source === source);\n});\n\n/**\n * Delete all keys from the object for the specified source.\n * @param obj\n * @param source\n */\nexport const deleteKeys = (obj: Any | Relation.Any, source: string) => {\n  const meta = EchoSchema.getMeta(obj);\n  for (let i = 0; i < meta.keys.length; i++) {\n    if (meta.keys[i].source === source) {\n      meta.keys.splice(i, 1);\n      i--;\n    }\n  }\n};\n\n// TODO(dmaretskyi): Default to `false`.\nexport const isDeleted = (obj: Any | Relation.Any): boolean => {\n  const deleted = EchoSchema.isDeleted(obj);\n  invariant(typeof deleted === 'boolean', 'Invalid object.');\n  return deleted;\n};\n\nexport const getLabel = (obj: Any | Relation.Any): string | undefined => {\n  const schema = getSchema(obj);\n  if (schema != null) {\n    return EchoSchema.getLabel(schema, obj);\n  }\n};\n\nexport const setLabel = (obj: Any | Relation.Any, label: string) => {\n  const schema = getSchema(obj);\n  if (schema != null) {\n    EchoSchema.setLabel(schema, obj, label);\n  }\n};\n\nconst compare = (a?: string, b?: string) => {\n  if (a == null) {\n    return b == null ? 0 : 1;\n  }\n\n  if (b == null) {\n    return -1;\n  }\n\n  return a.localeCompare(b);\n};\n\nexport type Comparator = (a: Any, b: Any) => number;\n\nexport const sortByLabel: Comparator = (a: Any, b: Any) => compare(getLabel(a), getLabel(b));\nexport const sortByTypename: Comparator = (a: Any, b: Any) => compare(getTypename(a), getTypename(b));\nexport const sort = (...comparators: Comparator[]): Comparator => {\n  return (a: Any, b: Any) => {\n    for (const comparator of comparators) {\n      const result = comparator(a, b);\n      if (result !== 0) {\n        return result;\n      }\n    }\n\n    return 0;\n  };\n};\n\n/**\n * JSON representation of an object.\n */\nexport type JSON = EchoSchema.ObjectJSON;\n\n/**\n * Converts object to its JSON representation.\n *\n * The same algorithm is used when calling the standard `JSON.stringify(obj)` function.\n */\n// TODO(burdon): Base util type for Obj/Relation?\nexport const toJSON = (obj: Any | Relation.Any): JSON => EchoSchema.objectToJSON(obj);\n\n/**\n * Creates an object from its json representation, performing schema validation.\n * References and schemas will be resolvable if the `refResolver` is provided.\n *\n * The function need to be async to support resolving the schema as well as the relation endpoints.\n *\n * @param options.refResolver - Resolver for references. Produces hydrated references that can be resolved.\n * @param options.dxn - Override object DXN. Changes the result of `Obj.getDXN`.\n */\nexport const fromJSON: (json: unknown, options?: { refResolver?: Ref.Resolver; dxn?: DXN }) => Promise<Any> =\n  EchoSchema.objectFromJSON as any;\n\n/**\n * Returns an immutable snapshot of an object.\n */\nexport const getSnapshot: <T extends Any>(obj: Obj<T>) => T = LiveObject.getSnapshot;\n\nexport type CloneOptions = {\n  /**\n   * Retain the original object's ID.\n   * @default false\n   */\n  retainId?: boolean;\n};\n\n/**\n * Clones an object or relation.\n * This does not clone referenced objects, only the properties in the object.\n * @returns A new object with the same schema and properties.\n */\nexport const clone = <T extends Any | Relation.Any>(obj: T, opts?: CloneOptions): T => {\n  const { id, ...data } = obj;\n  const schema = getSchema(obj);\n  invariant(schema != null, 'Object should have a schema');\n  const props: any = deepMapValues(data, (value, recurse) => {\n    if (EchoSchema.Ref.isRef(value)) {\n      return value;\n    }\n    return recurse(value);\n  });\n  if (opts?.retainId) {\n    props.id = id;\n  }\n  const meta = getMeta(obj);\n  props[EchoSchema.MetaId] = deepMapValues(meta, (value, recurse) => {\n    if (EchoSchema.Ref.isRef(value)) {\n      return value;\n    }\n    return recurse(value);\n  });\n  return make(schema, props);\n};\n\nexport const VersionTypeId = EchoSchema.VersionTypeId;\nexport type VersionType = typeof VersionTypeId;\n\n/**\n * Represent object version.\n * May be backed by Automerge.\n * Objects with no history are not versioned.\n */\nexport interface Version {\n  [VersionTypeId]: {};\n\n  /**\n   * Whether the object is versioned.\n   */\n  versioned: boolean;\n\n  /**\n   * Automerge heads.\n   */\n  automergeHeads?: string[];\n}\n\nconst unversioned: Version = {\n  [VersionTypeId]: {},\n  versioned: false,\n};\n\n/**\n * Checks that `obj` is a version object.\n */\nexport const isVersion = (obj: unknown): obj is Version => {\n  return obj != null && typeof obj === 'object' && VersionTypeId in obj;\n};\n\n/**\n * Returns the version of the object.\n */\nexport const version = (obj: Any | Relation.Any): Version => {\n  const version = (obj as any)[EchoSchema.ObjectVersionId];\n  if (version === undefined) {\n    return unversioned;\n  }\n  return version;\n};\n\n/**\n * Checks that `version` is a valid version object.\n */\nexport const versionValid = (version: Version): boolean => {\n  assertArgument(isVersion(version), 'version', 'Invalid version object');\n  return !!version.versioned;\n};\n\nexport type VersionCompareResult = 'unversioned' | 'equal' | 'different';\n\n/**\n * Compares two versions.\n * @param version1\n * @param version2\n * @returns 'unversioned' if either object is unversioned, 'equal' if the versions are equal, 'different' if the versions are different.\n */\nexport const compareVersions = (version1: Version, version2: Version): VersionCompareResult => {\n  assertArgument(isVersion(version1), 'version1', 'Invalid version object');\n  assertArgument(isVersion(version2), 'version2', 'Invalid version object');\n\n  if (!versionValid(version1) || !versionValid(version2)) {\n    return 'unversioned';\n  }\n\n  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {\n    return 'different';\n  }\n  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {\n    return 'different';\n  }\n\n  return 'equal';\n};\n\nexport const encodeVersion = (version: Version): string => {\n  return JSON.stringify(version);\n};\n\nexport const decodeVersion = (version: string): Version => {\n  const parsed = JSON.parse(version);\n  parsed[VersionTypeId] = {};\n  return parsed;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as EffectSchema from 'effect/Schema';\n\nimport { type EncodedReference } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport type * as Keys from '@dxos/keys';\n\nimport { type ToMutable } from './internal';\nimport * as EchoSchema from './internal';\nimport type * as RelationModule from './Relation';\n\n//\n// Kind\n//\n\nexport const KindId: unique symbol = EchoSchema.EntityKindId as any;\nexport type KindId = typeof KindId;\n\nexport const Kind = EchoSchema.EntityKind;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n */\n// NOTE: Needed to make `isRelation` and `isObject` checks work.\nexport interface OfKind<Kind extends EchoSchema.EntityKind> {\n  readonly id: Keys.ObjectId;\n  readonly [KindId]: Kind;\n}\n\n/**\n * Base ECHO schema type.\n */\nexport type Schema = EchoSchema.EchoSchema;\n\n/**\n * Returns all properties of an object or relation except for the id and kind.\n */\nexport type Properties<T = any> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;\n\n//\n// Obj\n//\n\ninterface ObjJsonProps {\n  id: string;\n}\n\n/**\n * Return type of the `Obj` schema constructor.\n *\n * This typedef avoids `TS4023` error (name from external module cannot be used named).\n * See Effect's note on interface types.\n */\nexport interface obj<Self extends EffectSchema.Schema.Any>\n  extends EchoSchema.TypeMeta,\n    EffectSchema.AnnotableClass<\n      obj<Self>,\n      OfKind<EchoSchema.EntityKind.Object> & ToMutable<EffectSchema.Schema.Type<Self>>,\n      EffectSchema.Simplify<ObjJsonProps & ToMutable<EffectSchema.Schema.Encoded<Self>>>,\n      EffectSchema.Schema.Context<Self>\n    > {}\n\n/**\n * Object schema.\n */\nexport const Obj: {\n  (opts: EchoSchema.TypeMeta): <Self extends EffectSchema.Schema.Any>(self: Self) => obj<Self>;\n} = EchoSchema.EchoObject as any;\n\n/**\n * Object schema type definitions.\n */\nexport declare namespace Obj {\n  /**\n   * Type that represents an arbitrary schema type of an object.\n   * NOTE: This is not an instance type.\n   */\n  // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.\n  // TODO(burdon): This erases the ECHO type info (e.g., id, typename).\n  export type Any = EffectSchema.Schema.AnyNoContext;\n}\n\n//\n// Expando\n//\n\n// TODO(burdon): We're using Expando in many places as a base type.\nexport interface Expando extends OfKind<EchoSchema.EntityKind.Object> {\n  [key: string]: any;\n}\n\ntype ExpandoEncoded = EffectSchema.Simplify<ObjJsonProps & { [key: string]: any }>;\n\nexport const Expando: EffectSchema.Schema<Expando, ExpandoEncoded, never> = EchoSchema.Expando as any;\n\n//\n// Relation\n//\n\ninterface RelationJsonProps {\n  id: string;\n  [EchoSchema.ATTR_RELATION_SOURCE]: string;\n  [EchoSchema.ATTR_RELATION_TARGET]: string;\n}\n\n/**\n * Return type of the `Relation` schema constructor.\n *\n * This typedef avoids `TS4023` error (name from external module cannot be used named).\n * See Effect's note on interface types.\n */\nexport interface relation<\n  Self extends EffectSchema.Schema.Any,\n  SourceSchema extends EffectSchema.Schema.Any,\n  TargetSchema extends EffectSchema.Schema.Any,\n> extends EchoSchema.TypeMeta,\n    EffectSchema.AnnotableClass<\n      relation<Self, SourceSchema, TargetSchema>,\n      OfKind<EchoSchema.EntityKind.Relation> &\n        Relation.Endpoints<EffectSchema.Schema.Type<SourceSchema>, EffectSchema.Schema.Type<TargetSchema>> &\n        ToMutable<EffectSchema.Schema.Type<Self>>,\n      EffectSchema.Simplify<RelationJsonProps & ToMutable<EffectSchema.Schema.Encoded<Self>>>,\n      EffectSchema.Schema.Context<Self>\n    > {}\n\n/**\n * Relation schema.\n */\n// TODO(dmaretskyi): I have to redefine the type here so that the definition uses symbols from @dxos/echo/Relation.\nexport const Relation: {\n  <Source extends EffectSchema.Schema.AnyNoContext, Target extends EffectSchema.Schema.AnyNoContext>(\n    opts: EchoSchema.EchoRelationOptions<Source, Target>,\n  ): <Self extends EffectSchema.Schema.Any>(self: Self) => relation<Self, Source, Target>;\n} = EchoSchema.EchoRelation as any;\n\n/**\n * Relation schema type definitions.\n */\nexport namespace Relation {\n  /**\n   * Type that represents an arbitrary schema type of a relation.\n   * NOTE: This is not an instance type.\n   */\n  // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.\n  export type Any = EffectSchema.Schema.AnyNoContext;\n\n  /**\n   * Get relation source type.\n   */\n  export type Source<A> = A extends Relation.Endpoints<infer S, infer _T> ? S : never;\n\n  /**\n   * Get relation target type.\n   */\n  export type Target<A> = A extends Relation.Endpoints<infer _S, infer T> ? T : never;\n\n  export type Endpoints<Source, Target> = {\n    [RelationModule.Source]: Source;\n    [RelationModule.Target]: Target;\n  };\n}\n\n//\n// Ref\n//\n\n/**\n * Return type of the `Ref` schema constructor.\n *\n * This typedef avoids `TS4023` error (name from external module cannot be used named).\n * See Effect's note on interface types.\n */\nexport interface ref<TargetSchema extends EffectSchema.Schema.Any>\n  extends EchoSchema.Ref$<EffectSchema.Schema.Type<TargetSchema>> {}\n\n/**\n * Ref schema.\n */\nexport const Ref: <S extends Obj.Any>(schema: S) => ref<S> = EchoSchema.Ref;\n\nexport interface Ref<T> extends EffectSchema.SchemaClass<EchoSchema.Ref<T>, EncodedReference> {}\n\n// TODO(buurdon): Move to Ref?\nexport namespace Ref {\n  /**\n   * Type that represents an arbitrary schema type of a reference.\n   * NOTE: This is not an instance type.\n   */\n  export type Any = EffectSchema.Schema<EchoSchema.Ref<any>, EncodedReference>;\n}\n\n/**\n * Gets the full DXN of the schema.\n * Will include the version if it's a `type` DXN.\n * @example \"dxn:example.com/type/Person:0.1.0\"\n * @example \"dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX\"\n */\nexport const getDXN = (schema: Obj.Any | Relation.Any): Keys.DXN | undefined => {\n  return EchoSchema.getSchemaDXN(schema);\n};\n\n/**\n * @param schema - Schema to get the typename from.\n * @returns The typename of the schema. Example: `example.com/type/Person`.\n */\nexport const getTypename = (schema: Obj.Any | Relation.Any): string => {\n  const typename = EchoSchema.getSchemaTypename(schema);\n  invariant(typeof typename === 'string' && !typename.startsWith('dxn:'), 'Invalid typename');\n  return typename;\n};\n\n/**\n * Gets the version of the schema.\n * @example 0.1.0\n */\nexport const getVersion = (schema: Obj.Any | Relation.Any): string => {\n  const version = EchoSchema.getSchemaVersion(schema);\n  invariant(typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/), 'Invalid version');\n  return version;\n};\n\n/**\n * @returns True if the schema is mutable.\n */\nexport const isMutable = EchoSchema.isMutable;\n\n/**\n * ECHO type metadata.\n */\nexport type Meta = EchoSchema.TypeAnnotation;\n\n/**\n * Gets the meta data of the schema.\n */\nexport const getMeta = (schema: Obj.Any | Relation.Any): Meta | undefined => {\n  return EchoSchema.getTypeAnnotation(schema);\n};\n\n// TODO(dmaretskyi): Remove re-exports.\nexport { SpaceId, ObjectId, DXN } from '@dxos/keys';\n\nexport { Format, JsonSchemaType as JsonSchema, toEffectSchema, toJsonSchema } from './internal';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Live } from '@dxos/live-object';\nimport { assumeType } from '@dxos/util';\n\nimport { live } from './internal';\nimport * as EchoSchema from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\n/**\n * NOTE: Don't export: Relation.Relation and Relation.Any form the public API.\n */\ninterface BaseRelation<Source, Target>\n  extends EchoSchema.HasId,\n    Type.Relation.Endpoints<Source, Target>,\n    Type.OfKind<EchoSchema.EntityKind.Relation> {}\n\n/**\n * Relation type with specific properties.\n */\nexport type Relation<Source extends Obj.Any, Target extends Obj.Any, Props> = BaseRelation<Source, Target> & Props;\n\n/**\n * Base type for all ECHO relations.\n */\nexport interface Any extends BaseRelation<Obj.Any, Obj.Any> {}\n\nexport const Any = Schema.Struct({}).pipe(\n  Type.Relation({\n    typename: 'dxos.org/types/Any',\n    version: '0.1.0',\n    source: Obj.Any,\n    target: Obj.Any,\n  }),\n);\n\n// TODO(dmaretskyi): Has to be `unique symbol`.\nexport const Source: unique symbol = EchoSchema.RelationSourceId as any;\nexport type Source = typeof Source;\nexport const Target: unique symbol = EchoSchema.RelationTargetId as any;\nexport type Target = typeof Target;\n\ntype MakeProps<T extends Any> = {\n  id?: EchoSchema.ObjectId;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Type.Properties<T>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata.\n * @returns\n */\n// NOTE: Writing the definition this way (with generic over schema) makes typescript perfer to infer the type from the first param (this schema) rather than the second param (the props).\n// TODO(dmaretskyi): Move meta into props.\nexport const make = <S extends Type.Relation.Any>(\n  schema: S,\n  props: NoInfer<MakeProps<Schema.Schema.Type<S>>>,\n  meta?: EchoSchema.ObjectMeta,\n): Live<Schema.Schema.Type<S> & Type.OfKind<EchoSchema.EntityKind.Relation>> => {\n  assertArgument(\n    EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Relation,\n    'schema',\n    'Expected a relation schema',\n  );\n\n  if (props[EchoSchema.MetaId] != null) {\n    meta = props[EchoSchema.MetaId] as any;\n    delete props[EchoSchema.MetaId];\n  }\n\n  const sourceDXN = EchoSchema.getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = EchoSchema.getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n  (props as any)[EchoSchema.RelationSourceDXNId] = sourceDXN;\n  (props as any)[EchoSchema.RelationTargetDXNId] = targetDXN;\n\n  return live<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\nexport const isRelation = (value: unknown): value is Any => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (EchoSchema.ATTR_RELATION_SOURCE in value || EchoSchema.ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  const kind = (value as any)[EchoSchema.EntityKindId];\n  return kind === EchoSchema.EntityKind.Relation;\n};\n\n/**\n * @returns Relation source DXN.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Any): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(value);\n  const dxn = (value as EchoSchema.InternalObjectProps)[EchoSchema.RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Any): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(value);\n  const dxn = (value as EchoSchema.InternalObjectProps)[EchoSchema.RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Any>(relation: T): Type.Relation.Source<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(relation);\n  const obj = (relation as EchoSchema.InternalObjectProps)[EchoSchema.RelationSourceId];\n  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\n  return obj as Type.Relation.Source<T>;\n};\n\n/**\n * @returns Relation target.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Any>(relation: T): Type.Relation.Target<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<EchoSchema.InternalObjectProps>(relation);\n  const obj = (relation as EchoSchema.InternalObjectProps)[EchoSchema.RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as Type.Relation.Target<T>;\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nexport * from './errors';\nexport * from './query';\n\nexport * as Key from './Key';\nexport * as Obj from './Obj';\nexport * as Ref from './Ref';\nexport * as Relation from './Relation';\nexport * as Type from './Type';\n\nexport { QueryAST } from '@dxos/echo-protocol';\nexport { DXN } from '@dxos/keys';\nexport { type Live } from '@dxos/live-object';\n"],
+  "mappings": "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",
+  "names": ["BaseError", "SchemaNotFoundError", "BaseError", "extend", "schema", "options", "context", "ObjectNotFoundError", "dxn", "SpaceId", "ObjectId", "VersionTypeId", "getDXN", "getLabel", "getMeta", "getSchema", "getSnapshot", "getTypename", "isDeleted", "setLabel", "Function", "Schema", "assertArgument", "invariant", "LiveObject", "assumeType", "deepMapValues", "Expando", "ObjectId", "Ref", "SpaceId", "getMeta", "isMutable", "invariant", "SpaceId", "ObjectId", "DXN", "KindId", "EntityKindId", "Kind", "EntityKind", "Obj", "EchoObject", "Expando", "Relation", "EchoRelation", "Ref", "getDXN", "schema", "getSchemaDXN", "getTypename", "typename", "getSchemaTypename", "invariant", "startsWith", "getVersion", "version", "getSchemaVersion", "match", "isMutable", "getMeta", "getTypeAnnotation", "Any", "Struct", "pipe", "Obj", "typename", "version", "Meta", "MetaId", "DEFAULT_META", "keys", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "Object", "structuredClone", "live", "isObject", "obj", "assumeType", "EntityKindId", "instanceOf", "args", "length", "isInstanceOf", "getSchema", "getDXN", "isSchema", "dxn", "getObjectDXN", "invariant", "getTypeDXN", "getType", "getTypename", "asTypeDXN", "type", "getSchemaTypename", "getMeta", "getKeys", "dual", "source", "filter", "key", "deleteKeys", "i", "splice", "isDeleted", "deleted", "getLabel", "setLabel", "label", "EchoSchema", "compare", "a", "b", "localeCompare", "sortByLabel", "sortByTypename", "sort", "comparators", "comparator", "result", "toJSON", "objectToJSON", "fromJSON", "objectFromJSON", "getSnapshot", "clone", "opts", "id", "data", "deepMapValues", "value", "recurse", "Ref", "isRef", "retainId", "VersionTypeId", "unversioned", "versioned", "isVersion", "ObjectVersionId", "undefined", "versionValid", "compareVersions", "version1", "version2", "automergeHeads", "some", "head", "includes", "encodeVersion", "JSON", "stringify", "decodeVersion", "parsed", "parse", "Any", "make", "Schema", "raise", "assertArgument", "invariant", "DXN", "assumeType", "Any", "Struct", "pipe", "Relation", "typename", "version", "source", "target", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "live", "isRelation", "value", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "EntityKindId", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "undefined", "id", "getTarget", "QueryAST", "DXN"]
+}