@dxos/echo 0.8.4-main.40e3dcdf1b → 0.8.4-main.43cb759274

package/dist/lib/neutral/chunk-4BB4MFCN.mjs

@@ -0,0 +1,154 @@
+import {
+  createEchoReferenceSchema
+} from "./chunk-7OAFN3OX.mjs";
+import {
+  Dictionary,
+  getDictionary,
+  setDictionary
+} from "./chunk-H26LSXVJ.mjs";
+import {
+  KindId,
+  SnapshotKindId
+} from "./chunk-O6BH7EPN.mjs";
+
+// src/internal/common/types/well-known-types.ts
+import { DXN } from "@dxos/keys";
+var TagTypeDXN = DXN.make("org.dxos.type.tag", "0.1.0");
+
+// src/internal/common/types/meta.ts
+import * as Schema from "effect/Schema";
+import { ForeignKey } from "@dxos/echo-protocol";
+import { invariant } from "@dxos/invariant";
+import { DXN as DXN2 } from "@dxos/keys";
+import { intersection } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/types/meta.ts";
+var ATTR_META = "@meta";
+var MetaId = /* @__PURE__ */ Symbol.for("@dxos/echo/Meta");
+var TagRefSchema = Schema.suspend(() => (
+  // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.
+  createEchoReferenceSchema(void 0, DXN2.getName(TagTypeDXN), DXN2.getVersion(TagTypeDXN))
+));
+var EntityMetaSchema = Schema.Struct({
+  keys: Schema.Array(ForeignKey),
+  /**
+  * Tags applied to this entity, as references to {@link Tag} objects.
+  */
+  tags: Schema.Array(TagRefSchema),
+  /**
+  * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).
+  * Identifies the canonical registry entry the object instance was created from.
+  */
+  key: Schema.optional(Schema.String),
+  /**
+  * Semantic version of the registry entry the object was created from.
+  * Must be a valid semver string (e.g. `1.2.3`).
+  */
+  version: Schema.optional(Schema.String),
+  /**
+  * Dictionary of annotations to this entity.
+  */
+  annotations: Dictionary
+});
+var getMeta = (obj) => {
+  const metadata = obj[MetaId];
+  invariant(metadata, "EntityMeta not found.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 57, S: void 0, A: ["metadata", "'EntityMeta not found.'"] });
+  return metadata;
+};
+var foreignKey = (source, id) => ({
+  source,
+  id
+});
+var foreignKeyEquals = (a, b) => a.source === b.source && a.id === b.id;
+var compareForeignKeys = (a, b) => intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;
+
+// src/internal/common/api/meta.ts
+import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/api/meta.ts";
+function getMetaChecked(entity) {
+  assertArgument(entity, "entity", "Should be an entity.");
+  const meta = getMeta(entity);
+  invariant2(meta != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 9, S: this, A: ["meta != null", "'Invalid entity.'"] });
+  return meta;
+}
+var getKeys = (entity, source) => {
+  assertArgument(entity, "entity", "Should be an entity.");
+  const meta = getMetaChecked(entity);
+  invariant2(meta != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 18, S: void 0, A: ["meta != null", "'Invalid entity.'"] });
+  return meta.keys.filter((key) => key.source === source);
+};
+var deleteKeys = (entity, source) => {
+  const meta = getMetaChecked(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 = getMetaChecked(entity);
+  if (!meta.tags.some((existing) => existing.uri === tag.uri)) {
+    meta.tags.push(tag);
+  }
+};
+var removeTag = (entity, tag) => {
+  const meta = getMetaChecked(entity);
+  for (let i = 0; i < meta.tags.length; i++) {
+    if (meta.tags[i].uri === tag.uri) {
+      meta.tags.splice(i, 1);
+      i--;
+    }
+  }
+};
+
+// src/internal/Entity/guard.ts
+var isEntity = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[KindId] !== void 0;
+};
+var isSnapshot = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[SnapshotKindId] !== void 0;
+};
+
+// src/internal/Annotation/entity-dictionary.ts
+var get = (target, annotation) => {
+  if (isEntity(target) || isSnapshot(target)) {
+    const meta = getMetaChecked(target);
+    return getDictionary(meta.annotations, annotation);
+  } else {
+    throw new TypeError("Target is not an annotation target.");
+  }
+};
+var set = (target, annotation, value) => {
+  if (isEntity(target)) {
+    const meta = getMetaChecked(target);
+    setDictionary(meta.annotations, annotation, value);
+  } else {
+    throw new TypeError("Target is not an annotation target.");
+  }
+};
+
+export {
+  TagTypeDXN,
+  ATTR_META,
+  MetaId,
+  EntityMetaSchema,
+  getMeta,
+  foreignKey,
+  foreignKeyEquals,
+  compareForeignKeys,
+  getMetaChecked,
+  getKeys,
+  deleteKeys,
+  addTag,
+  removeTag,
+  isEntity,
+  get,
+  set
+};
+//# sourceMappingURL=chunk-4BB4MFCN.mjs.map

package/dist/lib/neutral/chunk-4BB4MFCN.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/common/types/well-known-types.ts", "../../../src/internal/common/types/meta.ts", "../../../src/internal/common/api/meta.ts", "../../../src/internal/Entity/guard.ts", "../../../src/internal/Annotation/entity-dictionary.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport { DXN } from '@dxos/keys';\n\n/**\n * DXN identity of the system {@link Tag} type.\n *\n * Defined in this low-level leaf so it can be shared by the public `Tag` type (which brands the\n * schema with this DXN) and by `EntityMetaSchema.tags` (which builds a `Ref<Tag>` schema from it)\n * without either importing the other — `Tag` is top-level and `meta` is deep-internal, so a direct\n * dependency between them would form an eval-order cycle.\n */\nexport const TagTypeDXN = DXN.make('org.dxos.type.tag', '0.1.0');\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { type EncodedReference, ForeignKey } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Comparator, intersection } from '@dxos/util';\n\nimport type * as Entity from '../../../Entity';\nimport type * as Tag from '../../../Tag';\nimport { Dictionary } from '../../Annotation/dictionary';\n// `meta` is no longer re-exported from the `common/types` barrel (see ./index.ts), so importing the\n// Ref schema builder here no longer forms an eval-order cycle with `Annotation`/`Database`.\nimport { type Ref, createEchoReferenceSchema } from '../../Ref/ref';\nimport { type AnyProperties } from './base';\nimport { TagTypeDXN } from './well-known-types';\n\n/**\n * Property name for meta when object is serialized to JSON.\n */\nexport const ATTR_META = '@meta';\n\n/**\n * Metadata section.\n */\nexport const MetaId: Entity.Meta = Symbol.for('@dxos/echo/Meta') as any;\n\n//\n// EntityMeta\n//\n\n/**\n * Schema for references to {@link Tag} objects stored in {@link EntityMetaSchema.tags}.\n *\n * Built from the shared {@link createEchoReferenceSchema} (the same builder `Ref.Ref` uses) via\n * `Schema.suspend`, so it reuses the canonical ref codec rather than duplicating it. The Tag type\n * identity comes from the shared {@link TagTypeDXN} constant; `suspend` defers construction until\n * first use, and `Tag` is referenced type-only, so no `Tag` value import is needed.\n */\nconst TagRefSchema = Schema.suspend(\n  (): Schema.Schema<Ref<Tag.Tag>, EncodedReference> =>\n    // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.\n    createEchoReferenceSchema(undefined, DXN.getName(TagTypeDXN), DXN.getVersion(TagTypeDXN)) as Schema.Schema<\n      Ref<Tag.Tag>,\n      EncodedReference\n    >,\n);\n\nexport const EntityMetaSchema = Schema.Struct({\n  keys: Schema.Array(ForeignKey),\n\n  /**\n   * Tags applied to this entity, as references to {@link Tag} objects.\n   */\n  tags: Schema.Array(TagRefSchema),\n\n  /**\n   * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).\n   * Identifies the canonical registry entry the object instance was created from.\n   */\n  key: Schema.optional(Schema.String),\n\n  /**\n   * Semantic version of the registry entry the object was created from.\n   * Must be a valid semver string (e.g. `1.2.3`).\n   */\n  version: Schema.optional(Schema.String),\n\n  /**\n   * Dictionary of annotations to this entity.\n   */\n  annotations: Dictionary,\n});\n\nexport type EntityMeta = Schema.Schema.Type<typeof EntityMetaSchema>;\n\n/*\n * Get metadata from object.\n * Only callable on the object root.\n *\n * @internal (use Obj.getMeta or Relation.getMeta)\n */\n// TODO(burdon): Refine type to BaseObj.\nexport const getMeta = (obj: AnyProperties): EntityMeta => {\n  const metadata = (obj as any)[MetaId];\n  invariant(metadata, 'EntityMeta not found.');\n  return metadata;\n};\n\n//\n// Foreign keys\n//\n\nexport const foreignKey = (source: string, id: string): ForeignKey => ({ source, id });\nexport const foreignKeyEquals = (a: ForeignKey, b: ForeignKey) => a.source === b.source && a.id === b.id;\n\n// TODO(dmaretskyi): Move to echo-schema.\nexport const compareForeignKeys: Comparator<AnyProperties> = (a: AnyProperties, b: AnyProperties) =>\n  intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport type { DeepReadonly } from '@dxos/util';\n\nimport type * as Tag from '../../../Tag';\nimport type { Ref } from '../../Ref/ref';\nimport { type Mutable } from '../proxy';\nimport { type AnyProperties } from '../types';\nimport { type EntityMeta, getMeta as getMeta$ } from '../types/meta';\n\n/**\n * Deeply read-only version of EntityMeta.\n */\nexport type ReadonlyMeta = DeepReadonly<EntityMeta>;\n\n/**\n * Mutable meta type received in meta mutation callbacks.\n */\nexport type Meta = Mutable<EntityMeta>;\n\n/**\n * Get the metadata for an entity with validation.\n * Returns mutable meta when passed a mutable entity (inside change callback).\n * Returns read-only meta when passed a regular entity or snapshot.\n *\n * TODO(burdon): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\n */\nexport function getMetaChecked(entity: Mutable<AnyProperties>): Meta;\nexport function getMetaChecked(entity: AnyProperties): ReadonlyMeta;\nexport function getMetaChecked(entity: AnyProperties): Meta | ReadonlyMeta {\n  assertArgument(entity, 'entity', 'Should be an entity.');\n  const meta = getMeta$(entity);\n  invariant(meta != null, 'Invalid entity.');\n  return meta;\n}\n\n/**\n * @returns Foreign keys for the entity from the specified source.\n * Accepts both reactive entities and snapshots.\n */\nexport const getKeys = (entity: AnyProperties, source: string): ForeignKey[] => {\n  assertArgument(entity, 'entity', 'Should be an entity.');\n  const meta = getMetaChecked(entity);\n  invariant(meta != null, 'Invalid entity.');\n  return meta.keys.filter((key) => key.source === source);\n};\n\n/**\n * Delete all keys from the entity for the specified source.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const deleteKeys = (entity: Mutable<AnyProperties>, source: string) => {\n  const meta = getMetaChecked(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\n/**\n * Add a tag (a reference to a {@link Tag} object) to the entity. Idempotent.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const addTag = (entity: Mutable<AnyProperties>, tag: Ref<Tag.Tag>) => {\n  const meta = getMetaChecked(entity);\n  // Two refs to the same target are not `===`; dedupe by URI.\n  if (!meta.tags.some((existing) => existing.uri === tag.uri)) {\n    meta.tags.push(tag);\n  }\n};\n\n/**\n * Remove a tag (a reference to a {@link Tag} object) from the entity. No-op when not present.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const removeTag = (entity: Mutable<AnyProperties>, tag: Ref<Tag.Tag>) => {\n  const meta = getMetaChecked(entity);\n  for (let i = 0; i < meta.tags.length; i++) {\n    if (meta.tags[i].uri === tag.uri) {\n      meta.tags.splice(i, 1);\n      i--;\n    }\n  }\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport type * as Entity from '../../Entity';\nimport { KindId, SnapshotKindId } from '../common/types';\n\n/**\n * Returns true if the value is an ECHO entity instance (object or relation).\n */\nexport const isEntity = (value: unknown): value is Entity.Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[KindId] !== undefined;\n};\n\n/**\n * Returns true if the value is an ECHO entity snapshot.\n */\nexport const isSnapshot = (value: unknown): value is Entity.Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[SnapshotKindId] !== undefined;\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\n\nimport type * as Annotation from '../../Annotation';\nimport type * as Entity from '../../Entity';\nimport { getMetaChecked } from '../common/api/meta';\nimport { type Mutable } from '../common/proxy/reactive';\nimport { isEntity, isSnapshot } from '../Entity/guard';\nimport { getDictionary, setDictionary } from './dictionary';\n\n/**\n * Get the value of an annotation from an entity instance or snapshot.\n */\nexport const get = <T>(\n  target: Entity.Unknown | Entity.Snapshot,\n  annotation: Annotation.Annotation<T>,\n): Option.Option<T> => {\n  if (isEntity(target) || isSnapshot(target)) {\n    const meta = getMetaChecked(target);\n    return getDictionary(meta.annotations, annotation);\n  } else {\n    throw new TypeError('Target is not an annotation target.');\n  }\n};\n\n/**\n * Set the value of an annotation on an entity instance.\n * Must be called with a mutable entity — i.e. inside an `Obj.update` callback.\n */\nexport const set = <T>(target: Mutable<Entity.Unknown>, annotation: Annotation.Annotation<T>, value: T): void => {\n  if (isEntity(target)) {\n    const meta = getMetaChecked(target);\n    setDictionary(meta.annotations, annotation, value);\n  } else {\n    throw new TypeError('Target is not an annotation target.');\n  }\n};\n"],
+  "mappings": "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",
+  "names": ["DXN", "TagTypeDXN", "make", "Schema", "ForeignKey", "invariant", "DXN", "intersection", "Schema", "Struct", "keys", "ForeignKey", "invariant", "metadata", "id", "compareForeignKeys", "a", "b", "intersection", "getMeta", "assertArgument", "invariant", "__dxlog_file", "getMetaChecked", "meta", "entity", "invariant", "keys", "key", "source", "splice", "i", "tags", "existing", "length", "uri", "isEntity", "value", "KindId", "undefined", "isSnapshot", "SnapshotKindId", "get", "target", "annotation", "isEntity", "isSnapshot", "meta", "getMetaChecked", "getDictionary", "annotations", "TypeError", "set", "value", "setDictionary"]
+}

package/dist/lib/neutral/{chunk-CIRHIEMW.mjs → chunk-4SFPZJVA.mjs}

@@ -1,57 +1,62 @@
 import {
-  Unknown
-} from "./chunk-NQRLRYJM.mjs";
-import {
+  Kind,
   KindId,
   SnapshotKindId
-} from "./chunk-UFDK26FO.mjs";
+} from "./chunk-QVJDDG44.mjs";
+import {
+  getSchema
+} from "./chunk-JE7AOSWF.mjs";
 import {
-  ATTR_RELATION_SOURCE,
-  ATTR_RELATION_TARGET,
-  EchoRelationSchema,
-  MetaId,
-  RelationSourceDXNId,
-  RelationSourceId,
-  RelationTargetDXNId,
-  RelationTargetId,
   VersionTypeId,
-  addTag,
   change,
-  deleteKeys,
-  getDXN,
-  getDatabase,
-  getKeys,
-  getMetaChecked,
-  getObjectDXN,
   getSnapshot,
   getValue,
   isDeleted,
   isVersion,
   makeObject,
   objectToJSON,
-  removeTag,
   setValue,
   sort,
   sortByLabel,
   sortByTypename,
   subscribe,
   version
-} from "./chunk-TQQZLKB7.mjs";
+} from "./chunk-OYUG4FHF.mjs";
+import {
+  MetaId,
+  addTag,
+  deleteKeys,
+  getKeys,
+  getMetaChecked,
+  removeTag
+} from "./chunk-4BB4MFCN.mjs";
 import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
   ParentId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  TypeAnnotationId,
+  getDatabase,
   getDescription,
   getLabel,
-  getSchema,
+  getObjectEchoUri,
+  getType,
   getTypeAnnotation,
-  getTypeDXN,
+  getTypeURI,
   getTypename,
+  getUri,
+  isInstanceOf,
   setDescription,
   setLabel
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-H26LSXVJ.mjs";
 import {
-  EntityKind,
-  SchemaKindId
-} from "./chunk-WYOKA6AE.mjs";
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  EntityKind
+} from "./chunk-O6BH7EPN.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -62,26 +67,26 @@ __export(Relation_exports, {
   Meta: () => Meta,
   Source: () => Source,
   Target: () => Target,
-  Unknown: () => Unknown3,
+  Unknown: () => Unknown2,
   VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
-  change: () => change2,
   deleteKeys: () => deleteKeys2,
-  getDXN: () => getDXN2,
   getDatabase: () => getDatabase2,
   getDescription: () => getDescription2,
   getKeys: () => getKeys2,
   getLabel: () => getLabel2,
   getMeta: () => getMeta,
-  getSchema: () => getSchema2,
   getSnapshot: () => getSnapshot2,
   getSource: () => getSource,
-  getSourceDXN: () => getSourceDXN,
+  getSourceURI: () => getSourceURI,
   getTarget: () => getTarget,
-  getTargetDXN: () => getTargetDXN,
-  getTypeDXN: () => getTypeDXN2,
+  getTargetURI: () => getTargetURI,
+  getType: () => getType2,
+  getTypeURI: () => getTypeURI2,
   getTypename: () => getTypename2,
+  getURI: () => getURI,
   getValue: () => getValue2,
+  instanceOf: () => instanceOf,
   isDeleted: () => isDeleted2,
   isRelation: () => isRelation,
   isSnapshot: () => isSnapshot,
@@ -96,38 +101,34 @@ __export(Relation_exports, {
   sortByTypename: () => sortByTypename2,
   subscribe: () => subscribe2,
   toJSON: () => toJSON,
+  update: () => update,
   version: () => version2
 });
 import * as Schema from "effect/Schema";
 import { raise } from "@dxos/debug";
 import { createJsonPath } from "@dxos/effect";
 import { assertArgument, invariant } from "@dxos/invariant";
-import { DXN } from "@dxos/keys";
+import { EID, DXN } from "@dxos/keys";
 import { assumeType } from "@dxos/util";
 var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
-var Unknown3 = Schema.Struct({
+var Unknown2 = Schema.Struct({
   id: Schema.String
-}).pipe(
-  Schema.extend(Schema.Record({
-    key: Schema.String,
-    value: Schema.Unknown
-  })),
-  // TODO(dmaretskyi): Clean this up.
-  // NOTE: The EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.
-  //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.
-  EchoRelationSchema({
-    typename: "org.dxos.schema.any-relation",
+}).pipe(Schema.extend(Schema.Record({
+  key: Schema.String,
+  value: Schema.Unknown
+})), Schema.annotations({
+  [TypeAnnotationId]: {
+    kind: Kind.Relation,
+    typename: "org.dxos.schema.anyRelation",
     version: "0.0.0",
-    source: Unknown,
-    target: Unknown
-  }),
-  (schema) => Object.assign(schema, {
-    [SchemaKindId]: schema[SchemaKindId]
-  })
-);
+    sourceSchema: DXN.make(ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION),
+    targetSchema: DXN.make(ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION)
+  }
+}));
 var Source = RelationSourceId;
 var Target = RelationTargetId;
-var make = (schema, props) => {
+var make = (type, props) => {
+  const schema = getSchema(type);
   assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, "schema", "Expected a relation schema");
   assertArgument(props[ParentId] === void 0, "props", "Parent is not allowed for relations");
   let meta = void 0;
@@ -135,11 +136,17 @@ var make = (schema, props) => {
     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"));
+  const sourceDXN = getObjectEchoUri(props[Source]) ?? raise(new Error("Unresolved relation source"));
+  const targetDXN = getObjectEchoUri(props[Target]) ?? raise(new Error("Unresolved relation target"));
   props[RelationSourceDXNId] = sourceDXN;
   props[RelationTargetDXNId] = targetDXN;
-  return makeObject(schema, props, meta);
+  return makeObject(schema, props, meta, type);
+};
+var instanceOf = (...args) => {
+  if (args.length === 1) {
+    return (entity) => isInstanceOf(args[0], entity);
+  }
+  return isInstanceOf(args[0], args[1]);
 };
 var isRelation = (value) => {
   if (typeof value !== "object" || value === null) {
@@ -157,67 +164,39 @@ var isSnapshot = (value) => {
   }
   return value[SnapshotKindId] === EntityKind.Relation;
 };
-var getSourceDXN = (value) => {
+var getSourceURI = (value) => {
   assertArgument(isRelation(value), "Expected a relation");
   assumeType(value);
-  const dxn = value[RelationSourceDXNId];
-  invariant(dxn instanceof DXN, void 0, {
-    F: __dxlog_file,
-    L: 214,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
-  return dxn;
+  const uri = value[RelationSourceDXNId];
+  invariant(EID.isEID(uri), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 120, S: void 0, A: ["EID.isEID(uri)", ""] });
+  return uri;
 };
-var getTargetDXN = (value) => {
+var getTargetURI = (value) => {
   assertArgument(isRelation(value), "Expected a relation");
   assumeType(value);
-  const dxn = value[RelationTargetDXNId];
-  invariant(dxn instanceof DXN, void 0, {
-    F: __dxlog_file,
-    L: 227,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
-  return dxn;
+  const uri = value[RelationTargetDXNId];
+  invariant(EID.isEID(uri), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 131, S: void 0, A: ["EID.isEID(uri)", ""] });
+  return uri;
 };
 var getSource = (relation) => {
   assertArgument(isRelation(relation), "Expected a relation");
   assumeType(relation);
   const obj = relation[RelationSourceId];
-  invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 240,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid source: ${relation.id}`"
-    ]
-  });
+  if (obj === void 0) {
+    throw new Error(`Relation source could not be resolved.`);
+  }
   return obj;
 };
 var getTarget = (relation) => {
   assertArgument(isRelation(relation), "Expected a relation");
   assumeType(relation);
   const obj = relation[RelationTargetId];
-  invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 253,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid target: ${relation.id}`"
-    ]
-  });
+  if (obj === void 0) {
+    throw new Error(`Relation target could not be resolved.`);
+  }
   return obj;
 };
-var change2 = (relation, callback) => {
+var update = (relation, callback) => {
   change(relation, callback);
 };
 var getSnapshot2 = getSnapshot;
@@ -228,9 +207,9 @@ var getValue2 = (rel, path) => {
   return getValue(rel, createJsonPath(path));
 };
 var setValue2 = setValue;
-var getDXN2 = (entity) => getDXN(entity);
-var getTypeDXN2 = getTypeDXN;
-var getSchema2 = getSchema;
+var getURI = (entity) => getUri(entity);
+var getTypeURI2 = getTypeURI;
+var getType2 = (relation) => getType(relation);
 var getTypename2 = (entity) => getTypename(entity);
 var getDatabase2 = (entity) => getDatabase(entity);
 var Meta = MetaId;
@@ -242,7 +221,7 @@ var deleteKeys2 = (entity, source) => deleteKeys(entity, source);
 var addTag2 = (entity, tag) => addTag(entity, tag);
 var removeTag2 = (entity, tag) => removeTag(entity, tag);
 var isDeleted2 = (entity) => isDeleted(entity);
-var getLabel2 = (entity) => getLabel(entity);
+var getLabel2 = (entity, options) => getLabel(entity, options);
 var setLabel2 = (entity, label) => setLabel(entity, label);
 var getDescription2 = (entity) => getDescription(entity);
 var setDescription2 = (entity, description) => setDescription(entity, description);
@@ -255,24 +234,25 @@ var isVersion2 = isVersion;
 var version2 = (entity) => version(entity);
 
 export {
-  Unknown3 as Unknown,
+  Unknown2 as Unknown,
   Source,
   Target,
   make,
+  instanceOf,
   isRelation,
   isSnapshot,
-  getSourceDXN,
-  getTargetDXN,
+  getSourceURI,
+  getTargetURI,
   getSource,
   getTarget,
-  change2 as change,
+  update,
   getSnapshot2 as getSnapshot,
   subscribe2 as subscribe,
   getValue2 as getValue,
   setValue2 as setValue,
-  getDXN2 as getDXN,
-  getTypeDXN2 as getTypeDXN,
-  getSchema2 as getSchema,
+  getURI,
+  getTypeURI2 as getTypeURI,
+  getType2 as getType,
   getTypename2 as getTypename,
   getDatabase2 as getDatabase,
   Meta,
@@ -295,4 +275,4 @@ export {
   version2 as version,
   Relation_exports
 };
-//# sourceMappingURL=chunk-CIRHIEMW.mjs.map
+//# sourceMappingURL=chunk-4SFPZJVA.mjs.map

package/dist/lib/neutral/chunk-4SFPZJVA.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { EID, type EntityId, type URI, DXN } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as internal from './internal';\nimport * as entityInternal from './internal/Entity';\nimport * as Obj from './Obj';\nimport type * as Ref from './Ref';\nimport type * as Tag from './Tag';\nimport * as Type from './Type';\n\nexport type Endpoints<Source, Target> = {\n  [Source]: Source;\n  [Target]: Target;\n};\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends internal.AnyEntity, Endpoints<Source, Target>, Entity.OfKind<internal.EntityKind.Relation> {}\n\n/**\n * Relation with no known properties beyond id, kind, source, and target.\n * Use this when the relation's schema/properties are not known.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO relation, use `Relation.isRelation`.\n */\nexport interface Unknown extends BaseRelation<Obj.Unknown, Obj.Unknown> {}\n\n/**\n * Runtime Effect schema for any ECHO relation.\n * Use for validation, parsing, or as a reference target for collections.\n * A relation has `id`, source, and target fields plus any additional properties.\n *\n * NOTE: `Schema.is(Type.Relation)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Relation.isRelation()` for proper ECHO instance type guards that check the KindId brand.\n *\n * @example\n * ```ts\n * // Structural type guard (accepts any object with id field)\n * if (Schema.is(Type.Relation)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Relation.isRelation(unknownValue)) { ... }\n * ```\n */\n// TODO(dmaretskyi): Change ObjModule.Any to ObjModule.Unknown to have stricter types.\nexport const Unknown: internal.UnknownTypeSchema<Unknown, typeof Entity.Kind.Relation> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  Schema.annotations({\n    [internal.TypeAnnotationId]: {\n      kind: Entity.Kind.Relation,\n      typename: 'org.dxos.schema.anyRelation',\n      version: '0.0.0',\n      sourceSchema: DXN.make(internal.ANY_OBJECT_TYPENAME, internal.ANY_OBJECT_VERSION),\n      targetSchema: DXN.make(internal.ANY_OBJECT_TYPENAME, internal.ANY_OBJECT_VERSION),\n    },\n  }),\n) as unknown as internal.UnknownTypeSchema<Unknown, typeof Entity.Kind.Relation>;\n\n/**\n * Relation type with specific source and target types.\n */\nexport type OfShape<Source extends Obj.Unknown, Target extends Obj.Unknown, Props> = BaseRelation<Source, Target> &\n  Props;\n\n/**\n * Base type for snapshot relations (has SnapshotKindId instead of KindId).\n */\ninterface BaseRelationSnapshot<Source, Target> extends internal.AnyEntity, Endpoints<Source, Target> {\n  readonly [Entity.SnapshotKindId]: internal.EntityKind.Relation;\n  readonly id: EntityId;\n}\n\n/**\n * JSON-encoded properties for relations.\n */\nexport interface BaseRelationJson {\n  id: string;\n  [internal.ATTR_RELATION_SOURCE]: string;\n  [internal.ATTR_RELATION_TARGET]: string;\n}\n\n/**\n * Immutable snapshot of an ECHO relation.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> &\n  BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = entityInternal.RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = entityInternal.RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Get relation source type.\n */\nexport type SourceOf<A> = A extends Endpoints<infer S, infer _T> ? S : never;\n\n/**\n * Get relation target type.\n */\nexport type TargetOf<A> = A extends Endpoints<infer _S, infer T> ? T : never;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype MakePropsInternal<T extends Endpoints<any, any>> = {\n  id?: EntityId;\n  [Meta]?: Partial<internal.EntityMeta>;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Entity.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema. Accepts a `Type.AnyRelation`\n * entity (created with `Type.makeRelation`) and derives the props shape via\n * `Type.InstanceType`. Object-kind entities are rejected at the type level —\n * use `Obj.MakeProps` for those.\n */\nexport type MakeProps<S extends Type.AnyRelation> = MakePropsInternal<Type.InstanceType<S>>;\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. (deprecated; use [Obj.Meta] instead)\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 = <T extends Type.AnyRelation>(\n  type: T,\n  props: NoInfer<MakeProps<T>>,\n): Type.InstanceType<T> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  const schema = Type.getSchema(type);\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === internal.EntityKind.Relation,\n    'schema',\n    'Expected a relation schema',\n  );\n  assertArgument(props[internal.ParentId] === undefined, 'props', 'Parent is not allowed for relations');\n\n  let meta: internal.EntityMeta | undefined = undefined;\n\n  if (props[internal.MetaId] != null) {\n    meta = props[internal.MetaId] as any;\n    delete props[internal.MetaId];\n  }\n\n  const sourceDXN = internal.getObjectEchoUri(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = internal.getObjectEchoUri(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[internal.RelationSourceDXNId] = sourceDXN;\n  (props as any)[internal.RelationTargetDXNId] = targetDXN;\n\n  // Pass the type entity through as `typeSource` so the resulting instance\n  // carries a back-reference resolvable via `Relation.getType` / `Entity.getType`.\n  return internal.makeObject(schema as any, props as any, meta, type as any) as any;\n};\n\n/**\n * Test if a value is an instance of a given relation type.\n *\n * Mirrors `Obj.instanceOf` but only accepts `Type.AnyRelation` — use\n * `Obj.instanceOf` for objects and `Type.isType` for `Type.Type` entities.\n *\n * @example\n * ```ts\n * const isEmployedBy = Relation.instanceOf(EmployedBy);\n * if (isEmployedBy(relation)) {\n *   // relation is EmployedBy\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.AnyRelation>(schema: S): (value: unknown) => value is Type.InstanceType<S>;\n  <S extends Type.AnyRelation>(schema: S, value: unknown): value is Type.InstanceType<S>;\n} = ((...args: [schema: Type.AnyRelation, value?: unknown]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => internal.isInstanceOf(args[0], entity);\n  }\n  return internal.isInstanceOf(args[0], args[1]);\n}) as any;\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (internal.ATTR_RELATION_SOURCE in value || internal.ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  // Check for reactive relation (KindId) or snapshot (SnapshotKindId).\n  const kind = (value as any)[Entity.KindId] ?? (value as any)[Entity.SnapshotKindId];\n  return kind === internal.EntityKind.Relation;\n};\n\nexport const isSnapshot = (value: unknown): value is Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[Entity.SnapshotKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * @returns Relation source URI.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceURI = (value: Unknown | Snapshot): EID.EID => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(EID.isEID(uri));\n  return uri;\n};\n\n/**\n * @returns Relation target URI.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetURI = (value: Unknown | Snapshot): EID.EID => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(EID.isEID(uri));\n  return uri;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): SourceOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationSourceId];\n  if (obj === undefined) {\n    throw new Error(`Relation source could not be resolved.`);\n  }\n  return obj as SourceOf<T>;\n};\n\n/**\n * @returns Relation target.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Unknown | Snapshot>(relation: T): TargetOf<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(relation);\n  const obj = (relation as internal.InternalObjectProps)[internal.RelationTargetId];\n  if (obj === undefined) {\n    throw new Error(`Relation target could not be resolved.`);\n  }\n  return obj as TargetOf<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.update`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.update` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.update` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.update\n * Relation.update(worksFor, (obj) => {\n *   obj.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.update` for objects.\n */\nexport const update = <T extends Unknown>(relation: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(relation, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of a relation.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive relation at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(rel: T) => Snapshot<T> = internal.getSnapshot as any;\n\n//\n// Subscribe\n//\n\n/**\n * Subscribe to relation updates.\n * The callback is called synchronously when the relation is modified.\n * Only accepts reactive relations (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (rel: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(rel, callback);\n};\n\n//\n// Property Access\n//\n\n/**\n * Get a deeply nested property from a relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getValue = (rel: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return internal.getValue(rel, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  internal.setValue as any;\n\n//\n// Type\n//\n\n/**\n * Get the canonical URI of the relation. Returns `URI.URI` — today always an EID,\n * but future entity kinds may surface other URI schemes; narrow with `EID.parse(uri)`\n * or `DXN.tryMake(uri)` at the point of use. Accepts both reactive relations and snapshots.\n */\nexport const getURI = (entity: Unknown | Snapshot): URI.URI => internal.getUri(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeURI: (obj: internal.AnyProperties) => URI.URI | undefined = internal.getTypeURI;\n\n/**\n * Get the type entity (`Type.AnyRelation`) the relation was created from.\n *\n * Returns `undefined` when the relation's type isn't registered in this\n * runtime (e.g. a freshly deserialized snapshot whose type entity hasn't been\n * wired up yet, or a relation loaded from storage before its schema is known).\n * To get the Effect Schema from the returned entity, use `Type.getSchema(...)`.\n */\nexport const getType = (relation: Unknown | Snapshot): Type.AnyRelation | undefined =>\n  internal.getType(relation) as Type.AnyRelation | undefined;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the relation belongs to.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => internal.getDatabase(entity);\n\n//\n// Meta\n//\n\n/**\n * Property that accesses metadata for an entity.\n *\n * Alias for `Entity.Meta`.\n */\nexport const Meta = internal.MetaId;\n\n/**\n * Deeply read-only version of EntityMeta.\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.update` callback.\n */\nexport type Meta = internal.Meta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.update` callback).\n * Returns read-only meta when passed a regular relation or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * @returns Foreign keys for the relation from the specified source.\n * Accepts both reactive relations and snapshots.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => internal.deleteKeys(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: Ref.Ref<Tag.Tag>): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the relation is deleted.\n * Accepts both reactive relations and snapshots.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n *\n * @param options.fallback `'typename'` returns the relation's typename when no\n *   label is set (e.g. `org.dxos.type.table`).\n */\nexport const getLabel = (entity: Unknown | Snapshot, options?: internal.GetLabelOptions): string | undefined =>\n  internal.getLabel(entity, options);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  internal.setDescription(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting relations.\n * Accepts both reactive relations and snapshots.\n */\nexport type Comparator = internal.Comparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = internal.sortByLabel as Comparator;\nexport const sortByTypename: Comparator = internal.sortByTypename as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => internal.sort(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport const VersionTypeId = internal.VersionTypeId;\nexport const isVersion = internal.isVersion;\n\n/**\n * Represent relation version.\n */\nexport type Version = internal.EntityVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n"],
+  "mappings": "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",
+  "names": ["Unknown", "VersionTypeId", "addTag", "deleteKeys", "getDatabase", "getDescription", "getKeys", "getLabel", "getSnapshot", "getType", "getTypeURI", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "createJsonPath", "assertArgument", "invariant", "EID", "DXN", "assumeType", "Schema", "Record", "key", "annotations", "TypeAnnotationId", "kind", "Kind", "typename", "version", "sourceSchema", "targetSchema", "assertArgument", "internal", "getTypeAnnotation", "ParentId", "undefined", "meta", "props", "MetaId", "sourceDXN", "getObjectEchoUri", "RelationSourceDXNId", "RelationTargetDXNId", "targetDXN", "entity", "isInstanceOf", "args", "value", "assumeType", "invariant", "EID", "isEID", "uri", "relation", "RelationSourceId", "obj", "RelationTargetId", "getSnapshot", "subscribe", "getValue", "setValue", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "sortByTypename", "sort", "comparators", "VersionTypeId"]
+}

package/dist/lib/neutral/{chunk-YWXWXIE5.mjs → chunk-4Z6GET2X.mjs}

@@ -1,6 +1,6 @@
 import {
   Ref
-} from "./chunk-43Y5DOS6.mjs";
+} from "./chunk-7OAFN3OX.mjs";
 
 // src/internal/Ref/ref-array.ts
 import { isNonNullable } from "@dxos/util";
@@ -21,7 +21,7 @@ var RefArray = Object.freeze({
   * Removes the ref with the given id.
   */
   removeById: (refs, id) => {
-    const index = refs.findIndex(Ref.hasObjectId(id));
+    const index = refs.findIndex(Ref.hasEntityId(id));
     if (index >= 0) {
       refs.splice(index, 1);
     }
@@ -31,4 +31,4 @@ var RefArray = Object.freeze({
 export {
   RefArray
 };
-//# sourceMappingURL=chunk-YWXWXIE5.mjs.map
+//# sourceMappingURL=chunk-4Z6GET2X.mjs.map

package/dist/lib/neutral/chunk-4Z6GET2X.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Ref/ref-array.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { type EntityId } from '@dxos/keys';\nimport { isNonNullable } from '@dxos/util';\n\nimport { type AnyEntity } from '../common/types';\nimport { Ref } from './ref';\n\n/**\n * Helper functions for working with arrays of refs.\n */\nexport const RefArray = Object.freeze({\n  /**\n   * @returns all resolved targets.\n   */\n  targets: <T extends AnyEntity>(refs: readonly Ref<T>[]): T[] => {\n    return refs.map((ref) => ref.target).filter(isNonNullable);\n  },\n\n  /**\n   * Load all referenced objects.\n   */\n  loadAll: <T extends AnyEntity>(refs: readonly Ref<T>[]): Promise<T[]> => {\n    return Promise.all(refs.map((ref) => ref.load()));\n  },\n\n  /**\n   * Removes the ref with the given id.\n   */\n  removeById: (refs: Ref<AnyEntity>[], id: EntityId) => {\n    const index = refs.findIndex(Ref.hasEntityId(id));\n    if (index >= 0) {\n      refs.splice(index, 1);\n    }\n  },\n});\n"],
+  "mappings": ";;;;;AAKA,SAASA,qBAAqB;AAQvB,IAAMC,WAAWC,OAAOC,OAAO;;;;EAIpCC,SAAS,CAAsBC,SAAAA;AAC7B,WAAOA,KAAKC,IAAI,CAACC,QAAQA,IAAIC,MAAM,EAAEC,OAAOC,aAAAA;EAC9C;;;;EAKAC,SAAS,CAAsBN,SAAAA;AAC7B,WAAOO,QAAQC,IAAIR,KAAKC,IAAI,CAACC,QAAQA,IAAIO,KAAI,CAAA,CAAA;EAC/C;;;;EAKAC,YAAY,CAACV,MAAwBW,OAAAA;AACnC,UAAMC,QAAQZ,KAAKa,UAAUC,IAAIC,YAAYJ,EAAAA,CAAAA;AAC7C,QAAIC,SAAS,GAAG;AACdZ,WAAKgB,OAAOJ,OAAO,CAAA;IACrB;EACF;AACF,CAAA;",
+  "names": ["isNonNullable", "RefArray", "Object", "freeze", "targets", "refs", "map", "ref", "target", "filter", "isNonNullable", "loadAll", "Promise", "all", "load", "removeById", "id", "index", "findIndex", "Ref", "hasEntityId", "splice"]
+}

package/dist/lib/neutral/{chunk-ANHVGJI4.mjs → chunk-7LOUAPYZ.mjs}

@@ -5,17 +5,21 @@ import {
 // src/Key.ts
 var Key_exports = {};
 __export(Key_exports, {
+  EID: () => EID,
+  EntityId: () => EntityId,
   ForeignKey: () => ForeignKey,
-  ObjectId: () => ObjectId,
-  SpaceId: () => SpaceId
+  SpaceId: () => SpaceId,
+  URI: () => URI
 });
 import { ForeignKey } from "@dxos/echo-protocol";
-import { SpaceId, ObjectId } from "@dxos/keys";
+import { EID, EntityId, SpaceId, URI } from "@dxos/keys";
 
 export {
   Key_exports,
   ForeignKey,
+  EID,
+  EntityId,
   SpaceId,
-  ObjectId
+  URI
 };
-//# sourceMappingURL=chunk-ANHVGJI4.mjs.map
+//# sourceMappingURL=chunk-7LOUAPYZ.mjs.map