@dxos/echo 0.8.4-main.9735255 → 0.8.4-main.9be5663bfe

package/dist/lib/neutral/chunk-WVLOCXB5.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Entity.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport type { DXN, ObjectId } from '@dxos/keys';\n\nimport * as internal from './internal';\nimport type * as Relation from './Relation';\n\n// Re-export KindId and SnapshotKindId from internal.\nexport const KindId = internal.KindId;\nexport type KindId = typeof internal.KindId;\nexport const SnapshotKindId = internal.SnapshotKindId;\nexport type SnapshotKindId = typeof internal.SnapshotKindId;\n\n// NOTE: Relation does not extend Obj so that, for example, we can prevent Relations from being used as source and target objects.\n//  However, we generally refer to Obj and Relation instances as \"objects\",\n//  and many API methods accept both Obj.Unknown and Relation.Unknown (i.e., Entity.Unknown) instances.\n\nexport const Kind = internal.EntityKind;\nexport type Kind = internal.EntityKind;\nexport const KindSchema = internal.EntityKindSchema;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n * NOTE: Needed to make `isRelation` and `isObject` checks work.\n */\nexport interface OfKind<K extends Kind> {\n  readonly [KindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Assigns a snapshot kind to an Object or Relation snapshot.\n */\nexport interface SnapshotOfKind<K extends Kind> {\n  readonly [SnapshotKindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Obj or Relation with a specific set of properties.\n */\nexport type Entity<Props> = OfKind<Kind> & Props;\n\n/**\n * Unknown Obj or Relation (reactive).\n */\nexport interface Unknown extends OfKind<Kind> {}\n\n/**\n * Snapshot of an Obj or Relation.\n * Branded with SnapshotKindId instead of KindId.\n */\nexport interface Snapshot extends SnapshotOfKind<Kind> {}\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 *\n * This type is very permissive and allows accessing any property on the object.\n * We should move to Obj.Unknown that is not permissive and requires explicit instanceof checks..\n */\nexport interface Any extends OfKind<Kind> {\n  [key: string]: unknown;\n}\n\n/**\n * Returns all properties of an object or relation except for the id and kind.\n */\nexport type Properties<T> = Omit<T, 'id' | KindId | Relation.Source | Relation.Target>;\n\n/**\n * Check if a value is an ECHO entity (object or relation).\n * Returns `false` for snapshots.\n */\nexport const isEntity = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[KindId] !== undefined;\n};\n\n/**\n * Check if a value is an ECHO entity snapshot.\n * Returns `false` for entities.\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)[SnapshotKindId] !== undefined;\n};\n\n// TODO(dmaretskyi): Type introspection -- move to kind.\nexport const getKind = internal.getEntityKind;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport const Meta: unique symbol = internal.MetaId as any;\n\n/**\n * Property that accesses metadata for an entity.\n */\nexport type Meta = typeof Meta;\n\n//\n// Entity-level functions that work on any entity (object or relation).\n// Use these when you don't know or care about the specific entity kind.\n// For kind-specific functions, use Obj.* or Relation.*.\n//\n\n/**\n * JSON representation of an entity.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Get the DXN of an entity (object or relation).\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => internal.getDXN(entity);\n\n/**\n * Get the DXN of an entity's type.\n */\nexport const getTypeDXN = internal.getTypeDXN;\n\n/**\n * Get the typename of an entity's type.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n/**\n * Get the database an entity belongs to.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): any | undefined => internal.getDatabase(entity);\n\n/**\n * Get the metadata for an entity.\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(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): internal.ObjectMeta;\nexport function getMeta(entity: Unknown | Snapshot): internal.ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): internal.ObjectMeta | internal.ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * Get foreign keys for an entity from the specified source.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);\n\n/**\n * Check if an entity is deleted.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n/**\n * Get the label of an entity.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Get the description of an entity.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Convert an entity to its JSON representation.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n/**\n * Subscribe to changes on an entity (object or relation).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (entity: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(entity, callback);\n};\n\n//\n// Change\n//\n\n/**\n * Used to provide a mutable view of an entity within `Entity.change`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an entity (object or relation) within a change context.\n *\n * Entities are read-only by default. Mutations are batched and notifications fire\n * when the callback completes. Direct mutations outside of `Entity.change` will throw\n * at runtime.\n *\n * @param entity - The echo entity (object or relation) to mutate.\n * @param callback - Receives a mutable view of the entity. All mutations must occur here.\n *\n * @example\n * ```typescript\n * // Mutate within Entity.change\n * Entity.change(entity, (obj) => {\n *   obj.name = 'Updated';\n *   obj.count = 42;\n * });\n *\n * // Direct mutation throws\n * entity.name = 'Bob'; // Error: Cannot modify outside Entity.change()\n * ```\n *\n * Note: For type-specific operations, prefer `Obj.change` or `Relation.change`.\n */\nexport const change = <T extends Unknown>(entity: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(entity, callback);\n};\n\n/**\n * Add a tag to an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;gBAAAA;EAAA;;wBAAAC;EAAA,cAAAC;EAAA,cAAAC;EAAA,cAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,eAAAC;EAAA;kBAAAC;EAAA;oBAAAC;EAAA,mBAAAC;EAAA,iBAAAC;EAAA;;mBAAAC;EAAA,iBAAAC;EAAA;;AAaO,IAAMC,UAAkBA;AAExB,IAAMC,kBAA0BA;AAOhC,IAAMC,OAAgBC;AAEtB,IAAMC,aAAsBC;AAyD5B,IAAMC,WAAW,CAACC,UAAAA;AACvB,MAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;AAC/C,WAAO;EACT;AACA,SAAQA,MAAcP,OAAAA,MAAYQ;AACpC;AAMO,IAAMC,aAAa,CAACF,UAAAA;AACzB,MAAI,OAAOA,UAAU,YAAYA,UAAU,MAAM;AAC/C,WAAO;EACT;AACA,SAAQA,MAAcN,eAAAA,MAAoBO;AAC5C;AAGO,IAAME,UAAmBC;AAKzB,IAAMC,OAA+BC;AAqBrC,IAAMC,UAAS,CAACC,WAA6CD,OAAOC,MAAAA;AAKpE,IAAMC,cAAsBA;AAK5B,IAAMC,eAAc,CAACF,WAA4DE,YAAYF,MAAAA;AAK7F,IAAMG,eAAc,CAACH,WAAyDG,YAAYH,MAAAA;AAU1F,SAASI,QAAQJ,QAA6C;AACnE,SAAgBK,eAAeL,MAAAA;AACjC;AAKO,IAAMM,WAAU,CAACN,QAA4BO,WAA0CD,QAAQN,QAAQO,MAAAA;AAKvG,IAAMC,aAAY,CAACR,WAAiDQ,UAAUR,MAAAA;AAK9E,IAAMS,YAAW,CAACT,WAA4DS,SAAST,MAAAA;AAKvF,IAAMU,kBAAiB,CAACV,WAA4DU,eAAeV,MAAAA;AAKnG,IAAMW,SAAS,CAACX,WAA8CY,aAAaZ,MAAAA;AAM3E,IAAMa,aAAY,CAACb,QAAiBc,aAAAA;AACzC,SAAgBD,UAAUb,QAAQc,QAAAA;AACpC;AAmCO,IAAMC,UAAS,CAAoBf,QAAWc,aAAAA;AACnDE,EAASD,OAAOf,QAAQc,QAAAA;AAC1B;AAMO,IAAMG,UAAS,CAACjB,QAA0BkB,QAA+BD,OAAOjB,QAAQkB,GAAAA;AAMxF,IAAMC,aAAY,CAACnB,QAA0BkB,QAA+BC,UAAUnB,QAAQkB,GAAAA;",
+  "names": ["KindId", "SnapshotKindId", "addTag", "change", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "subscribe", "KindId", "SnapshotKindId", "Kind", "EntityKind", "KindSchema", "EntityKindSchema", "isEntity", "value", "undefined", "isSnapshot", "getKind", "getEntityKind", "Meta", "MetaId", "getDXN", "entity", "getTypeDXN", "getTypename", "getDatabase", "getMeta", "getMetaChecked", "getKeys", "source", "isDeleted", "getLabel", "getDescription", "toJSON", "objectToJSON", "subscribe", "callback", "change", "internal", "addTag", "tag", "removeTag"]
+}

package/dist/lib/neutral/chunk-YS6Q3XAD.mjs

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Extension.ts
+var Extension_exports = {};
+__export(Extension_exports, {
+  Key: () => Key,
+  TypeId: () => TypeId,
+  Values: () => Values,
+  get: () => get,
+  make: () => make,
+  set: () => set
+});
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+var TypeId = "~@dxos/echo/Extension";
+var make = (key, valueSchema) => {
+  return {
+    [TypeId]: {},
+    key: Key.make(key),
+    valueSchema
+  };
+};
+var Key = Schema.String.pipe(Schema.brand("~@dxos/echo/ExtensionKey"));
+var Values = Schema.Record({
+  key: Key,
+  value: Schema.Unknown
+});
+var get = Function.dual(2, (values, extension) => {
+  if (!(extension.key in values)) {
+    return Option.none();
+  }
+  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);
+});
+var set = Function.dual(3, (values, extension, value) => {
+  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);
+});
+
+export {
+  TypeId,
+  make,
+  Key,
+  Values,
+  get,
+  set,
+  Extension_exports
+};
+//# sourceMappingURL=chunk-YS6Q3XAD.mjs.map

package/dist/lib/neutral/chunk-YS6Q3XAD.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Extension.ts"],
+  "sourcesContent": ["// @import-as-namespace\n//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\n// @import-as-namespace\n\n/**\n * Extensions allow objects to contain typed properties that are not part of the schema.\n */\n\nexport const TypeId = '~@dxos/echo/Extension' as const;\nexport type TypeId = typeof TypeId;\n\nexport interface Extension<T> extends Record<\n  TypeId,\n  {\n    _Type: T;\n  }\n> {\n  readonly [TypeId]: {\n    _Type: T;\n  };\n\n  readonly key: Key;\n  readonly valueSchema: Schema.Schema<T>;\n}\n\n/**\n * Create a new typed extension.\n *\n * ```ts\n * const ColorExtension = Extension.make('color', Schema.String);\n *\n * const obj = Obj.make(Person, {\n *   [Obj.Meta]: { keys: [{ source: 'external', id: '123' }] },\n *   name: 'John',\n *   email: 'john@example.com',\n * });\n *\n * Obj.change(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n *\n * console.log(Extension.get(obj.extensions, ColorExtension)); // 'red'\n * ```\n */\nexport const make = <S extends Schema.Schema.AnyNoContext>(\n  key: string,\n  valueSchema: S,\n): Extension<Schema.Schema.Type<S>> => {\n  return {\n    [TypeId]: {} as any,\n    key: Key.make(key),\n    valueSchema,\n  };\n};\n\n/**\n * Unique identifier for an extension.\n */\n// TODO(dmaretskyi): filter to be fully qualified: (e.g., org.dxos.extension.color)\nexport const Key = Schema.String.pipe(Schema.brand('~@dxos/echo/ExtensionKey'));\nexport type Key = Schema.Schema.Type<typeof Key>;\n\n/**\n * Set of extension values.\n *\n * Can be used inside an object/relation schema:\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n *   extensions: Extension.Values,\n * });\n * ```\n */\nexport const Values = Schema.Record({ key: Key, value: Schema.Unknown });\nexport interface Values extends Schema.Schema.Type<typeof Values> {}\n\n/**\n * Get the value of an extension from a set of values.\n */\nexport const get: {\n  <T>(extension: Extension<T>): (values: Values) => Option.Option<T>;\n  <T>(values: Values, extension: Extension<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(extension: Extension<T>) => (values: Values) => Option.Option<T>,\n  <T>(values: Values, extension: Extension<T>) => Option.Option<T>\n>(2, (values, extension) => {\n  if (!(extension.key in values)) {\n    return Option.none();\n  }\n\n  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);\n});\n\n/**\n * Set the value of an extension in a set of values.\n *\n * Can also be used within Obj.change callback:\n *\n * ```ts\n * Obj.change(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n * ```\n */\nexport const set: {\n  <T>(extension: Extension<T>, value: T): (values: Values) => void;\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T): void;\n} = Function.dual<\n  <T>(extension: Extension<T>, value: T) => (values: Values) => void,\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T) => void\n>(3, (values, extension, value) => {\n  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);\n});\n"],
+  "mappings": ";;;;;AAAA;;;;;;;;;AAKA,YAAYA,cAAc;AAC1B,YAAYC,YAAY;AACxB,YAAYC,YAAY;AASjB,IAAMC,SAAS;AAoCf,IAAMC,OAAO,CAClBC,KACAC,gBAAAA;AAEA,SAAO;IACL,CAACH,MAAAA,GAAS,CAAC;IACXE,KAAKE,IAAIH,KAAKC,GAAAA;IACdC;EACF;AACF;AAMO,IAAMC,MAAaC,cAAOC,KAAYC,aAAM,0BAAA,CAAA;AAe5C,IAAMC,SAAgBC,cAAO;EAAEP,KAAKE;EAAKM,OAAcC;AAAQ,CAAA;AAM/D,IAAMC,MAGAC,cAGX,GAAG,CAACC,QAAQC,cAAAA;AACZ,MAAI,EAAEA,UAAUb,OAAOY,SAAS;AAC9B,WAAcE,YAAI;EACpB;AAEA,SAAgBV,cAAKQ,OAAOC,UAAUb,GAAG,GAAUe,yBAAkBF,UAAUZ,WAAW,GAAUe,WAAI;AAC1G,CAAA;AAaO,IAAMC,MAGAN,cAGX,GAAG,CAACC,QAAQC,WAAWL,UAAAA;AACvBI,SAAOC,UAAUb,GAAG,IAAWkB,kBAAWL,UAAUZ,WAAW,EAAEO,KAAAA;AACnE,CAAA;",
+  "names": ["Function", "Option", "Schema", "TypeId", "make", "key", "valueSchema", "Key", "String", "pipe", "brand", "Values", "Record", "value", "Unknown", "get", "dual", "values", "extension", "none", "decodeUnknownSync", "some", "set", "encodeSync"]
+}

package/dist/lib/neutral/{chunk-VR4A4WGG.mjs → chunk-YSLSJ7QS.mjs}

@@ -1,6 +1,14 @@
+import {
+  Unknown
+} from "./chunk-ZGVZNBBJ.mjs";
+import {
+  KindId,
+  SnapshotKindId
+} from "./chunk-WVLOCXB5.mjs";
 import {
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
+  EchoRelationSchema,
   MetaId,
   RelationSourceDXNId,
   RelationSourceId,
@@ -12,37 +20,38 @@ import {
   deleteKeys,
   getDXN,
   getDatabase,
-  getDescription,
   getKeys,
-  getLabel,
   getMetaChecked,
   getObjectDXN,
   getSnapshot,
+  getValue,
   isDeleted,
   isVersion,
   makeObject,
   objectToJSON,
   removeTag,
-  setDescription,
-  setLabel,
   setValue,
   sort,
   sortByLabel,
   sortByTypename,
   subscribe,
   version
-} from "./chunk-SU2LVM7J.mjs";
+} from "./chunk-FW7UJX25.mjs";
 import {
+  ParentId,
+  getDescription,
+  getLabel,
   getSchema,
   getTypeAnnotation,
   getTypeDXN,
-  getTypename
-} from "./chunk-CUDIBUM4.mjs";
+  getTypename,
+  setDescription,
+  setLabel
+} from "./chunk-6URFBQJH.mjs";
 import {
   EntityKind,
-  KindId,
-  SnapshotKindId
-} from "./chunk-YQYMWZAD.mjs";
+  SchemaKindId
+} from "./chunk-TBKX6JQO.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -50,9 +59,11 @@ import {
 // src/Relation.ts
 var Relation_exports = {};
 __export(Relation_exports, {
+  Meta: () => Meta,
   Source: () => Source,
   Target: () => Target,
-  VersionTypeId: () => VersionTypeId,
+  Unknown: () => Unknown3,
+  VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
   change: () => change2,
   deleteKeys: () => deleteKeys2,
@@ -70,10 +81,11 @@ __export(Relation_exports, {
   getTargetDXN: () => getTargetDXN,
   getTypeDXN: () => getTypeDXN2,
   getTypename: () => getTypename2,
-  getValue: () => getValue,
+  getValue: () => getValue2,
   isDeleted: () => isDeleted2,
   isRelation: () => isRelation,
-  isVersion: () => isVersion,
+  isSnapshot: () => isSnapshot,
+  isVersion: () => isVersion2,
   make: () => make,
   removeTag: () => removeTag2,
   setDescription: () => setDescription2,
@@ -86,16 +98,39 @@ __export(Relation_exports, {
   toJSON: () => toJSON,
   version: () => version2
 });
+import * as Schema from "effect/Schema";
 import { raise } from "@dxos/debug";
-import { createJsonPath, getValue as getValue$ } from "@dxos/effect";
+import { createJsonPath } from "@dxos/effect";
 import { assertArgument, invariant } from "@dxos/invariant";
 import { 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({
+  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.anyRelation",
+    version: "0.0.0",
+    source: Unknown,
+    target: Unknown
+  }),
+  (schema) => Object.assign(schema, {
+    [SchemaKindId]: schema[SchemaKindId]
+  })
+);
 var Source = RelationSourceId;
 var Target = RelationTargetId;
-var make = (schema, props, meta) => {
+var make = (schema, props) => {
   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;
   if (props[MetaId] != null) {
     meta = props[MetaId];
     delete props[MetaId];
@@ -116,13 +151,19 @@ var isRelation = (value) => {
   const kind = value[KindId] ?? value[SnapshotKindId];
   return kind === EntityKind.Relation;
 };
+var isSnapshot = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return value[SnapshotKindId] === EntityKind.Relation;
+};
 var getSourceDXN = (value) => {
   assertArgument(isRelation(value), "Expected a relation");
   assumeType(value);
   const dxn = value[RelationSourceDXNId];
   invariant(dxn instanceof DXN, void 0, {
     F: __dxlog_file,
-    L: 188,
+    L: 214,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -137,7 +178,7 @@ var getTargetDXN = (value) => {
   const dxn = value[RelationTargetDXNId];
   invariant(dxn instanceof DXN, void 0, {
     F: __dxlog_file,
-    L: 201,
+    L: 227,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -152,7 +193,7 @@ var getSource = (relation) => {
   const obj = relation[RelationSourceId];
   invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
     F: __dxlog_file,
-    L: 214,
+    L: 240,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -167,7 +208,7 @@ var getTarget = (relation) => {
   const obj = relation[RelationTargetId];
   invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
     F: __dxlog_file,
-    L: 227,
+    L: 253,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -183,8 +224,8 @@ var getSnapshot2 = getSnapshot;
 var subscribe2 = (rel, callback) => {
   return subscribe(rel, callback);
 };
-var getValue = (rel, path) => {
-  return getValue$(rel, createJsonPath(path));
+var getValue2 = (rel, path) => {
+  return getValue(rel, createJsonPath(path));
 };
 var setValue2 = setValue;
 var getDXN2 = (entity) => getDXN(entity);
@@ -192,6 +233,7 @@ var getTypeDXN2 = getTypeDXN;
 var getSchema2 = getSchema;
 var getTypename2 = (entity) => getTypename(entity);
 var getDatabase2 = (entity) => getDatabase(entity);
+var Meta = MetaId;
 function getMeta(entity) {
   return getMetaChecked(entity);
 }
@@ -208,13 +250,17 @@ var toJSON = (entity) => objectToJSON(entity);
 var sortByLabel2 = sortByLabel;
 var sortByTypename2 = sortByTypename;
 var sort2 = (...comparators) => sort(...comparators);
+var VersionTypeId2 = VersionTypeId;
+var isVersion2 = isVersion;
 var version2 = (entity) => version(entity);
 
 export {
+  Unknown3 as Unknown,
   Source,
   Target,
   make,
   isRelation,
+  isSnapshot,
   getSourceDXN,
   getTargetDXN,
   getSource,
@@ -222,13 +268,14 @@ export {
   change2 as change,
   getSnapshot2 as getSnapshot,
   subscribe2 as subscribe,
-  getValue,
+  getValue2 as getValue,
   setValue2 as setValue,
   getDXN2 as getDXN,
   getTypeDXN2 as getTypeDXN,
   getSchema2 as getSchema,
   getTypename2 as getTypename,
   getDatabase2 as getDatabase,
+  Meta,
   getMeta,
   getKeys2 as getKeys,
   deleteKeys2 as deleteKeys,
@@ -243,7 +290,9 @@ export {
   sortByLabel2 as sortByLabel,
   sortByTypename2 as sortByTypename,
   sort2 as sort,
+  VersionTypeId2 as VersionTypeId,
+  isVersion2 as isVersion,
   version2 as version,
   Relation_exports
 };
-//# sourceMappingURL=chunk-VR4A4WGG.mjs.map
+//# sourceMappingURL=chunk-YSLSJ7QS.mjs.map

package/dist/lib/neutral/chunk-YSLSJ7QS.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 { DXN, type ObjectId } 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 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: Type.Relation<Unknown, Obj.Any, Obj.Any> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  // TODO(dmaretskyi): Clean this up.\n  // NOTE: The EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.\n  //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.\n  internal.EchoRelationSchema({\n    typename: 'org.dxos.schema.anyRelation',\n    version: '0.0.0',\n    source: Obj.Unknown,\n    target: Obj.Unknown,\n  }),\n  (schema) =>\n    Object.assign(schema, {\n      [internal.SchemaKindId]: (schema as any)[internal.SchemaKindId],\n    }) as unknown as Type.Relation<Unknown, Obj.Any, Obj.Any>,\n);\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: ObjectId;\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 Unknown> = {\n  id?: ObjectId;\n  [Meta]?: internal.ObjectMeta;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Entity.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema.\n * Takes a schema type (created with Type.Relation) and extracts the props type.\n */\nexport type MakeProps<S extends Type.AnyRelation> = MakePropsInternal<Schema.Schema.Type<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 = <S extends Type.AnyRelation>(\n  schema: S,\n  props: NoInfer<MakeProps<S>>,\n): Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation> => {\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.ObjectMeta | 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.getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = internal.getObjectDXN(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  return internal.makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\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 DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\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  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\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  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\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.change`.\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.change` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.change` 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.change\n * Relation.change(worksFor, (obj) => {\n *   obj.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.change` for objects.\n */\nexport const change = <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.change` 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 DXN of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => internal.getDXN(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeDXN = internal.getTypeDXN;\n\n/**\n * Get the schema of the relation.\n * Returns the branded ECHO schema used to create the relation.\n */\nexport const getSchema: (rel: unknown | undefined) => Type.AnyEntity | undefined = internal.getSchema as any;\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 ObjectMeta.\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.change` 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.change` 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.change` 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.change` 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: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.change` 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: string): 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 */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.change` 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.change` 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", "change", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "createJsonPath", "assertArgument", "invariant", "DXN", "assumeType", "Unknown", "Struct", "id", "String", "pipe", "extend", "Record", "key", "value", "EchoRelationSchema", "typename", "version", "source", "target", "schema", "Object", "assign", "SchemaKindId", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "props", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "Relation", "ParentId", "undefined", "meta", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "makeObject", "isRelation", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "KindId", "SnapshotKindId", "isSnapshot", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "getTarget", "change", "callback", "internal", "getSnapshot", "subscribe", "rel", "getValue", "path", "createJsonPath", "setValue", "getDXN", "entity", "getTypeDXN", "getSchema", "getTypename", "getDatabase", "Meta", "getMeta", "getMetaChecked", "getKeys", "deleteKeys", "addTag", "tag", "removeTag", "isDeleted", "getLabel", "setLabel", "label", "getDescription", "setDescription", "description", "toJSON", "objectToJSON", "sortByLabel", "sortByTypename", "sort", "comparators", "VersionTypeId", "isVersion"]
+}