@dxos/echo 0.8.4-main.d05673bc65 → 0.8.4-main.e00bdcdb52

package/dist/lib/neutral/{chunk-NQRLRYJM.mjs → chunk-LOTZLYHB.mjs}

@@ -1,8 +1,11 @@
+import {
+  isRef
+} from "./chunk-TW76K7H5.mjs";
 import {
   Kind,
   KindId,
   SnapshotKindId
-} from "./chunk-UFDK26FO.mjs";
+} from "./chunk-6VC3FI5E.mjs";
 import {
   EchoObjectSchema,
   MetaId,
@@ -18,9 +21,11 @@ import {
   getDatabase,
   getKeys,
   getMetaChecked,
+  getProxyTarget,
   getSnapshot,
   getValue,
   isDeleted,
+  isProxy,
   isVersion,
   makeObject,
   objectFromJSON,
@@ -33,7 +38,7 @@ import {
   subscribe,
   version,
   versionValid
-} from "./chunk-TQQZLKB7.mjs";
+} from "./chunk-UYJYDSD7.mjs";
 import {
   ParentId,
   getDescription,
@@ -45,15 +50,15 @@ import {
   isInstanceOf,
   setDescription,
   setLabel
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-JALF2CVV.mjs";
 import {
   ANY_OBJECT_TYPENAME,
   ANY_OBJECT_VERSION,
   SchemaKindId
-} from "./chunk-WYOKA6AE.mjs";
+} from "./chunk-N4B7FHQT.mjs";
 import {
   GetReactiveError
-} from "./chunk-UBEZSGXY.mjs";
+} from "./chunk-ZISMEVKD.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -67,7 +72,6 @@ __export(Obj_exports, {
   Unknown: () => Unknown2,
   VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
-  change: () => change2,
   clone: () => clone2,
   compareVersions: () => compareVersions2,
   decodeVersion: () => decodeVersion2,
@@ -106,17 +110,22 @@ __export(Obj_exports, {
   sortByTypename: () => sortByTypename2,
   subscribe: () => subscribe2,
   toJSON: () => toJSON,
+  update: () => update,
+  updateFrom: () => updateFrom,
   version: () => version2,
   versionValid: () => versionValid2
 });
 import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
 import * as Function from "effect/Function";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
+import * as Utils from "effect/Utils";
 import { createJsonPath } from "@dxos/effect";
-import { assertArgument } from "@dxos/invariant";
+import { assertArgument, invariant } from "@dxos/invariant";
 import { ObjectId } from "@dxos/keys";
-import { assumeType } from "@dxos/util";
+import { assumeType, deepMapValues } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
 var Unknown2 = Schema.Struct({
   id: Schema.String
 }).pipe(
@@ -192,7 +201,7 @@ var getReactive = (snapshot) => Effect.gen(function* () {
 var getReactiveOption = (snapshot) => getReactive(snapshot).pipe(Effect.map(Option.some), Effect.catchAll(() => Effect.succeed(Option.none())));
 var getReactiveOrThrow = (snapshot) => Effect.runSync(getReactive(snapshot));
 var clone2 = clone;
-var change2 = (obj, callback) => {
+var update = (obj, callback) => {
   change(obj, callback);
 };
 var getValue2 = (obj, path) => {
@@ -217,7 +226,11 @@ var getDXN2 = (entity) => {
   assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
   return getDXN(entity);
 };
-var getTypeDXN2 = getTypeDXN;
+var getTypeDXN2 = (obj) => {
+  const type = getTypeDXN(obj);
+  invariant(type != null, "Corrupted object: missing type.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 315, S: void 0, A: ["type != null", "'Corrupted object: missing type.'"] });
+  return type;
+};
 var getSchema2 = getSchema;
 var getTypename2 = (entity) => getTypename(entity);
 var getDatabase2 = (entity) => getDatabase(entity);
@@ -247,6 +260,99 @@ var setParent = (entity, parent) => {
   assumeType(parent);
   entity[ParentId] = parent;
 };
+var valuesEqual = (left, right) => {
+  if (left === right) {
+    return true;
+  }
+  if (left === null || right === null) {
+    return left === right;
+  }
+  if (typeof left !== "object" || typeof right !== "object") {
+    return Utils.structuralRegion(() => Equal.equals(left, right));
+  }
+  if (isRef(left) && isRef(right)) {
+    return left.dxn.toString() === right.dxn.toString();
+  }
+  if (isRef(left) || isRef(right)) {
+    return false;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index++) {
+      if (!valuesEqual(left[index], right[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(leftRecord).filter((key) => key !== "id"),
+    ...Object.keys(rightRecord).filter((key) => key !== "id")
+  ]);
+  for (const key of keys) {
+    const leftHas = Object.hasOwn(leftRecord, key);
+    const rightHas = Object.hasOwn(rightRecord, key);
+    const leftValue = leftHas ? leftRecord[key] : void 0;
+    const rightValue = rightHas ? rightRecord[key] : void 0;
+    if (!valuesEqual(leftValue, rightValue)) {
+      return false;
+    }
+  }
+  return true;
+};
+var prepareAssignValue = (value) => deepMapValues(value, (nested, recurse) => {
+  if (nested === null || typeof nested !== "object") {
+    return nested;
+  }
+  if (isRef(nested)) {
+    return nested;
+  }
+  if (Array.isArray(nested)) {
+    return recurse(nested);
+  }
+  if (isProxy(nested)) {
+    return recurse({
+      ...getProxyTarget(nested)
+    });
+  }
+  return recurse(nested);
+});
+var updateFrom = (target, source, options) => {
+  assertArgument(isObject(target), "Expected an echo object target.");
+  assertArgument(isObject(source), "Expected an echo object source.");
+  let keys = Object.keys(source).filter((key) => key !== "id");
+  if (options?.include !== void 0) {
+    const include = new Set(options.include.map((key) => String(key)));
+    keys = keys.filter((key) => include.has(key));
+  }
+  if (options?.exclude !== void 0) {
+    const exclude = new Set(options.exclude.map((key) => String(key)));
+    keys = keys.filter((key) => !exclude.has(key));
+  }
+  let updated = false;
+  const sourceRecord = source;
+  const targetRecord = target;
+  for (const key of keys) {
+    if (!Object.hasOwn(sourceRecord, key)) {
+      continue;
+    }
+    const nextValue = sourceRecord[key];
+    const prevValue = Object.hasOwn(targetRecord, key) ? targetRecord[key] : void 0;
+    if (valuesEqual(prevValue, nextValue)) {
+      continue;
+    }
+    targetRecord[key] = prepareAssignValue(nextValue);
+    updated = true;
+  }
+  return updated;
+};
 var toJSON = (entity) => objectToJSON(entity);
 var fromJSON = objectFromJSON;
 var sortByLabel2 = sortByLabel;
@@ -271,7 +377,7 @@ export {
   getReactiveOption,
   getReactiveOrThrow,
   clone2 as clone,
-  change2 as change,
+  update,
   getValue2 as getValue,
   setValue2 as setValue,
   ID,
@@ -296,6 +402,7 @@ export {
   Parent,
   getParent,
   setParent,
+  updateFrom,
   toJSON,
   fromJSON,
   sortByLabel2 as sortByLabel,
@@ -310,4 +417,4 @@ export {
   version2 as version,
   Obj_exports
 };
-//# sourceMappingURL=chunk-NQRLRYJM.mjs.map
+//# sourceMappingURL=chunk-LOTZLYHB.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Obj.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as Utils from 'effect/Utils';\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { type DXN, ObjectId } from '@dxos/keys';\nimport { assumeType, deepMapValues } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as Err from './Err';\nimport * as internal from './internal';\nimport { getProxyTarget, isProxy } from './internal/common/proxy/proxy-utils';\nimport * as objInternal from './internal/Obj';\nimport * as Ref from './Ref';\nimport type * as Type from './Type';\n\n/**\n * Base type for all ECHO objects.\n */\ninterface BaseObj extends internal.AnyEntity, Entity.OfKind<typeof Entity.Kind.Object> {}\n\n/**\n * Object type with specific properties.\n */\nexport type OfShape<Props> = BaseObj & Props;\n\n/**\n * Object with no known properties beyond id and kind.\n * Use this when the object's schema/properties are not known.\n * For objects with arbitrary properties, use `Obj.AnyProps`.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO object, use `Schema.is(Type.Obj)`.\n */\nexport interface Unknown extends BaseObj {}\n\n/**\n * Runtime Effect schema for any ECHO object.\n * Use for validation, parsing, or as a reference target for collections.\n *\n * NOTE: `Schema.is(Type.Obj)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Obj.isObject()` 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.Obj)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Obj.isObject(unknownValue)) { ... }\n *\n * // Reference to any object type\n * const Collection = Schema.Struct({\n *   objects: Schema.Array(Ref.Ref(Obj.Unknown)),\n * }).pipe(Type.object({ typename: 'Collection', version: '0.1.0' }));\n * ```\n */\n// TODO(wittjosiah): Investigate if Schema.filter can validate KindId on ECHO instances.\n//   Effect Schema normalizes proxy objects to plain objects before calling filter predicates.\n//   Possible approaches: custom Schema.declare, AST manipulation, or upstream contribution.\nexport const Unknown: Type.Obj<Unknown> = 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 EchoObjectSchema annotation is required for Ref.Ref(Obj.Unknown) to work.\n  //   The typename/version only satisfy ECHO schema machinery for reference targets.\n  internal.EchoObjectSchema({ typename: internal.ANY_OBJECT_TYPENAME, version: internal.ANY_OBJECT_VERSION }),\n  (schema) =>\n    Object.assign(schema, {\n      [internal.SchemaKindId]: (schema as any)[internal.SchemaKindId],\n    }) as unknown as Type.Obj<Unknown>,\n);\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 * Prefer using `Obj.Unknown` when you don't need to access arbitrary properties.\n */\nexport interface Any extends BaseObj, internal.AnyProperties {}\n\n/**\n * Base type for snapshot objects (has SnapshotKindId instead of KindId).\n */\ninterface BaseSnapshot extends internal.AnyEntity {\n  readonly [Entity.SnapshotKindId]: typeof Entity.Kind.Object;\n  readonly id: ObjectId;\n}\n\n/**\n * Immutable snapshot of an ECHO object.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks like useObject().\n *\n * Snapshots are structurally identical to reactive objects but have a different brand,\n * making them distinguishable at the TypeScript level. Neither is assignable to the other.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> & BaseSnapshot;\n\n/**\n * JSON-encoded properties for objects.\n */\nexport interface BaseObjJson {\n  id: string;\n}\n\nconst defaultMeta: internal.ObjectMeta = {\n  keys: [],\n};\n\ntype MakePropsInternal<T extends Unknown> = {\n  id?: ObjectId;\n  [Meta]?: Partial<internal.ObjectMeta>;\n} & Entity.Properties<T>;\n\n// TODO(burdon): Should we allow the caller to set the id?\n/**\n * Props type for object creation with a given schema.\n */\nexport type MakeProps<S extends Schema.Schema.AnyNoContext> = {\n  id?: ObjectId;\n  [Meta]?: Partial<internal.ObjectMeta>;\n  [Parent]?: Unknown;\n} & MakePropsInternal<Schema.Schema.Type<S>>;\n\n/**\n * Creates a new echo object of the given schema.\n * @param schema - Object schema.\n * @param props - Object properties.\n * @param meta - Object metadata (deprecated) -- pass with Obj.Meta.\n *\n * Meta can be passed as a symbol in `props`.\n *\n * Example:\n * ```ts\n * const obj = Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' });\n * ```\n *\n * Note: Only accepts object schemas, not relation schemas. Use `Relation.make` for relations.\n */\nexport const make = <S extends Type.AnyObj>(\n  schema: S,\n  props: NoInfer<MakeProps<S>>,\n): OfShape<Schema.Schema.Type<S>> => {\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === Entity.Kind.Object,\n    'schema',\n    'Expected an object schema',\n  );\n\n  let meta: internal.ObjectMeta | undefined = undefined;\n\n  // Set default fields on meta on creation.\n  if (props[internal.MetaId] != null) {\n    meta = { ...structuredClone(defaultMeta), ...props[internal.MetaId] };\n    delete props[internal.MetaId];\n  }\n\n  // Filter undefined values (Object.entries only returns string-keyed properties).\n  const filterUndefined: any = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== undefined));\n\n  // Copy symbol properties (like ParentId) that Object.entries doesn't include.\n  for (const sym of Object.getOwnPropertySymbols(props)) {\n    const value = (props as any)[sym];\n    if (value !== undefined) {\n      filterUndefined[sym] = value;\n    }\n  }\n\n  return internal.makeObject<Schema.Schema.Type<S>>(schema, filterUndefined as any, {\n    ...defaultMeta,\n    ...meta,\n  });\n};\n\n/**\n * Determine if object is an ECHO object.\n */\nexport const isObject = (obj: unknown): obj is Unknown => {\n  assumeType<internal.InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && obj[Entity.KindId] === Entity.Kind.Object;\n};\n\nexport const isSnapshot = (obj: unknown): obj is Snapshot => {\n  assumeType<internal.InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && (obj as any)[Entity.SnapshotKindId] === Entity.Kind.Object;\n};\n\n/**\n * Subscribe to object updates.\n * The callback is called synchronously when the object is modified.\n * Only accepts reactive objects (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (obj: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(obj, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of an object.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive object at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(obj: T) => Snapshot<T> = objInternal.getSnapshot as any;\n\n/**\n * Returns the reactive version of an object from the database, given its snapshot.\n * Inverse of `Obj.getSnapshot`.\n *\n * Uses `Obj.getDatabase` internally to get the database from the snapshot,\n * then resolves the reactive object by ID.\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns Effect that succeeds with the reactive object, or fails with `GetReactiveError`.\n * @example\n * ```ts\n * const snapshot = Obj.getSnapshot(obj);\n * const reactive = Obj.getReactive(snapshot).pipe(\n *   Effect.runSync\n * );\n * ```\n */\nexport const getReactive = <T extends Unknown>(snapshot: Snapshot<T>): Effect.Effect<T, Err.GetReactiveError> =>\n  Effect.gen(function* () {\n    const db = internal.getDatabase(snapshot);\n    if (!db) {\n      return yield* Effect.fail(new Err.GetReactiveError({ reason: 'no-database', snapshotId: snapshot.id }));\n    }\n    const obj = db.getObjectById(snapshot.id);\n    if (!obj) {\n      return yield* Effect.fail(new Err.GetReactiveError({ reason: 'object-not-found', snapshotId: snapshot.id }));\n    }\n    return obj as T;\n  });\n\n/**\n * Like `Obj.getReactive` but returns `Option.none()` instead of failing when the object\n * cannot be resolved (no database, object not found).\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns Effect that succeeds with `Option.some(reactive)` or `Option.none()`.\n */\nexport const getReactiveOption = <T extends Unknown>(snapshot: Snapshot<T>): Effect.Effect<Option.Option<T>, never> =>\n  getReactive(snapshot).pipe(\n    Effect.map(Option.some),\n    Effect.catchAll(() => Effect.succeed(Option.none())),\n  );\n\n/**\n * Synchronous version of `Obj.getReactive`. Returns the reactive object or throws\n * `GetReactiveError` when the object cannot be resolved (no database, object not found).\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns The reactive object.\n * @throws {Err.GetReactiveError} When the object cannot be resolved.\n */\nexport const getReactiveOrThrow = <T extends Unknown>(snapshot: Snapshot<T>): T =>\n  Effect.runSync(getReactive(snapshot));\n\nexport type CloneOptions = {\n  /**\n   * Retain the original object's ID.\n   * @default false\n   */\n  retainId?: boolean;\n\n  /**\n   * Recursively clone referenced objects.\n   * @default false\n   */\n  deep?: boolean;\n};\n\n/**\n * Clones an object or relation.\n * This does not clone referenced objects, only the properties in the object.\n * @returns A new object with the same schema and properties.\n */\nexport const clone: <T extends Unknown>(obj: T, opts?: CloneOptions) => T = objInternal.clone;\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of an object within `Obj.update`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo object 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 `Obj.update` will throw\n * an error for echo objects.\n *\n * This function also works with nested objects within echo objects (e.g., Template structs)\n * that are reactive at runtime.\n *\n * @param obj - The echo object to mutate. Use `Relation.update` for relations.\n * @param callback - The callback that performs mutations on the object.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John', age: 25 });\n *\n * // Mutate within Obj.update\n * Obj.update(person, (obj) => {\n *   obj.name = 'Jane';\n *   obj.age = 30;\n * });\n * // ONE notification fires here\n *\n * // Direct mutation throws\n * person.name = 'Bob'; // Error: Cannot modify outside Obj.update()\n * ```\n *\n * Note: Only accepts objects. Use `Relation.update` for relations.\n */\nexport const update = <T extends Unknown>(obj: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(obj, callback);\n};\n\n/**\n * Get a deeply nested property from an object.\n *\n * Similar to lodash.get and getDeep from @dxos/util.\n * This is the complementary function to setValue.\n * Accepts both reactive objects and snapshots.\n *\n * @param obj - The ECHO object to get the property from.\n * @param path - Path to the property (array of keys).\n * @returns The value at the path, or undefined if not found.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, {\n *   name: 'John',\n *   addresses: [{ street: '123 Main St' }]\n * });\n *\n * Obj.getValue(person, ['addresses', 0, 'street']); // '123 Main St'\n * Obj.getValue(person, ['addresses', 1, 'street']); // undefined\n * ```\n */\nexport const getValue = (obj: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return internal.getValue(obj, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on an object, using the object's schema to determine\n * whether to initialize nested data as an empty object or array.\n *\n * Similar to lodash.set and setDeep from @dxos/util, but schema-aware.\n * Must be called within an `Obj.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 *\n * @param obj - The mutable ECHO object to set the property on.\n * @param path - Path to the property (array of keys).\n * @param value - Value to set.\n * @returns The value that was set.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John' });\n * // Person schema has: addresses: Schema.Array(Address)\n * Obj.update(person, (obj) => {\n *   Obj.setValue(obj, ['addresses', 0, 'street'], '123 Main St');\n * });\n * // Creates: person.addresses = [{ street: '123 Main St' }]\n * ```\n */\n// TODO(wittjosiah): Compute possible path values + type value based on generic object type.\nexport const setValue: (obj: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  objInternal.setValue as any;\n\n//\n// Type\n//\n\n// TODO(burdon): To discuss: prefer over ObjectId or Key.ObjectId or Type.ID?\nexport const ID = ObjectId;\nexport type ID = ObjectId;\n\n/**\n * Test if object or relation is an instance of a schema.\n * @example\n * ```ts\n * const john = Obj.make(Person, { name: 'John' });\n * const isPerson = Obj.instanceOf(Person);\n * if (isPerson(john)) {\n *   // john is Person\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Schema.Schema.Type<S>;\n  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Schema.Schema.Type<S>;\n} = ((...args: [schema: Type.AnyEntity, value: unknown] | [schema: Type.AnyEntity]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => internal.isInstanceOf(args[0], entity);\n  }\n\n  return internal.isInstanceOf(args[0], args[1]);\n}) as any;\n\n/**\n * Test if a snapshot is an instance of a schema.\n * Mirrors `instanceOf` but only accepts values branded with SnapshotKindId.\n * Use when the value is known to be a snapshot (e.g. from `getSnapshot` or `useObject`).\n *\n * @example\n * ```ts\n * const snapshot = Obj.getSnapshot(person);\n * if (Obj.snapshotOf(Person, snapshot)) {\n *   // snapshot is Obj.Snapshot<Person>\n * }\n * ```\n */\nexport const snapshotOf: {\n  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Snapshot<Schema.Schema.Type<S>>;\n  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Snapshot<Schema.Schema.Type<S>>;\n} = ((...args: [schema: Type.AnyEntity, value: unknown] | [schema: Type.AnyEntity]) => {\n  const check = (entity: unknown) =>\n    entity != null &&\n    typeof entity === 'object' &&\n    Entity.SnapshotKindId in entity &&\n    internal.isInstanceOf(args[0], entity);\n\n  if (args.length === 1) {\n    return (entity: unknown) => check(entity);\n  }\n\n  return check(args[1]);\n}) as any;\n\n// TODO(dmaretskyi): Allow returning undefined.\n/**\n * Get the DXN of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => {\n  assertArgument(!Schema.isSchema(entity), 'obj', 'Object should not be a schema.');\n  return internal.getDXN(entity);\n};\n\n/**\n * @returns The DXN of the object's type.\n * @example dxn:com.example.type.person:1.0.0\n * @throws If the object is missing its type (corrupted object).\n */\nexport const getTypeDXN = (obj: Unknown | Snapshot): DXN => {\n  const type = internal.getTypeDXN(obj);\n  invariant(type != null, 'Corrupted object: missing type.');\n  return type;\n};\n\n/**\n * Get the schema of the object.\n * Returns the branded ECHO schema used to create the object.\n */\nexport const getSchema: (obj: Unknown | Snapshot) => Type.AnyEntity | undefined = internal.getSchema as any;\n\n/**\n * @returns The typename of the object's type.\n * Accepts both reactive objects and snapshots.\n * @example `com.example.type.person`\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the object belongs to.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDatabase = (entity: Entity.Unknown | Entity.Snapshot): Database.Database | undefined =>\n  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 * Prevents mutation at all nesting levels (e.g., `meta.keys.push()` is a TypeScript error).\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Obj.getMeta` inside an `Obj.update` callback.\n */\nexport type Meta = internal.Meta;\n\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): Allow returning undefined.\n/**\n * Get the metadata for an object.\n * Returns mutable meta when passed a mutable object (inside `Obj.update` callback).\n * Returns read-only meta when passed a regular object or snapshot.\n *\n * @example\n * ```ts\n * // Read-only access outside change callback\n * const meta = Obj.getMeta(person);  // ReadonlyMeta\n *\n * // Mutable access inside change callback\n * Obj.update(person, (obj) => {\n *   const meta = Obj.getMeta(obj);     // ObjectMeta (mutable)\n *   meta.tags ??= [];\n *   meta.tags.push('important');\n * });\n * ```\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 object from the specified source.\n * Accepts both reactive objects and snapshots.\n */\nexport const getKeys: {\n  (entity: Unknown | Snapshot, source: string): ForeignKey[];\n  (source: string): (entity: Unknown | Snapshot) => ForeignKey[];\n} = Function.dual(2, (entity: Unknown | Snapshot, source?: string): ForeignKey[] => internal.getKeys(entity, source!));\n\n/**\n * Delete all keys from the object for the specified source.\n * Must be called within an `Obj.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 object.\n * Must be called within an `Obj.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: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the object.\n * Must be called within an `Obj.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: string): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the object is deleted.\n * Accepts both reactive objects and snapshots.\n */\n// TODO(dmaretskyi): Default to `false`.\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => objInternal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Set the label of the object.\n * Must be called within an `Obj.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 object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the object.\n * Must be called within an `Obj.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 * Symbol to set parent when creating objects with `Obj.make`.\n * @example\n * ```ts\n * Obj.make(TestSchema.Person, {\n *   [Obj.Parent]: parentObject,\n *   name: 'John',\n * })\n * ```\n */\nexport const Parent: unique symbol = internal.ParentId as any;\n\n/**\n * Get the parent of an object.\n * The parent is always loaded together with the object.\n * Only objects are allowed to have a parent\n * @returns The parent object, or undefined if the object has no parent.\n */\nexport const getParent = (entity: Unknown | Snapshot): Unknown | undefined => {\n  assertArgument(isObject(entity), 'Expected an object');\n  assumeType<internal.InternalObjectProps>(entity);\n  return entity[internal.ParentId] as Unknown | undefined;\n};\n\n/**\n * Sets the parent of an object.\n * If a parent (or any transitive parent) is deleted, the object will be deleted.\n * Only objects are allowed to have a parent.\n */\nexport const setParent = (entity: Unknown, parent: Any | undefined) => {\n  assertArgument(isObject(entity), 'Expected an object');\n  assertArgument(parent === undefined || isObject(parent), 'Expected an object');\n  assumeType<internal.InternalObjectProps>(entity);\n  assumeType<internal.InternalObjectProps | undefined>(parent);\n  entity[internal.ParentId] = parent;\n};\n\ninterface UpdateFromOptions<T> {\n  exclude?: (keyof T)[];\n  include?: (keyof T)[];\n}\n\nconst valuesEqual = (left: unknown, right: unknown): boolean => {\n  if (left === right) {\n    return true;\n  }\n  if (left === null || right === null) {\n    return left === right;\n  }\n  if (typeof left !== 'object' || typeof right !== 'object') {\n    return Utils.structuralRegion(() => Equal.equals(left, right));\n  }\n  if (Ref.isRef(left) && Ref.isRef(right)) {\n    return left.dxn.toString() === right.dxn.toString();\n  }\n  if (Ref.isRef(left) || Ref.isRef(right)) {\n    return false;\n  }\n  if (Array.isArray(left) && Array.isArray(right)) {\n    if (left.length !== right.length) {\n      return false;\n    }\n    for (let index = 0; index < left.length; index++) {\n      if (!valuesEqual(left[index], right[index])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  if (Array.isArray(left) || Array.isArray(right)) {\n    return false;\n  }\n  const leftRecord = left as Record<string, unknown>;\n  const rightRecord = right as Record<string, unknown>;\n  const keys = new Set([\n    ...Object.keys(leftRecord).filter((key) => key !== 'id'),\n    ...Object.keys(rightRecord).filter((key) => key !== 'id'),\n  ]);\n  for (const key of keys) {\n    const leftHas = Object.hasOwn(leftRecord, key);\n    const rightHas = Object.hasOwn(rightRecord, key);\n    const leftValue = leftHas ? leftRecord[key] : undefined;\n    const rightValue = rightHas ? rightRecord[key] : undefined;\n    if (!valuesEqual(leftValue, rightValue)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Breaks reactive proxies on assigned values so echo-db assignment accepts nested structs (same idea as link assignment).\n */\nconst prepareAssignValue = (value: unknown): unknown =>\n  deepMapValues(value, (nested, recurse) => {\n    if (nested === null || typeof nested !== 'object') {\n      return nested;\n    }\n    if (Ref.isRef(nested)) {\n      return nested;\n    }\n    if (Array.isArray(nested)) {\n      return recurse(nested);\n    }\n    if (isProxy(nested)) {\n      return recurse({ ...getProxyTarget(nested) });\n    }\n    return recurse(nested);\n  });\n\n/**\n * For each key present on `source` (except `id`), assigns `target[key]` when the current value differs.\n * References are compared by target DXN; other values use Effect `Equal.equals` inside a structural region,\n * with recursive comparison for arrays and plain object-shaped property bags (excluding `id`).\n *\n * Must be called within an `Obj.update` callback.\n *\n * @returns Whether any property was updated.\n */\nexport const updateFrom = <T extends Unknown>(\n  target: Mutable<T>,\n  source: T,\n  options?: UpdateFromOptions<T>,\n): boolean => {\n  assertArgument(isObject(target), 'Expected an echo object target.');\n  assertArgument(isObject(source), 'Expected an echo object source.');\n  let keys = Object.keys(source as Record<string, unknown>).filter((key) => key !== 'id');\n  if (options?.include !== undefined) {\n    const include = new Set(options.include.map((key) => String(key)));\n    keys = keys.filter((key) => include.has(key));\n  }\n  if (options?.exclude !== undefined) {\n    const exclude = new Set(options.exclude.map((key) => String(key)));\n    keys = keys.filter((key) => !exclude.has(key));\n  }\n  let updated = false;\n  const sourceRecord = source as Record<string, unknown>;\n  const targetRecord = target as Record<string, unknown>;\n  for (const key of keys) {\n    if (!Object.hasOwn(sourceRecord, key)) {\n      continue;\n    }\n    const nextValue = sourceRecord[key];\n    const prevValue = Object.hasOwn(targetRecord, key) ? targetRecord[key] : undefined;\n    if (valuesEqual(prevValue, nextValue)) {\n      continue;\n    }\n    targetRecord[key] = prepareAssignValue(nextValue) as never;\n    updated = true;\n  }\n  return updated;\n};\n\n//\n// JSON\n//\n\n/**\n * JSON representation of an object.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts object to its JSON representation.\n * Accepts both reactive objects and snapshots.\n *\n * The same algorithm is used when calling the standard `JSON.stringify(obj)` function.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => objInternal.objectToJSON(entity);\n\n/**\n * Creates an object from its json representation, performing schema validation.\n * References and schemas will be resolvable if the `refResolver` is provided.\n *\n * The function must be async to support resolving the schema as well as the relation endpoints.\n *\n * @param options.refResolver - Resolver for references. Produces hydrated references that can be resolved.\n * @param options.dxn - Override object DXN. Changes the result of `Obj.getDXN`.\n * @param options.database - Database to associate with the object.\n */\nexport const fromJSON: (\n  json: unknown,\n  options?: { refResolver?: Ref.Resolver; dxn?: DXN; database?: Database.Database; parent?: Unknown },\n) => Promise<Unknown> = objInternal.objectFromJSON as any;\n\n/**\n * Comparator function type for sorting objects.\n * Accepts both reactive objects 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 type VersionCompareResult = internal.VersionCompareResult;\n\n/**\n * Represent object version.\n * May be backed by Automerge.\n * Objects with no history are not versioned.\n */\nexport type Version = internal.EntityVersion;\n\nexport const isVersion = internal.isVersion;\nexport const versionValid = internal.versionValid;\nexport const compareVersions = internal.compareVersions;\nexport const encodeVersion = internal.encodeVersion;\nexport const decodeVersion = internal.decodeVersion;\n\n/**\n * Returns the version of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n"],
+  "mappings": "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",
+  "names": ["Unknown", "VersionTypeId", "addTag", "clone", "compareVersions", "decodeVersion", "deleteKeys", "encodeVersion", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "versionValid", "Effect", "Equal", "Function", "Option", "Schema", "Utils", "createJsonPath", "assertArgument", "invariant", "ObjectId", "assumeType", "deepMapValues", "Schema", "Record", "key", "version", "ANY_OBJECT_VERSION", "assign", "SchemaKindId", "defaultMeta", "keys", "meta", "undefined", "props", "internal", "structuredClone", "MetaId", "Object", "getOwnPropertySymbols", "value", "filterUndefined", "sym", "isSnapshot", "obj", "subscribe", "Effect", "GetReactiveError", "reason", "snapshotId", "snapshot", "id", "getValue", "setValue", "entity", "isInstanceOf", "args", "length", "check", "invariant", "type", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "assumeType", "ParentId", "assertArgument", "parent", "isObject", "right", "left", "Ref", "isRef", "Array", "isArray", "index", "leftRecord", "Set", "rightRecord", "rightHas", "leftValue", "leftHas", "rightValue", "valuesEqual", "nested", "isProxy", "getProxyTarget", "source", "filter", "include", "options", "map", "String", "exclude", "updated", "targetRecord", "hasOwn", "prevValue", "nextValue", "sortByTypename", "sort", "comparators", "versionValid", "compareVersions", "encodeVersion", "decodeVersion"]
+}

package/dist/lib/neutral/{chunk-WYOKA6AE.mjs → chunk-N4B7FHQT.mjs}

@@ -9,7 +9,7 @@ var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
   return EntityKind2;
 })({});
 var EntityKindSchema = Schema.Enums(EntityKind);
-var ANY_OBJECT_TYPENAME = "org.dxos.schema.any-object";
+var ANY_OBJECT_TYPENAME = "org.dxos.schema.anyObject";
 var ANY_OBJECT_VERSION = "0.0.0";
 
 // src/internal/Annotation/util.ts
@@ -64,4 +64,4 @@ export {
   unwrapOptional,
   makeTypeJsonSchemaAnnotation
 };
-//# sourceMappingURL=chunk-WYOKA6AE.mjs.map
+//# sourceMappingURL=chunk-N4B7FHQT.mjs.map

package/dist/lib/neutral/{chunk-WYOKA6AE.mjs.map → chunk-N4B7FHQT.mjs.map}

@@ -1,7 +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 * Kinds of entities stored in ECHO: objects and relations.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\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.any-object';\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 type * 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 the schema.\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 value on the schema.\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.\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) =>\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 = {\n    // TODO(dmaretskyi): Should this include the version?\n    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  } as any;\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"],
+  "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 * Kinds of entities stored in ECHO: objects and relations.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\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 type * 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 the schema.\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 value on the schema.\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.\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) =>\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 = {\n    // TODO(dmaretskyi): Should this include the version?\n    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  } as any;\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;AAMvB,IAAKC,aAAAA,0BAAAA,aAAAA;;;SAAAA;;AAKL,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC/ClC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAuBb,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,MAAM;;IAEVC,KAAKR,QAAQS,cAAcC,IAAIC,aAAaX,QAAQY,QAAQ,EAAEC,SAAQ;IACtEC,YAAYd,QAAQG;IACpBY,SAASf,QAAQe;IACjBH,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEc,MAAMhB,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAEU,MAAMhB,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
   "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "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", "fromTypename", "typename", "toString", "entityKind", "version", "$ref"]
 }

package/dist/lib/neutral/{chunk-RMLF7JOZ.mjs → chunk-NKXEKBP5.mjs}

@@ -4,17 +4,17 @@ import {
   EchoSchema,
   PersistentSchema,
   isMutable
-} from "./chunk-TQQZLKB7.mjs";
+} from "./chunk-UYJYDSD7.mjs";
 import {
   getSchemaDXN,
   getSchemaTypename,
   getSchemaVersion,
   getTypeAnnotation
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-JALF2CVV.mjs";
 import {
   EntityKind,
   SchemaKindId
-} from "./chunk-WYOKA6AE.mjs";
+} from "./chunk-N4B7FHQT.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -51,28 +51,12 @@ var getDXN = (schema) => {
 };
 var getTypename = (schema) => {
   const typename = getSchemaTypename(schema);
-  invariant(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", {
-    F: __dxlog_file,
-    L: 230,
-    S: void 0,
-    A: [
-      "typeof typename === 'string' && !typename.startsWith('dxn:')",
-      "'Invalid typename'"
-    ]
-  });
+  invariant(typeof typename === "string" && !typename.startsWith("dxn:"), "Invalid typename", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 70, S: void 0, A: ["typeof typename === 'string' && !typename.startsWith('dxn:')", "'Invalid typename'"] });
   return typename;
 };
 var getVersion = (schema) => {
   const version = getSchemaVersion(schema);
-  invariant(typeof version === "string" && version.match(/^\d+\.\d+\.\d+$/), "Invalid version", {
-    F: __dxlog_file,
-    L: 240,
-    S: void 0,
-    A: [
-      "typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)",
-      "'Invalid version'"
-    ]
-  });
+  invariant(typeof version === "string" && version.match(/^\d+\.\d+\.\d+$/), "Invalid version", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 78, S: void 0, A: ["typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/)", "'Invalid version'"] });
   return version;
 };
 var isMutable2 = isMutable;
@@ -94,4 +78,4 @@ export {
   getMeta,
   Type_exports
 };
-//# sourceMappingURL=chunk-RMLF7JOZ.mjs.map
+//# sourceMappingURL=chunk-NKXEKBP5.mjs.map

package/dist/lib/neutral/{chunk-RMLF7JOZ.mjs.map → chunk-NKXEKBP5.mjs.map}

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/Type.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type EncodedReference } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { type DXN } from '@dxos/keys';\nimport { type ToMutable } from '@dxos/util';\n\nimport type * as Entity from './Entity';\nimport * as typeInternal from './internal/Type';\nimport * as internal from './internal';\nimport type * as ObjModule from './Obj';\nimport type * as RelationModule from './Relation';\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport const RuntimeType = typeInternal.EchoSchema;\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport type RuntimeType = typeInternal.EchoSchema;\n\n//\n// Internal types (not exported)\n//\n\n/**\n * Type that marks a schema as an ECHO schema.\n * The value indicates the entity kind (Object or Relation).\n */\ntype EchoSchemaKind<K extends internal.EntityKind = internal.EntityKind> = {\n  readonly [internal.SchemaKindId]: K;\n};\n\n//\n// Obj - Runtime schema for any ECHO object\n//\n\n/**\n * TypeScript type for an ECHO object schema.\n * `T` is the instance type produced by the schema.\n * `Fields` is the optional struct fields type for introspection.\n *\n * @example\n * ```ts\n * const PersonSchema: Type.Obj<Person> = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'Person', version: '0.1.0' }));\n *\n * // Access fields for introspection:\n * Object.keys(PersonSchema.fields); // ['name']\n * ```\n */\nexport interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Object>,\n    Schema.AnnotableClass<\n      Obj<T, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Object> & T,\n      Schema.Simplify<ObjModule.BaseObjJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO object schema.\n * Accepts both static schemas (created with Type.object()) and EchoSchema.\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isObjectSchema() for runtime type guards.\n */\ntype ObjectSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO object schema.\n * Accepts both static schemas (Type.object()) and mutable schemas (EchoSchema).\n */\nexport type AnyObj = ObjectSchemaBase;\n\n/**\n * Factory function to create an ECHO object schema.\n * Adds object metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'com.example.type.person', version: '0.1.0' }));\n * ```\n */\nexport const object: {\n  (opts: internal.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;\n} = internal.EchoObjectSchema as any;\n\n//\n// PersistentType (Schema stored in database)\n//\n\nexport const PersistentType: Obj<typeInternal.PersistentSchema> = typeInternal.PersistentSchema as any;\n\nexport interface PersistentType extends Schema.Schema.Type<typeof PersistentType> {}\n\n/**\n * TypeScript type for an ECHO relation schema.\n * `T` is the instance type produced by the schema (excluding source/target).\n * `Source` and `Target` are the endpoint types.\n * `Fields` is the optional struct fields type for introspection.\n */\nexport interface Relation<T, Source, Target, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Relation>,\n    Schema.AnnotableClass<\n      Relation<T, Source, Target, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Relation> & RelationModule.Endpoints<Source, Target> & T,\n      Schema.Simplify<RelationModule.BaseRelationJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO relation schema.\n * Accepts static schemas (created with Type.relation()).\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isRelationSchema() for runtime type guards.\n */\ntype RelationSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO relation schema.\n * Accepts static schemas (Type.relation()).\n */\nexport type AnyRelation = RelationSchemaBase;\n\n/**\n * Factory function to create an ECHO relation schema.\n * Adds relation metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const WorksFor = Schema.Struct({\n *   role: Schema.String,\n * }).pipe(Type.relation({\n *   typename: 'com.example.type.works-for',\n *   version: '0.1.0',\n *   source: Person,\n *   target: Company,\n * }));\n * ```\n */\nexport const relation: {\n  <SourceSchema extends Schema.Schema.AnyNoContext, TargetSchema extends Schema.Schema.AnyNoContext>(\n    opts: internal.EchoRelationSchemaOptions<SourceSchema, TargetSchema>,\n  ): <Self extends Schema.Schema.Any>(\n    self: Self,\n  ) => Relation<Schema.Schema.Type<Self>, Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>>;\n} = internal.EchoRelationSchema as any;\n\n/**\n * Type alias for any ECHO entity schema (object or relation).\n * Use this in type annotations for schema parameters.\n */\nexport type AnyEntity = AnyObj | AnyRelation;\n\n/**\n * Type guard to check if a schema is an object schema.\n * NOTE: This checks SCHEMAS, not instances. Use Obj.isObject for instances.\n */\nexport const isObjectSchema = (schema: AnyEntity): schema is AnyObj => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Object;\n};\n\n/**\n * Type guard to check if a schema is a relation schema.\n * NOTE: This checks SCHEMAS, not instances. Use Relation.isRelation for instances.\n */\nexport const isRelationSchema = (schema: AnyEntity): schema is AnyRelation => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * Type that represents any Ref schema (with unknown target type).\n * This is a schema type, not an instance type.\n */\nexport type AnyRef = Schema.Schema<internal.Ref<any>, EncodedReference>;\n\n//\n// Schema utility functions\n//\n\n/**\n * Gets the full DXN of the schema.\n * Will include the version if it's a `type` DXN.\n * @example \"dxn:com.example.type.person:0.1.0\"\n * @example \"dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX\"\n */\nexport const getDXN = (schema: AnyEntity): DXN | undefined => {\n  return internal.getSchemaDXN(schema);\n};\n\n/**\n * @param schema - Schema to get the typename from.\n * @returns The typename of the schema. Example: `com.example.type.person`.\n */\nexport const getTypename = (schema: AnyEntity): string => {\n  const typename = internal.getSchemaTypename(schema);\n  invariant(typeof typename === 'string' && !typename.startsWith('dxn:'), 'Invalid typename');\n  return typename;\n};\n\n/**\n * Gets the version of the schema.\n * @example 0.1.0\n */\nexport const getVersion = (schema: AnyEntity): string => {\n  const version = internal.getSchemaVersion(schema);\n  invariant(typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/), 'Invalid version');\n  return version;\n};\n\n/**\n * @returns True if the schema is mutable.\n */\nexport const isMutable = typeInternal.isMutable;\n\n/**\n * ECHO type metadata.\n */\nexport type Meta = internal.TypeAnnotation;\n\n/**\n * Gets the meta data of the schema.\n */\nexport const getMeta = (schema: AnyEntity): Meta | undefined => {\n  return internal.getTypeAnnotation(schema);\n};\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;mBAAAA;EAAA;;;;;AASA,SAASC,iBAAiB;;AAanB,IAAMC,cAA2BC;AAmFjC,IAAMC,SAEAC;AAMN,IAAMC,iBAAkEC;AA4DxE,IAAMC,WAMAC;AAYN,IAAMC,iBAAiB,CAACC,WAAAA;AAC7B,SAAQA,OAAwBC,YAAY,MAAeC,WAAWC;AACxE;AAMO,IAAMC,mBAAmB,CAACJ,WAAAA;AAC/B,SAAQA,OAAwBC,YAAY,MAAeC,WAAWG;AACxE;AAkBO,IAAMC,SAAS,CAACN,WAAAA;AACrB,SAAgBO,aAAaP,MAAAA;AAC/B;AAMO,IAAMQ,cAAc,CAACR,WAAAA;AAC1B,QAAMS,WAAoBC,kBAAkBV,MAAAA;AAC5CW,YAAU,OAAOF,aAAa,YAAY,CAACA,SAASG,WAAW,MAAA,GAAS,oBAAA;;;;;;;;;AACxE,SAAOH;AACT;AAMO,IAAMI,aAAa,CAACb,WAAAA;AACzB,QAAMc,UAAmBC,iBAAiBf,MAAAA;AAC1CW,YAAU,OAAOG,YAAY,YAAYA,QAAQE,MAAM,iBAAA,GAAoB,mBAAA;;;;;;;;;AAC3E,SAAOF;AACT;AAKO,IAAMG,aAAyBA;AAU/B,IAAMC,UAAU,CAAClB,WAAAA;AACtB,SAAgBmB,kBAAkBnB,MAAAA;AACpC;",
-  "names": ["isMutable", "invariant", "RuntimeType", "EchoSchema", "object", "EchoObjectSchema", "PersistentType", "PersistentSchema", "relation", "EchoRelationSchema", "isObjectSchema", "schema", "SchemaKindId", "EntityKind", "Object", "isRelationSchema", "Relation", "getDXN", "getSchemaDXN", "getTypename", "typename", "getSchemaTypename", "invariant", "startsWith", "getVersion", "version", "getSchemaVersion", "match", "isMutable", "getMeta", "getTypeAnnotation"]
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type EncodedReference } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { type DXN } from '@dxos/keys';\nimport { type ToMutable } from '@dxos/util';\n\nimport type * as Entity from './Entity';\nimport * as internal from './internal';\nimport * as typeInternal from './internal/Type';\nimport type * as ObjModule from './Obj';\nimport type * as RelationModule from './Relation';\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport const RuntimeType = typeInternal.EchoSchema;\n\n/**\n * Dynamic type that can be constructed, mutated, and persisted in the ECHO database.\n */\nexport type RuntimeType = typeInternal.EchoSchema;\n\n//\n// Internal types (not exported)\n//\n\n/**\n * Type that marks a schema as an ECHO schema.\n * The value indicates the entity kind (Object or Relation).\n */\ntype EchoSchemaKind<K extends internal.EntityKind = internal.EntityKind> = {\n  readonly [internal.SchemaKindId]: K;\n};\n\n//\n// Obj - Runtime schema for any ECHO object\n//\n\n/**\n * TypeScript type for an ECHO object schema.\n * `T` is the instance type produced by the schema.\n * `Fields` is the optional struct fields type for introspection.\n *\n * @example\n * ```ts\n * const PersonSchema: Type.Obj<Person> = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'Person', version: '0.1.0' }));\n *\n * // Access fields for introspection:\n * Object.keys(PersonSchema.fields); // ['name']\n * ```\n */\nexport interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Object>,\n    Schema.AnnotableClass<\n      Obj<T, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Object> & T,\n      Schema.Simplify<ObjModule.BaseObjJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO object schema.\n * Accepts both static schemas (created with Type.object()) and EchoSchema.\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isObjectSchema() for runtime type guards.\n */\ntype ObjectSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO object schema.\n * Accepts both static schemas (Type.object()) and mutable schemas (EchoSchema).\n */\nexport type AnyObj = ObjectSchemaBase;\n\n/**\n * Factory function to create an ECHO object schema.\n * Adds object metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n * }).pipe(Type.object({ typename: 'com.example.type.person', version: '0.1.0' }));\n * ```\n */\nexport const object: {\n  (opts: internal.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;\n} = internal.EchoObjectSchema as any;\n\n//\n// PersistentType (Schema stored in database)\n//\n\nexport const PersistentType: Obj<typeInternal.PersistentSchema> = typeInternal.PersistentSchema as any;\n\nexport interface PersistentType extends Schema.Schema.Type<typeof PersistentType> {}\n\n/**\n * TypeScript type for an ECHO relation schema.\n * `T` is the instance type produced by the schema (excluding source/target).\n * `Source` and `Target` are the endpoint types.\n * `Fields` is the optional struct fields type for introspection.\n */\nexport interface Relation<T, Source, Target, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>\n  extends\n    internal.TypeMeta,\n    EchoSchemaKind<internal.EntityKind.Relation>,\n    Schema.AnnotableClass<\n      Relation<T, Source, Target, Fields>,\n      Entity.OfKind<typeof Entity.Kind.Relation> & RelationModule.Endpoints<Source, Target> & T,\n      Schema.Simplify<RelationModule.BaseRelationJson & ToMutable<T>>,\n      never\n    > {\n  /**\n   * The fields defined in the original struct schema.\n   * Allows accessing field definitions for introspection.\n   */\n  readonly fields: Fields;\n}\n\n/**\n * Structural base type for any ECHO relation schema.\n * Accepts static schemas (created with Type.relation()).\n * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.\n * Use Type.isRelationSchema() for runtime type guards.\n */\ntype RelationSchemaBase = Schema.Schema.AnyNoContext & {\n  readonly typename: string;\n  readonly version: string;\n};\n\n/**\n * Type that represents any ECHO relation schema.\n * Accepts static schemas (Type.relation()).\n */\nexport type AnyRelation = RelationSchemaBase;\n\n/**\n * Factory function to create an ECHO relation schema.\n * Adds relation metadata annotations to an Effect schema.\n *\n * @example\n * ```ts\n * const WorksFor = Schema.Struct({\n *   role: Schema.String,\n * }).pipe(Type.relation({\n *   typename: 'com.example.type.works-for',\n *   version: '0.1.0',\n *   source: Person,\n *   target: Company,\n * }));\n * ```\n */\nexport const relation: {\n  <SourceSchema extends Schema.Schema.AnyNoContext, TargetSchema extends Schema.Schema.AnyNoContext>(\n    opts: internal.EchoRelationSchemaOptions<SourceSchema, TargetSchema>,\n  ): <Self extends Schema.Schema.Any>(\n    self: Self,\n  ) => Relation<Schema.Schema.Type<Self>, Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>>;\n} = internal.EchoRelationSchema as any;\n\n/**\n * Type alias for any ECHO entity schema (object or relation).\n * Use this in type annotations for schema parameters.\n */\nexport type AnyEntity = AnyObj | AnyRelation;\n\n/**\n * Type guard to check if a schema is an object schema.\n * NOTE: This checks SCHEMAS, not instances. Use Obj.isObject for instances.\n */\nexport const isObjectSchema = (schema: AnyEntity): schema is AnyObj => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Object;\n};\n\n/**\n * Type guard to check if a schema is a relation schema.\n * NOTE: This checks SCHEMAS, not instances. Use Relation.isRelation for instances.\n */\nexport const isRelationSchema = (schema: AnyEntity): schema is AnyRelation => {\n  return (schema as any)[internal.SchemaKindId] === internal.EntityKind.Relation;\n};\n\n/**\n * Type that represents any Ref schema (with unknown target type).\n * This is a schema type, not an instance type.\n */\nexport type AnyRef = Schema.Schema<internal.Ref<any>, EncodedReference>;\n\n//\n// Schema utility functions\n//\n\n/**\n * Gets the full DXN of the schema.\n * Will include the version if it's a `type` DXN.\n * @example \"dxn:com.example.type.person:0.1.0\"\n * @example \"dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX\"\n */\nexport const getDXN = (schema: AnyEntity): DXN | undefined => {\n  return internal.getSchemaDXN(schema);\n};\n\n/**\n * @param schema - Schema to get the typename from.\n * @returns The typename of the schema. Example: `com.example.type.person`.\n */\nexport const getTypename = (schema: AnyEntity): string => {\n  const typename = internal.getSchemaTypename(schema);\n  invariant(typeof typename === 'string' && !typename.startsWith('dxn:'), 'Invalid typename');\n  return typename;\n};\n\n/**\n * Gets the version of the schema.\n * @example 0.1.0\n */\nexport const getVersion = (schema: AnyEntity): string => {\n  const version = internal.getSchemaVersion(schema);\n  invariant(typeof version === 'string' && version.match(/^\\d+\\.\\d+\\.\\d+$/), 'Invalid version');\n  return version;\n};\n\n/**\n * @returns True if the schema is mutable.\n */\nexport const isMutable = typeInternal.isMutable;\n\n/**\n * ECHO type metadata.\n */\nexport type Meta = internal.TypeAnnotation;\n\n/**\n * Gets the meta data of the schema.\n */\nexport const getMeta = (schema: AnyEntity): Meta | undefined => {\n  return internal.getTypeAnnotation(schema);\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;mBAAAA;EAAA;;;;;AASA,SAASC,iBAAiB;AAU1B,IAAA,eAAA;;AA2FA,IAAA,SAAA;;;AAmFE,IAAA,iBAAA,CAAA,WAAA;AAEF,SAAA,OAAA,YAAA,MAAA,WAAA;;AAME,IAAA,mBAAA,CAAA,WAAA;AAQA,SAAA,OAAA,YAAA,MAAA,WAAA;AACF;AAWE,IAAA,SAAA,CAAA,WAAA;AAEF,SAAA,aAAA,MAAA;;AAMEC,IAAU,cAAOC,CAAAA,WAAa;AAC9B,QAAA,WAAOA,kBAAAA,MAAAA;AACP,YAAA,OAAA,aAAA,YAAA,CAAA,SAAA,WAAA,MAAA,GAAA,oBAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,QAAA,GAAA,CAAA,gEAAA,oBAAA,EAAA,CAAA;AAEF,SAAA;;AAMED,IAAU,aAAOE,CAAAA,WAAY;AAC7B,QAAA,UAAOA,iBAAAA,MAAAA;AACP,YAAA,OAAA,YAAA,YAAA,QAAA,MAAA,iBAAA,GAAA,mBAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,QAAA,GAAA,CAAA,wEAAA,mBAAA,EAAA,CAAA;AAEF,SAAA;;;AAeE,IAAA,UAAA,CAAA,WAAA;;;",
+  "names": ["isMutable", "invariant", "invariant", "typename", "version"]
 }

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

@@ -1,10 +1,10 @@
 import {
   Unknown
-} from "./chunk-NQRLRYJM.mjs";
+} from "./chunk-LOTZLYHB.mjs";
 import {
   KindId,
   SnapshotKindId
-} from "./chunk-UFDK26FO.mjs";
+} from "./chunk-6VC3FI5E.mjs";
 import {
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
@@ -36,7 +36,7 @@ import {
   sortByTypename,
   subscribe,
   version
-} from "./chunk-TQQZLKB7.mjs";
+} from "./chunk-UYJYDSD7.mjs";
 import {
   ParentId,
   getDescription,
@@ -47,11 +47,11 @@ import {
   getTypename,
   setDescription,
   setLabel
-} from "./chunk-SEMVAGBM.mjs";
+} from "./chunk-JALF2CVV.mjs";
 import {
   EntityKind,
   SchemaKindId
-} from "./chunk-WYOKA6AE.mjs";
+} from "./chunk-N4B7FHQT.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -65,7 +65,6 @@ __export(Relation_exports, {
   Unknown: () => Unknown3,
   VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
-  change: () => change2,
   deleteKeys: () => deleteKeys2,
   getDXN: () => getDXN2,
   getDatabase: () => getDatabase2,
@@ -96,6 +95,7 @@ __export(Relation_exports, {
   sortByTypename: () => sortByTypename2,
   subscribe: () => subscribe2,
   toJSON: () => toJSON,
+  update: () => update,
   version: () => version2
 });
 import * as Schema from "effect/Schema";
@@ -116,7 +116,7 @@ var Unknown3 = Schema.Struct({
   // NOTE: The EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.
   //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.
   EchoRelationSchema({
-    typename: "org.dxos.schema.any-relation",
+    typename: "org.dxos.schema.anyRelation",
     version: "0.0.0",
     source: Unknown,
     target: Unknown
@@ -161,63 +161,35 @@ 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: 214,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
+  invariant(dxn instanceof DXN, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 100, S: void 0, A: ["dxn instanceof DXN", ""] });
   return dxn;
 };
 var getTargetDXN = (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",
-      ""
-    ]
-  });
+  invariant(dxn instanceof DXN, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 111, S: void 0, A: ["dxn instanceof DXN", ""] });
   return dxn;
 };
 var getSource = (relation) => {
   assertArgument(isRelation(relation), "Expected a relation");
   assumeType(relation);
   const obj = relation[RelationSourceId];
-  invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 240,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid source: ${relation.id}`"
-    ]
-  });
+  if (obj === void 0) {
+    throw new Error(`Relation source could not be resolved.`);
+  }
   return obj;
 };
 var getTarget = (relation) => {
   assertArgument(isRelation(relation), "Expected a relation");
   assumeType(relation);
   const obj = relation[RelationTargetId];
-  invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 253,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid target: ${relation.id}`"
-    ]
-  });
+  if (obj === void 0) {
+    throw new Error(`Relation target could not be resolved.`);
+  }
   return obj;
 };
-var change2 = (relation, callback) => {
+var update = (relation, callback) => {
   change(relation, callback);
 };
 var getSnapshot2 = getSnapshot;
@@ -265,7 +237,7 @@ export {
   getTargetDXN,
   getSource,
   getTarget,
-  change2 as change,
+  update,
   getSnapshot2 as getSnapshot,
   subscribe2 as subscribe,
   getValue2 as getValue,
@@ -295,4 +267,4 @@ export {
   version2 as version,
   Relation_exports
 };
-//# sourceMappingURL=chunk-CIRHIEMW.mjs.map
+//# sourceMappingURL=chunk-NSMLBSFS.mjs.map