@dxos/echo 0.8.4-main.3a94e84 → 0.8.4-main.3c1ae3b

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

@@ -0,0 +1,363 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Obj
+} from "./chunk-FWTPV5QD.mjs";
+import {
+  isRef
+} from "./chunk-W3OLV7MG.mjs";
+import {
+  Kind
+} from "./chunk-5M5P2DCR.mjs";
+import {
+  MetaId,
+  ObjectVersionId,
+  VersionTypeId,
+  getMeta,
+  getObjectDXN,
+  isDeleted,
+  makeObject,
+  objectFromJSON,
+  objectToJSON
+} from "./chunk-DJX53IQ3.mjs";
+import {
+  getDescription,
+  getLabel,
+  getSchema,
+  getSchemaTypename,
+  getTypeAnnotation,
+  getTypeDXN,
+  isInstanceOf,
+  setDescription,
+  setLabel
+} from "./chunk-6OTQZKHX.mjs";
+import {
+  KindId
+} from "./chunk-NHYOREKX.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// 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: () => getDXN,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta2,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename,
+  instanceOf: () => instanceOf,
+  isDeleted: () => isDeleted2,
+  isObject: () => isObject,
+  isVersion: () => isVersion,
+  make: () => make,
+  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 Schema from "effect/Schema";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { ObjectId } from "@dxos/keys";
+import { getSnapshot as getSnapshot$ } from "@dxos/live-object";
+import { assumeType, deepMapValues } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
+var Any = Schema.Struct({}).pipe(Obj({
+  typename: "dxos.org/type/Any",
+  version: "0.1.0"
+}));
+var defaultMeta = {
+  keys: []
+};
+var make = (schema, props, meta) => {
+  assertArgument(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);
+  invariant(schema != null, "Object should have a schema", {
+    F: __dxlog_file,
+    L: 157,
+    S: void 0,
+    A: [
+      "schema != null",
+      "'Object should have a schema'"
+    ]
+  });
+  const props = deepMapValues(data, (value, recurse) => {
+    if (isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = getMeta2(obj);
+  props[MetaId] = deepMapValues(meta, (value, recurse) => {
+    if (isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  return make(schema, props);
+};
+var ID = ObjectId;
+var instanceOf = (...args) => {
+  if (args.length === 1) {
+    return (entity) => isInstanceOf(args[0], entity);
+  }
+  return isInstanceOf(args[0], args[1]);
+};
+var getDXN = (entity) => {
+  assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
+  const dxn = getObjectDXN(entity);
+  invariant(dxn != null, "Invalid object.", {
+    F: __dxlog_file,
+    L: 213,
+    S: void 0,
+    A: [
+      "dxn != null",
+      "'Invalid object.'"
+    ]
+  });
+  return dxn;
+};
+var getTypeDXN2 = getTypeDXN;
+var getSchema2 = getSchema;
+var getTypename = (entity) => {
+  const schema = getSchema(entity);
+  if (schema == null) {
+    return getTypeDXN(entity)?.asTypeDXN()?.type;
+  }
+  return getSchemaTypename(schema);
+};
+var Meta = MetaId;
+var getMeta2 = (entity) => {
+  const meta = getMeta(entity);
+  invariant(meta != null, "Invalid object.", {
+    F: __dxlog_file,
+    L: 253,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta;
+};
+var getKeys = Function.dual(2, (entity, source) => {
+  const meta = getMeta2(entity);
+  invariant(meta != null, "Invalid object.", {
+    F: __dxlog_file,
+    L: 265,
+    S: void 0,
+    A: [
+      "meta != null",
+      "'Invalid object.'"
+    ]
+  });
+  return meta.keys.filter((key) => key.source === source);
+});
+var deleteKeys = (entity, source) => {
+  const meta = getMeta2(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 = getMeta2(entity);
+  meta.tags ??= [];
+  meta.tags.push(tag);
+};
+var removeTag = (entity, tag) => {
+  const meta = getMeta2(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);
+  invariant(typeof deleted === "boolean", "Invalid object.", {
+    F: __dxlog_file,
+    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(getTypename(a), getTypename(b));
+var sort = (...comparators) => {
+  return (a, b) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  };
+};
+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) => {
+  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[VersionTypeId] = {};
+  return parsed;
+};
+
+export {
+  Any,
+  make,
+  isObject,
+  getSnapshot,
+  clone,
+  ID,
+  instanceOf,
+  getDXN,
+  getTypeDXN2 as getTypeDXN,
+  getSchema2 as getSchema,
+  getTypename,
+  Meta,
+  getMeta2 as getMeta,
+  getKeys,
+  deleteKeys,
+  addTag,
+  removeTag,
+  isDeleted2 as isDeleted,
+  getLabel2 as getLabel,
+  setLabel2 as setLabel,
+  getDescription2 as getDescription,
+  setDescription2 as setDescription,
+  toJSON,
+  fromJSON,
+  sortByLabel,
+  sortByTypename,
+  sort,
+  isVersion,
+  version,
+  versionValid,
+  compareVersions,
+  encodeVersion,
+  decodeVersion,
+  Obj_exports
+};
+//# sourceMappingURL=chunk-BJACR7QG.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Obj.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Schema from 'effect/Schema';\n\nimport { type ForeignKey } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { type DXN, ObjectId } from '@dxos/keys';\nimport { getSnapshot as getSnapshot$ } from '@dxos/live-object';\nimport { assumeType, deepMapValues } from '@dxos/util';\n\nimport * as Entity from './Entity';\nimport {\n  type AnyEchoObject,\n  type AnyProperties,\n  type InternalObjectProps,\n  MetaId,\n  type ObjectJSON,\n  type ObjectMeta,\n  ObjectVersionId,\n  VersionTypeId,\n  getDescription as getDescription$,\n  getLabel as getLabel$,\n  getMeta as getMeta$,\n  getObjectDXN,\n  getSchema as getSchema$,\n  getSchemaTypename,\n  getTypeAnnotation,\n  getTypeDXN as getTypeDXN$,\n  isDeleted as isDeleted$,\n  isInstanceOf,\n  makeObject,\n  objectFromJSON,\n  objectToJSON,\n  setDescription as setDescription$,\n  setLabel as setLabel$,\n} from './internal';\nimport * as Ref from './Ref';\nimport * as Type from './Type';\n\n/**\n * Base type for all ECHO objects.\n * @private\n */\ninterface BaseObj extends AnyEchoObject, Entity.OfKind<typeof Entity.Kind.Object> {}\n\n/**\n * Base type for all Obj objects.\n */\nexport interface Any extends BaseObj {}\n\nexport const Any = Schema.Struct({}).pipe(\n  Type.Obj({\n    typename: 'dxos.org/type/Any',\n    version: '0.1.0',\n  }),\n);\n\n/**\n * Object type with specific properties.\n */\nexport type Obj<Props> = BaseObj & Props;\n\n/**\n * Object with arbitrary properties.\n *\n * NOTE: Due to how typescript works, this type is not assignable to a specific schema type.\n * In that case, use `Obj.instanceOf` to check if an object is of a specific type.\n */\nexport interface AnyProps extends BaseObj, AnyProperties {}\n\nconst defaultMeta: ObjectMeta = {\n  keys: [],\n};\n\ntype Props<T = any> = {\n  id?: ObjectId;\n  [Meta]?: Partial<ObjectMeta>;\n} & Type.Properties<T>;\n\n// TODO(burdon): Should we allow the caller to set the id?\nexport type MakeProps<T extends Schema.Schema.AnyNoContext> = {\n  id?: ObjectId;\n  [Meta]?: Partial<ObjectMeta>;\n} & NoInfer<Props<Schema.Schema.Type<T>>>;\n\n/**\n * Creates a new object of the given types.\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 Schema.Schema.AnyNoContext>(\n  schema: S,\n  props: MakeProps<S>,\n  meta?: Partial<ObjectMeta>,\n): Obj<Schema.Schema.Type<S>> => {\n  assertArgument(getTypeAnnotation(schema)?.kind === Entity.Kind.Object, 'schema', 'Expected an object schema');\n\n  // Set default fields on meta on creation.\n  if (props[MetaId] != null) {\n    meta = { ...structuredClone(defaultMeta), ...props[MetaId] };\n    delete props[MetaId];\n  }\n\n  // Filter undefined values.\n  const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== undefined));\n\n  return makeObject<Schema.Schema.Type<S>>(schema, filterUndefined as any, {\n    ...defaultMeta,\n    ...meta,\n  });\n};\n\n/**\n * Determine if object is an ECHO object.\n */\nexport const isObject = (obj: unknown): obj is Any => {\n  assumeType<InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && obj[Entity.KindId] === Entity.Kind.Object;\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of an object.\n */\nexport const getSnapshot: <T extends Any>(obj: Obj<T>) => T = 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>(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 (Ref.isRef(value)) {\n      return value;\n    }\n    return recurse(value);\n  });\n\n  if (opts?.retainId) {\n    props.id = id;\n  }\n  const meta = getMeta(obj);\n  props[MetaId] = deepMapValues(meta, (value, recurse) => {\n    if (Ref.isRef(value)) {\n      return value;\n    }\n    return recurse(value);\n  });\n\n  return make(schema as Type.Obj.Any, props);\n};\n\n//\n// Type\n//\n\n// TODO(burdon): To discuss: prefer over ObjectId or Key.ObjectId or Type.ID?\nexport const ID = ObjectId;\nexport type ID = ObjectId;\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 isPerson = Obj.instanceOf(Person);\n * if (isPerson(john)) {\n *   // john is Person\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.Entity.Any>(schema: S): (value: unknown) => value is Schema.Schema.Type<S>;\n  <S extends Type.Entity.Any>(schema: S, value: unknown): value is Schema.Schema.Type<S>;\n} = ((...args: [schema: Type.Entity.Any, value: unknown] | [schema: Type.Entity.Any]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => isInstanceOf(args[0], entity);\n  }\n\n  return isInstanceOf(args[0], args[1]);\n}) as any;\n\n// TODO(dmaretskyi): Allow returning undefined.\nexport const getDXN = (entity: Entity.Unknown): DXN => {\n  assertArgument(!Schema.isSchema(entity), 'obj', 'Object should not be a schema.');\n  const dxn = getObjectDXN(entity);\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/Person:1.0.0\n */\n// TODO(burdon): Must define and return type for expando.\nexport const getTypeDXN = getTypeDXN$;\n\n/**\n * Get the schema of the object.\n */\nexport const getSchema = getSchema$;\n\n/**\n * @returns The typename of the object's type.\n * @example `example.com/type/Person`\n */\nexport const getTypename = (entity: Entity.Unknown): string | undefined => {\n  const schema = getSchema$(entity);\n  if (schema == null) {\n    // Try to extract typename from DXN.\n    return getTypeDXN$(entity)?.asTypeDXN()?.type;\n  }\n\n  return getSchemaTypename(schema);\n};\n\n//\n// Meta\n//\n\nexport const Meta: unique symbol = MetaId as any;\n\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): Allow returning undefined.\nexport const getMeta = (entity: AnyProperties): ObjectMeta => {\n  const meta = getMeta$(entity);\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  (entity: Entity.Unknown, source: string): ForeignKey[];\n  (source: string): (entity: Entity.Unknown) => ForeignKey[];\n} = Function.dual(2, (entity: Entity.Unknown, source?: string): ForeignKey[] => {\n  const meta = getMeta(entity);\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 entity\n * @param source\n */\nexport const deleteKeys = (entity: Entity.Unknown, source: string) => {\n  const meta = getMeta(entity);\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\nexport const addTag = (entity: Entity.Unknown, tag: string) => {\n  const meta = getMeta(entity);\n  meta.tags ??= [];\n  meta.tags.push(tag);\n};\n\nexport const removeTag = (entity: Entity.Unknown, tag: string) => {\n  const meta = getMeta(entity);\n  if (!meta.tags) {\n    return;\n  }\n  for (let i = 0; i < meta.tags.length; i++) {\n    if (meta.tags[i] === tag) {\n      meta.tags.splice(i, 1);\n      i--;\n    }\n  }\n};\n\n// TODO(dmaretskyi): Default to `false`.\nexport const isDeleted = (entity: Entity.Unknown): boolean => {\n  const deleted = isDeleted$(entity);\n  invariant(typeof deleted === 'boolean', 'Invalid object.');\n  return deleted;\n};\n\n//\n// Annotations\n//\n\nexport const getLabel = (entity: Entity.Unknown): string | undefined => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    return getLabel$(schema, entity);\n  }\n};\n\nexport const setLabel = (entity: Entity.Unknown, label: string) => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    setLabel$(schema, entity, label);\n  }\n};\n\nexport const getDescription = (entity: Entity.Unknown): string | undefined => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    return getDescription$(schema, entity);\n  }\n};\n\nexport const setDescription = (entity: Entity.Unknown, description: string) => {\n  const schema = getSchema$(entity);\n  if (schema != null) {\n    setDescription$(schema, entity, description);\n  }\n};\n\n//\n// JSON\n//\n\n/**\n * JSON representation of an object.\n */\nexport type JSON = 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 */\nexport const toJSON = (entity: Entity.Unknown): JSON => objectToJSON(entity);\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 must 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  objectFromJSON as any;\n\n//\n// Sorting\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: Entity.Unknown, b: Entity.Unknown) => number;\n\nexport const sortByLabel: Comparator = (a: Entity.Unknown, b: Entity.Unknown) => compare(getLabel(a), getLabel(b));\nexport const sortByTypename: Comparator = (a: Entity.Unknown, b: Entity.Unknown) =>\n  compare(getTypename(a), getTypename(b));\nexport const sort = (...comparators: Comparator[]): Comparator => {\n  return (a: Entity.Unknown, b: Entity.Unknown) => {\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// Version\n//\n\n/**\n * Unique symbol for version type identification.\n */\nexport { 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 = (entity: unknown): entity is Version => {\n  return entity != null && typeof entity === 'object' && VersionTypeId in entity;\n};\n\n/**\n * Returns the version of the object.\n */\nexport const version = (entity: Entity.Unknown): Version => {\n  const version = (entity as any)[ObjectVersionId];\n  if (version === undefined) {\n    return unversioned;\n  }\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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;wBAAAA;EAAA;kBAAAC;EAAA,eAAAC;EAAA,iBAAAC;EAAA;oBAAAC;EAAA;;mBAAAC;EAAA;;;;wBAAAC;EAAA,gBAAAC;EAAA;;;;;;;AAIA,YAAYC,cAAc;AAC1B,YAAYC,YAAY;AAGxB,SAASC,gBAAgBC,iBAAiB;AAC1C,SAAmBC,gBAAgB;AACnC,SAASC,eAAeC,oBAAoB;AAC5C,SAASC,YAAYC,qBAAqB;;AA0CnC,IAAMC,MAAaC,cAAO,CAAC,CAAA,EAAGC,KAC9BC,IAAI;EACPC,UAAU;EACVC,SAAS;AACX,CAAA,CAAA;AAgBF,IAAMC,cAA0B;EAC9BC,MAAM,CAAA;AACR;AA0BO,IAAMC,OAAO,CAClBC,QACAC,OACAC,SAAAA;AAEAC,iBAAeC,kBAAkBJ,MAAAA,GAASK,SAAgBC,KAAKC,QAAQ,UAAU,2BAAA;AAGjF,MAAIN,MAAMO,MAAAA,KAAW,MAAM;AACzBN,WAAO;MAAE,GAAGO,gBAAgBZ,WAAAA;MAAc,GAAGI,MAAMO,MAAAA;IAAQ;AAC3D,WAAOP,MAAMO,MAAAA;EACf;AAGA,QAAME,kBAAkBH,OAAOI,YAAYJ,OAAOK,QAAQX,KAAAA,EAAOY,OAAO,CAAC,CAACC,GAAGC,CAAAA,MAAOA,MAAMC,MAAAA,CAAAA;AAE1F,SAAOC,WAAkCjB,QAAQU,iBAAwB;IACvE,GAAGb;IACH,GAAGK;EACL,CAAA;AACF;AAKO,IAAMgB,WAAW,CAACC,QAAAA;AACvBC,aAAgCD,GAAAA;AAChC,SAAO,OAAOA,QAAQ,YAAYA,QAAQ,QAAQA,IAAWE,MAAM,MAAaf,KAAKC;AACvF;AASO,IAAMe,cAAiDC;AAevD,IAAMC,QAAQ,CAAgBL,KAAQM,SAAAA;AAC3C,QAAM,EAAEC,IAAI,GAAGC,KAAAA,IAASR;AACxB,QAAMnB,SAAS4B,UAAWT,GAAAA;AAC1BU,YAAU7B,UAAU,MAAM,+BAAA;;;;;;;;;AAC1B,QAAMC,QAAa6B,cAAcH,MAAM,CAACI,OAAOC,YAAAA;AAC7C,QAAQC,MAAMF,KAAAA,GAAQ;AACpB,aAAOA;IACT;AACA,WAAOC,QAAQD,KAAAA;EACjB,CAAA;AAEA,MAAIN,MAAMS,UAAU;AAClBjC,UAAMyB,KAAKA;EACb;AACA,QAAMxB,OAAOiC,SAAQhB,GAAAA;AACrBlB,QAAMO,MAAAA,IAAUsB,cAAc5B,MAAM,CAAC6B,OAAOC,YAAAA;AAC1C,QAAQC,MAAMF,KAAAA,GAAQ;AACpB,aAAOA;IACT;AACA,WAAOC,QAAQD,KAAAA;EACjB,CAAA;AAEA,SAAOhC,KAAKC,QAAwBC,KAAAA;AACtC;AAOO,IAAMmC,KAAKC;AAcX,IAAMC,aAGR,IAAIC,SAAAA;AACP,MAAIA,KAAKC,WAAW,GAAG;AACrB,WAAO,CAACC,WAAoBC,aAAaH,KAAK,CAAA,GAAIE,MAAAA;EACpD;AAEA,SAAOC,aAAaH,KAAK,CAAA,GAAIA,KAAK,CAAA,CAAE;AACtC;AAGO,IAAMI,SAAS,CAACF,WAAAA;AACrBtC,iBAAe,CAAQyC,gBAASH,MAAAA,GAAS,OAAO,gCAAA;AAChD,QAAMI,MAAMC,aAAaL,MAAAA;AACzBZ,YAAUgB,OAAO,MAAM,mBAAA;;;;;;;;;AACvB,SAAOA;AACT;AAOO,IAAME,cAAaC;AAKnB,IAAMC,aAAYrB;AAMlB,IAAMsB,cAAc,CAACT,WAAAA;AAC1B,QAAMzC,SAAS4B,UAAWa,MAAAA;AAC1B,MAAIzC,UAAU,MAAM;AAElB,WAAOgD,WAAYP,MAAAA,GAASU,UAAAA,GAAaC;EAC3C;AAEA,SAAOC,kBAAkBrD,MAAAA;AAC3B;AAMO,IAAMsD,OAAsB9C;AAI5B,IAAM2B,WAAU,CAACM,WAAAA;AACtB,QAAMvC,OAAOqD,QAASd,MAAAA;AACtBZ,YAAU3B,QAAQ,MAAM,mBAAA;;;;;;;;;AACxB,SAAOA;AACT;AAKO,IAAMsD,UAGAC,cAAK,GAAG,CAAChB,QAAwBiB,WAAAA;AAC5C,QAAMxD,OAAOiC,SAAQM,MAAAA;AACrBZ,YAAU3B,QAAQ,MAAM,mBAAA;;;;;;;;;AACxB,SAAOA,KAAKJ,KAAKe,OAAO,CAAC8C,QAAQA,IAAID,WAAWA,MAAAA;AAClD,CAAA;AAOO,IAAME,aAAa,CAACnB,QAAwBiB,WAAAA;AACjD,QAAMxD,OAAOiC,SAAQM,MAAAA;AACrB,WAASoB,IAAI,GAAGA,IAAI3D,KAAKJ,KAAK0C,QAAQqB,KAAK;AACzC,QAAI3D,KAAKJ,KAAK+D,CAAAA,EAAGH,WAAWA,QAAQ;AAClCxD,WAAKJ,KAAKgE,OAAOD,GAAG,CAAA;AACpBA;IACF;EACF;AACF;AAEO,IAAME,SAAS,CAACtB,QAAwBuB,QAAAA;AAC7C,QAAM9D,OAAOiC,SAAQM,MAAAA;AACrBvC,OAAK+D,SAAS,CAAA;AACd/D,OAAK+D,KAAKC,KAAKF,GAAAA;AACjB;AAEO,IAAMG,YAAY,CAAC1B,QAAwBuB,QAAAA;AAChD,QAAM9D,OAAOiC,SAAQM,MAAAA;AACrB,MAAI,CAACvC,KAAK+D,MAAM;AACd;EACF;AACA,WAASJ,IAAI,GAAGA,IAAI3D,KAAK+D,KAAKzB,QAAQqB,KAAK;AACzC,QAAI3D,KAAK+D,KAAKJ,CAAAA,MAAOG,KAAK;AACxB9D,WAAK+D,KAAKH,OAAOD,GAAG,CAAA;AACpBA;IACF;EACF;AACF;AAGO,IAAMO,aAAY,CAAC3B,WAAAA;AACxB,QAAM4B,UAAUC,UAAW7B,MAAAA;AAC3BZ,YAAU,OAAOwC,YAAY,WAAW,mBAAA;;;;;;;;;AACxC,SAAOA;AACT;AAMO,IAAME,YAAW,CAAC9B,WAAAA;AACvB,QAAMzC,SAAS4B,UAAWa,MAAAA;AAC1B,MAAIzC,UAAU,MAAM;AAClB,WAAOwE,SAAUxE,QAAQyC,MAAAA;EAC3B;AACF;AAEO,IAAMgC,YAAW,CAAChC,QAAwBiC,UAAAA;AAC/C,QAAM1E,SAAS4B,UAAWa,MAAAA;AAC1B,MAAIzC,UAAU,MAAM;AAClB2E,aAAU3E,QAAQyC,QAAQiC,KAAAA;EAC5B;AACF;AAEO,IAAME,kBAAiB,CAACnC,WAAAA;AAC7B,QAAMzC,SAAS4B,UAAWa,MAAAA;AAC1B,MAAIzC,UAAU,MAAM;AAClB,WAAO6E,eAAgB7E,QAAQyC,MAAAA;EACjC;AACF;AAEO,IAAMqC,kBAAiB,CAACrC,QAAwBsC,gBAAAA;AACrD,QAAM/E,SAAS4B,UAAWa,MAAAA;AAC1B,MAAIzC,UAAU,MAAM;AAClBgF,mBAAgBhF,QAAQyC,QAAQsC,WAAAA;EAClC;AACF;AAgBO,IAAME,SAAS,CAACxC,WAAiCyC,aAAazC,MAAAA;AAW9D,IAAM0C,WACXC;AAMF,IAAMC,UAAU,CAACC,GAAYC,MAAAA;AAC3B,MAAID,KAAK,MAAM;AACb,WAAOC,KAAK,OAAO,IAAI;EACzB;AAEA,MAAIA,KAAK,MAAM;AACb,WAAO;EACT;AAEA,SAAOD,EAAEE,cAAcD,CAAAA;AACzB;AAIO,IAAME,cAA0B,CAACH,GAAmBC,MAAsBF,QAAQd,UAASe,CAAAA,GAAIf,UAASgB,CAAAA,CAAAA;AACxG,IAAMG,iBAA6B,CAACJ,GAAmBC,MAC5DF,QAAQnC,YAAYoC,CAAAA,GAAIpC,YAAYqC,CAAAA,CAAAA;AAC/B,IAAMI,OAAO,IAAIC,gBAAAA;AACtB,SAAO,CAACN,GAAmBC,MAAAA;AACzB,eAAWM,cAAcD,aAAa;AACpC,YAAME,SAASD,WAAWP,GAAGC,CAAAA;AAC7B,UAAIO,WAAW,GAAG;AAChB,eAAOA;MACT;IACF;AAEA,WAAO;EACT;AACF;AA8BA,IAAMC,cAAuB;EAC3B,CAACC,aAAAA,GAAgB,CAAC;EAClBC,WAAW;AACb;AAKO,IAAMC,YAAY,CAACC,WAAAA;AACxB,SAAOA,UAAU,QAAQ,OAAOA,WAAW,YAAYH,iBAAiBG;AAC1E;AAKO,IAAMC,UAAU,CAACD,WAAAA;AACtB,QAAMC,WAAWD,OAAeE,eAAAA;AAChC,MAAID,aAAYE,QAAW;AACzB,WAAOP;EACT;AAEA,SAAOK;AACT;AAKO,IAAMG,eAAe,CAACH,aAAAA;AAC3BI,iBAAeN,UAAUE,QAAAA,GAAU,WAAW,wBAAA;AAC9C,SAAO,CAAC,CAACA,SAAQH;AACnB;AAUO,IAAMQ,kBAAkB,CAACC,UAAmBC,aAAAA;AACjDH,iBAAeN,UAAUQ,QAAAA,GAAW,YAAY,wBAAA;AAChDF,iBAAeN,UAAUS,QAAAA,GAAW,YAAY,wBAAA;AAEhD,MAAI,CAACJ,aAAaG,QAAAA,KAAa,CAACH,aAAaI,QAAAA,GAAW;AACtD,WAAO;EACT;AAEA,MAAID,SAASE,gBAAgBC,WAAWF,SAASC,gBAAgBC,QAAQ;AACvE,WAAO;EACT;AACA,MAAIH,SAASE,gBAAgBE,KAAK,CAACC,SAAS,CAACJ,SAASC,gBAAgBI,SAASD,IAAAA,CAAAA,GAAQ;AACrF,WAAO;EACT;AAEA,SAAO;AACT;AAEO,IAAME,gBAAgB,CAACb,aAAAA;AAC5B,SAAOc,KAAKC,UAAUf,QAAAA;AACxB;AAEO,IAAMgB,gBAAgB,CAAChB,aAAAA;AAC5B,QAAMiB,SAASH,KAAKI,MAAMlB,QAAAA;AAC1BiB,SAAOrB,aAAAA,IAAiB,CAAC;AACzB,SAAOqB;AACT;",
+  "names": ["getDescription", "getLabel", "getMeta", "getSchema", "getTypeDXN", "isDeleted", "setDescription", "setLabel", "Function", "Schema", "assertArgument", "invariant", "ObjectId", "getSnapshot", "getSnapshot$", "assumeType", "deepMapValues", "Any", "Struct", "pipe", "Obj", "typename", "version", "defaultMeta", "keys", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "Kind", "Object", "MetaId", "structuredClone", "filterUndefined", "fromEntries", "entries", "filter", "_", "v", "undefined", "makeObject", "isObject", "obj", "assumeType", "KindId", "getSnapshot", "getSnapshot$", "clone", "opts", "id", "data", "getSchema$", "invariant", "deepMapValues", "value", "recurse", "isRef", "retainId", "getMeta", "ID", "ObjectId", "instanceOf", "args", "length", "entity", "isInstanceOf", "getDXN", "isSchema", "dxn", "getObjectDXN", "getTypeDXN", "getTypeDXN$", "getSchema", "getTypename", "asTypeDXN", "type", "getSchemaTypename", "Meta", "getMeta$", "getKeys", "dual", "source", "key", "deleteKeys", "i", "splice", "addTag", "tag", "tags", "push", "removeTag", "isDeleted", "deleted", "isDeleted$", "getLabel", "getLabel$", "setLabel", "label", "setLabel$", "getDescription", "getDescription$", "setDescription", "description", "setDescription$", "toJSON", "objectToJSON", "fromJSON", "objectFromJSON", "compare", "a", "b", "localeCompare", "sortByLabel", "sortByTypename", "sort", "comparators", "comparator", "result", "unversioned", "VersionTypeId", "versioned", "isVersion", "entity", "version", "ObjectVersionId", "undefined", "versionValid", "assertArgument", "compareVersions", "version1", "version2", "automergeHeads", "length", "some", "head", "includes", "encodeVersion", "JSON", "stringify", "decodeVersion", "parsed", "parse"]
+}

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

@@ -0,0 +1,37 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Order.ts
+var Order_exports = {};
+__export(Order_exports, {
+  natural: () => natural,
+  property: () => property
+});
+var OrderClass = class _OrderClass {
+  ast;
+  static variance = {};
+  static is(value) {
+    return typeof value === "object" && value !== null && "~Order" in value;
+  }
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Order" = _OrderClass.variance;
+};
+var natural = new OrderClass({
+  kind: "natural"
+});
+var property = (property2, direction) => new OrderClass({
+  kind: "property",
+  property: property2,
+  direction
+});
+
+export {
+  natural,
+  property,
+  Order_exports
+};
+//# sourceMappingURL=chunk-BYL2NPEA.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Order.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nexport interface Order<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Order': { value: T };\n\n  ast: QueryAST.Order;\n}\n\nexport type Any = Order<any>;\n\nclass OrderClass implements Order<any> {\n  private static variance: Order<any>['~Order'] = {} as Order<any>['~Order'];\n\n  static is(value: unknown): value is Order<any> {\n    return typeof value === 'object' && value !== null && '~Order' in value;\n  }\n\n  constructor(public readonly ast: QueryAST.Order) {}\n\n  '~Order' = OrderClass.variance;\n}\n\nexport const natural: Order<any> = new OrderClass({ kind: 'natural' });\nexport const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order<T> =>\n  new OrderClass({\n    kind: 'property',\n    property,\n    direction,\n  });\n"],
+  "mappings": ";;;;;;AAAA;;;;;AAeA,IAAMA,aAAN,MAAMA,YAAAA;;EACJ,OAAeC,WAAiC,CAAC;EAEjD,OAAOC,GAAGC,OAAqC;AAC7C,WAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,YAAYA;EACpE;EAEA,YAA4BC,KAAqB;SAArBA,MAAAA;EAAsB;EAElD,WAAWJ,YAAWC;AACxB;AAEO,IAAMI,UAAsB,IAAIL,WAAW;EAAEM,MAAM;AAAU,CAAA;AAC7D,IAAMC,WAAW,CAAIA,WAA4BC,cACtD,IAAIR,WAAW;EACbM,MAAM;EACNC,UAAAA;EACAC;AACF,CAAA;",
+  "names": ["OrderClass", "variance", "is", "value", "ast", "natural", "kind", "property", "direction"]
+}

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

@@ -0,0 +1,74 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  Currency,
+  CurrencyAnnotationId,
+  DecimalPrecision,
+  Email,
+  Format,
+  FormatAnnotation,
+  FormatAnnotationId,
+  FormatEnums,
+  Formula,
+  GeoLocation,
+  GeoPoint,
+  Hostname,
+  JSON,
+  Markdown,
+  OptionsAnnotation,
+  OptionsAnnotationId,
+  PropertyKind,
+  Regex,
+  SelectOption,
+  Text,
+  TypeEnum,
+  TypeFormat,
+  URL,
+  UUID,
+  formatToType,
+  getFormatAnnotation,
+  getOptionsAnnotation,
+  getTypeEnum,
+  typeToFormat
+} from "./chunk-HLUDHPFO.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// 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: () => JSON,
+  Markdown: () => Markdown,
+  OptionsAnnotation: () => OptionsAnnotation,
+  OptionsAnnotationId: () => OptionsAnnotationId,
+  PropertyKind: () => PropertyKind,
+  Regex: () => Regex,
+  SelectOption: () => SelectOption,
+  Text: () => Text,
+  TypeEnum: () => TypeEnum,
+  TypeFormat: () => TypeFormat,
+  URL: () => URL,
+  UUID: () => UUID,
+  formatToType: () => formatToType,
+  getFormatAnnotation: () => getFormatAnnotation,
+  getOptionsAnnotation: () => getOptionsAnnotation,
+  getTypeEnum: () => getTypeEnum,
+  typeToFormat: () => typeToFormat
+});
+
+export {
+  Format_exports
+};
+//# sourceMappingURL=chunk-CCMFPJUT.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Format.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type TypeFormat as Format } from './internal';\n\nexport * from './internal/formats';\n\nexport type { Format };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+  "names": []
+}

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

@@ -0,0 +1,39 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Err.ts
+var Err_exports = {};
+__export(Err_exports, {
+  ObjectNotFoundError: () => ObjectNotFoundError,
+  SchemaNotFoundError: () => SchemaNotFoundError
+});
+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
+    });
+  }
+};
+
+export {
+  SchemaNotFoundError,
+  ObjectNotFoundError,
+  Err_exports
+};
+//# sourceMappingURL=chunk-D5BW7KHR.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Err.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"],
+  "mappings": ";;;;;;AAAA;;;;;AAIA,SAASA,iBAAwC;AAG1C,IAAMC,sBAAN,cAAkCC,UAAUC,OAAO,oBAAoB,kBAAA,EAAA;EAC5E,YAAYC,QAAgBC,SAA4B;AACtD,UAAM;MAAEC,SAAS;QAAEF;MAAO;MAAG,GAAGC;IAAQ,CAAA;EAC1C;AACF;AAEO,IAAME,sBAAN,cAAkCL,UAAUC,OAAO,oBAAoB,kBAAA,EAAA;EAC5E,YAAYK,KAAUH,SAA4B;AAChD,UAAM;MAAEC,SAAS;QAAEE;MAAI;MAAG,GAAGH;IAAQ,CAAA;EACvC;AACF;",
+  "names": ["BaseError", "SchemaNotFoundError", "BaseError", "extend", "schema", "options", "context", "ObjectNotFoundError", "dxn"]
+}