@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/dist/lib/neutral/{chunk-HBUZJNZO.mjs → chunk-LWXVKPPW.mjs}

@@ -1,57 +1,62 @@
 import {
-  Unknown
-} from "./chunk-B4BASU6W.mjs";
-import {
+  Kind,
   KindId,
   SnapshotKindId
-} from "./chunk-T6W2LEZU.mjs";
+} from "./chunk-SBVFRTST.mjs";
+import {
+  getSchema
+} from "./chunk-T6E37YIP.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,
+  makeRelation,
   objectToJSON,
-  removeTag,
   setValue,
   sort,
   sortByLabel,
   sortByTypename,
   subscribe,
   version
-} from "./chunk-MOR5ERFM.mjs";
+} from "./chunk-7FPIAJIV.mjs";
+import {
+  addTag,
+  deleteKeys,
+  getKeys,
+  getMetaChecked,
+  removeTag
+} from "./chunk-4ZUHOTCG.mjs";
 import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  MetaId,
   ParentId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  TypeAnnotationId,
+  getDatabase,
   getDescription,
   getLabel,
-  getSchema,
+  getObjectEchoUri,
+  getType,
   getTypeAnnotation,
-  getTypeDXN,
+  getTypeURI,
   getTypename,
+  getUri,
+  isInstanceOf,
   setDescription,
   setLabel
-} from "./chunk-2KHZ36F5.mjs";
+} from "./chunk-R5W6DXR4.mjs";
 import {
-  EntityKind,
-  SchemaKindId
-} from "./chunk-TBKX6JQO.mjs";
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  EntityKind
+} from "./chunk-O6BH7EPN.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -62,26 +67,27 @@ __export(Relation_exports, {
   Meta: () => Meta,
   Source: () => Source,
   Target: () => Target,
-  Unknown: () => Unknown3,
+  Unknown: () => Unknown2,
   VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
-  change: () => change2,
+  atom: () => atom,
   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,
-  getValue: () => getValue2,
+  getURI: () => getURI,
+  getValue: () => getValue,
+  instanceOf: () => instanceOf,
   isDeleted: () => isDeleted2,
   isRelation: () => isRelation,
   isSnapshot: () => isSnapshot,
@@ -96,38 +102,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 { SchemaEx } 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({
+}).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 +137,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,35 +165,19 @@ 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: 121, 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: 132, S: void 0, A: ["EID.isEID(uri)", ""] });
+  return uri;
 };
 var getSource = (relation) => {
   assertArgument(isRelation(relation), "Expected a relation");
@@ -205,20 +197,20 @@ var getTarget = (relation) => {
   }
   return obj;
 };
-var change2 = (relation, callback) => {
+var update = (relation, callback) => {
   change(relation, callback);
 };
 var getSnapshot2 = getSnapshot;
 var subscribe2 = (rel, callback) => {
   return subscribe(rel, callback);
 };
-var getValue2 = (rel, path) => {
-  return getValue(rel, createJsonPath(path));
+var getValue = (rel, path) => {
+  return SchemaEx.getValue(rel, SchemaEx.createJsonPath(path));
 };
 var setValue2 = setValue;
-var getDXN2 = (entity) => getDXN(entity);
-var getTypeDXN2 = getTypeDXN;
-var getSchema2 = getSchema;
+var getURI = (entity, options) => getUri(entity, options);
+var getTypeURI2 = getTypeURI;
+var getType2 = (relation) => getType(relation);
 var getTypename2 = (entity) => getTypename(entity);
 var getDatabase2 = (entity) => getDatabase(entity);
 var Meta = MetaId;
@@ -230,7 +222,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);
@@ -241,26 +233,28 @@ var sort2 = (...comparators) => sort(...comparators);
 var VersionTypeId2 = VersionTypeId;
 var isVersion2 = isVersion;
 var version2 = (entity) => version(entity);
+var atom = makeRelation;
 
 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,
+  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,
@@ -281,6 +275,7 @@ export {
   VersionTypeId2 as VersionTypeId,
   isVersion2 as isVersion,
   version2 as version,
+  atom,
   Relation_exports
 };
-//# sourceMappingURL=chunk-HBUZJNZO.mjs.map
+//# sourceMappingURL=chunk-LWXVKPPW.mjs.map

package/dist/lib/neutral/chunk-LWXVKPPW.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 { SchemaEx } 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 objInternal from './internal/Obj';\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 SchemaEx.getValue(rel, SchemaEx.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 *\n * @param options.prefer - Controls the URI form (see {@link internal.GetURIOptions}).\n */\nexport const getURI = (entity: Unknown | Snapshot, options?: internal.GetURIOptions): URI.URI =>\n  internal.getUri(entity, options);\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\n//\n// Atoms\n//\n\nexport const atom = objInternal.makeRelation;\n"],
+  "mappings": "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",
+  "names": ["Unknown", "VersionTypeId", "addTag", "deleteKeys", "getDatabase", "getDescription", "getKeys", "getLabel", "getSnapshot", "getType", "getTypeURI", "getTypename", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "SchemaEx", "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", "setValue", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "sortByTypename", "sort", "comparators", "VersionTypeId"]
+}

package/dist/lib/neutral/{chunk-BVOFLCVF.mjs → chunk-MZ7K3MLL.mjs}

@@ -1,10 +1,10 @@
 import {
   RefArray
-} from "./chunk-OS35K56T.mjs";
+} from "./chunk-5SUJPHAE.mjs";
 import {
   Ref,
   getSchemaReference
-} from "./chunk-G3IQMKF7.mjs";
+} from "./chunk-WTQJHC75.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -14,7 +14,8 @@ var Ref_exports = {};
 __export(Ref_exports, {
   Array: () => Array,
   Ref: () => Ref2,
-  fromDXN: () => fromDXN,
+  fromURI: () => fromURI,
+  hasEntityId: () => hasEntityId,
   isRef: () => isRef,
   isRefType: () => isRefType,
   make: () => make
@@ -25,7 +26,8 @@ var Ref2 = Ref;
 var Array = RefArray;
 var isRef = Ref.isRef;
 var make = Ref.make;
-var fromDXN = Ref.fromDXN;
+var fromURI = (uri) => Ref.fromURI(uri);
+var hasEntityId = Ref.hasEntityId;
 var isRefType = (ast) => {
   return SchemaAST.getAnnotation(ast, SchemaAST.JSONSchemaAnnotationId).pipe(Option.flatMap((jsonSchema) => "$id" in jsonSchema ? Option.some(jsonSchema) : Option.none()), Option.flatMap((jsonSchema) => {
     const { typename } = getSchemaReference(jsonSchema) ?? {};
@@ -38,8 +40,9 @@ export {
   Array,
   isRef,
   make,
-  fromDXN,
+  fromURI,
+  hasEntityId,
   isRefType,
   Ref_exports
 };
-//# sourceMappingURL=chunk-BVOFLCVF.mjs.map
+//# sourceMappingURL=chunk-MZ7K3MLL.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport type * as internal from './internal';\nimport * as refInternal from './internal/Ref';\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Obj from './Obj';\n// eslint-disable-next-line @dxos/rules/import-as-namespace\nimport type * as TypeNs from './Type';\n\n/**\n * Instance type for a reference.\n *\n * Reference can point to any object or relation.\n * References are lazy loaded.\n *\n * `ref.dxn` is the DXN of the referenced object.\n *\n * @example\n * ```ts\n * const taskRef: Ref<Task> = Ref.make(task);\n *\n * await taskRef.load(); // Returns Promise<Task>\n * yield* Database.load(taskRef); // Effectful version.\n *\n * database.makeRef(dxn); // Create a ref from a DXN.\n * ```\n */\nexport type Ref<T> = refInternal.Ref<T>;\nexport type Unknown = refInternal.Ref<Obj.Unknown>;\n\n/**\n * Factory function to create a Ref schema for the given target schema.\n * Use this in schema definitions to declare reference fields.\n *\n * @example\n * ```ts\n * const Task = Schema.Struct({\n *   assignee: Ref.Ref(Person),  // Creates a Ref schema\n * }).pipe(Type.makeObject(DXN.make('com.example.type.task', '0.1.0')));\n * ```\n */\nexport const Ref: {\n  <S extends TypeNs.AnyObj | TypeNs.AnyRelation>(type: S): RefSchema<TypeNs.InstanceType<S> & Obj.Unknown>;\n\n  // `Type.Type` entities (the meta-schema kind) can be referenced too — e.g. a\n  // trigger that points to a stored function/workflow definition.\n  <T extends TypeNs.Type<any>>(type: T): RefSchema<TypeNs.InstanceType<T>>;\n\n  // Schema-side overload for the well-known \"any object\" / \"any relation\" schemas.\n  // Other raw `Schema.Schema` values are intentionally rejected — callers should\n  // pass a `Type.Type` entity instead.\n  <S extends internal.UnknownTypeSchema<any, any>>(schema: S): RefSchema<Schema.Schema.Type<S> & Obj.Unknown>;\n} = refInternal.Ref as any;\n\nexport const Array = refInternal.RefArray;\n\n/**\n * TypeScript type for a Ref schema.\n * This is the type of the SCHEMA itself, not the runtime ref instance.\n * For the instance type, use `Ref.Ref<T>` from the Ref module.\n *\n * @example\n * ```ts\n * // Schema type annotation (rarely needed, usually inferred):\n * const refSchema: Ref.RefSchema<typeof Task> = Ref.Ref(Task);\n *\n * // Instance type annotation (use Ref.Ref instead):\n * const refInstance: Ref.Ref<Task> = Ref.make(task);\n * ```\n */\n// TODO(dmaretskyi): Investigate if we can remove this type.\n//                   Post DX-836 it will become just `Schema.Schema<Ref.Ref<T>>`.\n//                   NOTE: This could be Type.Ref<T> instead, but since it going to be removed, it's better to keep it here, self-contained.\nexport interface RefSchema<T extends Entity.Unknown> extends refInternal.RefSchema<T> {}\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Unknown> = R extends refInternal.Ref<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = refInternal.RefResolver;\n\nexport const isRef: (value: unknown) => value is Unknown = refInternal.Ref.isRef;\n\nexport const make = refInternal.Ref.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept URI.\nexport const fromURI = (uri: URI.URI): refInternal.Ref<any> => refInternal.Ref.fromURI(uri);\n\nexport const hasEntityId = refInternal.Ref.hasEntityId;\n\n// TODO(wittjosiah): Factor out?\nexport const isRefType = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation<JsonSchema.JsonSchema>(ast, SchemaAST.JSONSchemaAnnotationId).pipe(\n    Option.flatMap((jsonSchema) => ('$id' in jsonSchema ? Option.some(jsonSchema) : Option.none())),\n    Option.flatMap((jsonSchema) => {\n      const { typename } = refInternal.getSchemaReference(jsonSchema) ?? {};\n      return typename ? Option.some(true) : Option.some(false);\n    }),\n    Option.getOrElse(() => false),\n  );\n};\n"],
+  "mappings": ";;;;;;;;;;;;AAAA;;;aAAAA;EAAA;;;;;;AAMA,YAAYC,YAAY;AAExB,YAAYC,eAAe;AA4CpB,IAAMC,OAWGA;AAET,IAAMC,QAAoBC;AA+B1B,IAAMC,QAA0DH,IAAIG;AAEpE,IAAMC,OAAmBJ,IAAII;AAG7B,IAAMC,UAAU,CAACC,QAAmDN,IAAIK,QAAQC,GAAAA;AAEhF,IAAMC,cAA0BP,IAAIO;AAGpC,IAAMC,YAAY,CAACC,QAAAA;AACxB,SAAiBC,wBAAqCD,KAAeE,gCAAsB,EAAEC,KACpFC,eAAQ,CAACC,eAAgB,SAASA,aAAoBC,YAAKD,UAAAA,IAAqBE,YAAI,CAAA,GACpFH,eAAQ,CAACC,eAAAA;AACd,UAAM,EAAEG,SAAQ,IAAiBC,mBAAmBJ,UAAAA,KAAe,CAAC;AACpE,WAAOG,WAAkBF,YAAK,IAAA,IAAeA,YAAK,KAAA;EACpD,CAAA,GACOI,iBAAU,MAAM,KAAA,CAAA;AAE3B;",
+  "names": ["Ref", "Option", "SchemaAST", "Ref", "Array", "RefArray", "isRef", "make", "fromURI", "uri", "hasEntityId", "isRefType", "ast", "getAnnotation", "JSONSchemaAnnotationId", "pipe", "flatMap", "jsonSchema", "some", "none", "typename", "getSchemaReference", "getOrElse"]
+}

package/dist/lib/neutral/{chunk-TBKX6JQO.mjs → chunk-O6BH7EPN.mjs}

@@ -3,9 +3,31 @@ import * as Schema from "effect/Schema";
 var KindId = "~@dxos/echo/Kind";
 var SchemaKindId = "~@dxos/echo/SchemaKind";
 var SnapshotKindId = "~@dxos/echo/SnapshotKind";
+var StaticTypeSchemaSlot = "~@dxos/echo/Type.StaticSchema";
+var getStaticTypeSchema = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[StaticTypeSchemaSlot];
+};
+var getSchemaKind = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[SchemaKindId];
+};
+var getEntityKindBrand = (value) => {
+  if (value == null || typeof value !== "object") {
+    return void 0;
+  }
+  return value[KindId];
+};
+var InstancePhantomId = "~@dxos/echo/Type.Instance";
+var UnknownTypeSchemaBrandId = "~@dxos/echo/UnknownTypeSchemaBrand";
 var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
   EntityKind2["Object"] = "object";
   EntityKind2["Relation"] = "relation";
+  EntityKind2["Type"] = "type";
   return EntityKind2;
 })({});
 var EntityKindSchema = Schema.Enums(EntityKind);
@@ -35,8 +57,7 @@ var makeTypeJsonSchemaAnnotation = (options) => {
   assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), "relationSource");
   assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), "relationTarget");
   const obj = {
-    // TODO(dmaretskyi): Should this include the version?
-    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),
+    $id: options.identifier ?? DXN.make(options.typename, options.version),
     entityKind: options.kind,
     version: options.version,
     typename: options.typename
@@ -56,6 +77,12 @@ export {
   KindId,
   SchemaKindId,
   SnapshotKindId,
+  StaticTypeSchemaSlot,
+  getStaticTypeSchema,
+  getSchemaKind,
+  getEntityKindBrand,
+  InstancePhantomId,
+  UnknownTypeSchemaBrandId,
   EntityKind,
   EntityKindSchema,
   ANY_OBJECT_TYPENAME,
@@ -64,4 +91,4 @@ export {
   unwrapOptional,
   makeTypeJsonSchemaAnnotation
 };
-//# sourceMappingURL=chunk-TBKX6JQO.mjs.map
+//# sourceMappingURL=chunk-O6BH7EPN.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/common/types/entity.ts", "../../../src/internal/Annotation/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Hidden slot on a static `Type.Type` entity that holds the source Effect\n * Schema. `Type.getSchema(...)` reads this for static types; persisted types\n * rebuild from `jsonSchema` instead. Stored as a string key for declaration\n * portability (see KindId comment above).\n */\nexport const StaticTypeSchemaSlot = '~@dxos/echo/Type.StaticSchema' as const;\nexport type StaticTypeSchemaSlot = typeof StaticTypeSchemaSlot;\n\n/**\n * Read the hidden `StaticTypeSchemaSlot` off any value that may carry one.\n * Returns `undefined` for raw schemas (no slot) and non-object inputs.\n * Single point-of-cast for the slot lookup.\n */\nexport const getStaticTypeSchema = (value: unknown): Schema.Schema.AnyNoContext | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [StaticTypeSchemaSlot]?: Schema.Schema.AnyNoContext })[StaticTypeSchemaSlot];\n};\n\n/**\n * Read the `[SchemaKindId]` brand off a value. Returns `undefined` for raw\n * schemas (which don't carry the brand on their static type) and non-object\n * inputs. Single point-of-cast for the brand lookup.\n */\nexport const getSchemaKind = (value: unknown): EntityKind | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [SchemaKindId]?: EntityKind })[SchemaKindId];\n};\n\n/**\n * Read the `[KindId]` brand off a value. Returns `undefined` for raw schemas\n * and non-object inputs. Companion to {@link getSchemaKind}.\n */\nexport const getEntityKindBrand = (value: unknown): EntityKind | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [KindId]?: EntityKind })[KindId];\n};\n\n/**\n * Phantom string key on `Type<A>` entities that carries the instance type `A`.\n * Lets internal helpers (`makeObject`, `createObject`, etc.) pattern-match the\n * instance type from an entity input without importing from the top-level\n * `Type` module. Mirrors `Type.InstancePhantomId` (declared in `Type.ts`).\n *\n * Stored as a string key so declarations remain portable across packages\n * (see KindId comment above).\n */\nexport const InstancePhantomId = '~@dxos/echo/Type.Instance' as const;\nexport type InstancePhantomId = typeof InstancePhantomId;\n\n/**\n * Nominal brand carried by the well-known \"any object\" / \"any relation\"\n * schemas (`Obj.Unknown`, `Relation.Unknown`). The brand lets `Ref.Ref`,\n * `Filter.type`, and `Query.type` accept these schemas in addition to\n * `Type.Type` entities, without opening the door to arbitrary raw schemas.\n *\n * Stored as a string key so declarations remain portable across packages\n * (see KindId comment above).\n */\nexport const UnknownTypeSchemaBrandId = '~@dxos/echo/UnknownTypeSchemaBrand' as const;\nexport type UnknownTypeSchemaBrandId = typeof UnknownTypeSchemaBrandId;\n\n/**\n * Schema-side companion to `Type.Type` entities for the \"any object\" /\n * \"any relation\" cases. Branded so `Ref.Ref` / `Filter.type` / `Query.type`\n * can pattern-match on it; arbitrary `Schema.Schema` values do not satisfy\n * this shape.\n */\nexport interface UnknownTypeSchema<A, K extends EntityKind> extends Schema.Schema<A, any, never> {\n  readonly [UnknownTypeSchemaBrandId]: K;\n}\n\n/**\n * Kinds of entities stored in ECHO: objects, relations, and types.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n  Type = 'type',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'org.dxos.schema.anyObject';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../common/types';\n\nexport interface AnnotationHelper<T> {\n  /**\n   * Get the annotation value from an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — to read an annotation off a `Type.Type`\n   * entity, unwrap it first with `Type.getSchema(entity)`. This keeps the\n   * annotation pipeline single-shaped and forces annotations to live on the\n   * source schema, not on the post-construction Type entity.\n   */\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  /**\n   * Get the annotation value from the AST.\n   */\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  /**\n   * Set the annotation on an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — annotations must be applied to the\n   * source schema BEFORE wrapping it with `Type.makeObject` / `Type.makeRelation`.\n   * In a pipe, place every `Annotation.X.set(...)` before the `Type.make...` step.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\n/**\n * Note: only for system annotations.\n */\n// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.\n// TODO(dmaretskyi): REconcile with Annotation.make.\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S): S =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj: Record<string, unknown> = {\n    $id: options.identifier ?? DXN.make(options.typename, options.version),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  };\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AASvB,IAAMC,uBAAuB;AAQ7B,IAAMC,sBAAsB,CAACC,UAAAA;AAClC,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAAkEF,oBAAAA;AAC5E;AAOO,IAAMI,gBAAgB,CAACF,UAAAA;AAC5B,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAA0CJ,YAAAA;AACpD;AAMO,IAAMO,qBAAqB,CAACH,UAAAA;AACjC,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAAoCL,MAAAA;AAC9C;AAWO,IAAMS,oBAAoB;AAY1B,IAAMC,2BAA2B;AAgBjC,IAAKC,aAAAA,0BAAAA,aAAAA;;;;SAAAA;;AAML,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC9HlC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAiCb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAA+B;IACnCC,KAAKR,QAAQS,cAAcC,IAAIC,KAAKX,QAAQY,UAAUZ,QAAQa,OAAO;IACrEC,YAAYd,QAAQG;IACpBU,SAASb,QAAQa;IACjBD,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEa,MAAMf,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAES,MAAMf,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "StaticTypeSchemaSlot", "getStaticTypeSchema", "value", "undefined", "getSchemaKind", "getEntityKindBrand", "InstancePhantomId", "UnknownTypeSchemaBrandId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "make", "typename", "version", "entityKind", "$ref"]
+}