@dxos/echo 0.8.4-main.7ace549 → 0.8.4-main.937b3ca

package/dist/lib/node-esm/chunk-4PNXQA64.mjs

@@ -0,0 +1,250 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  MetaId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  VersionTypeId,
+  addTag,
+  change,
+  deleteKeys,
+  getDXN,
+  getDatabase,
+  getDescription,
+  getKeys,
+  getLabel,
+  getMetaChecked,
+  getObjectDXN,
+  getSnapshot,
+  isDeleted,
+  isVersion,
+  makeObject,
+  objectToJSON,
+  removeTag,
+  setDescription,
+  setLabel,
+  setValue,
+  sort,
+  sortByLabel,
+  sortByTypename,
+  subscribe,
+  version
+} from "./chunk-LT3H4JOX.mjs";
+import {
+  getSchema,
+  getTypeAnnotation,
+  getTypeDXN,
+  getTypename
+} from "./chunk-YOLH5KS4.mjs";
+import {
+  EntityKind,
+  KindId,
+  SnapshotKindId
+} from "./chunk-XHJRMQZD.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Relation.ts
+var Relation_exports = {};
+__export(Relation_exports, {
+  Source: () => Source,
+  Target: () => Target,
+  VersionTypeId: () => VersionTypeId,
+  addTag: () => addTag2,
+  change: () => change2,
+  deleteKeys: () => deleteKeys2,
+  getDXN: () => getDXN2,
+  getDatabase: () => getDatabase2,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys2,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta,
+  getSchema: () => getSchema2,
+  getSnapshot: () => getSnapshot2,
+  getSource: () => getSource,
+  getSourceDXN: () => getSourceDXN,
+  getTarget: () => getTarget,
+  getTargetDXN: () => getTargetDXN,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename2,
+  getValue: () => getValue,
+  isDeleted: () => isDeleted2,
+  isRelation: () => isRelation,
+  isVersion: () => isVersion,
+  make: () => make,
+  removeTag: () => removeTag2,
+  setDescription: () => setDescription2,
+  setLabel: () => setLabel2,
+  setValue: () => setValue2,
+  sort: () => sort2,
+  sortByLabel: () => sortByLabel2,
+  sortByTypename: () => sortByTypename2,
+  subscribe: () => subscribe2,
+  toJSON: () => toJSON,
+  version: () => version2
+});
+import { raise } from "@dxos/debug";
+import { createJsonPath, getValue as getValue$ } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+import { assumeType } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
+var Source = RelationSourceId;
+var Target = RelationTargetId;
+var make = (schema, props, meta) => {
+  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, "schema", "Expected a relation schema");
+  if (props[MetaId] != null) {
+    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"));
+  props[RelationSourceDXNId] = sourceDXN;
+  props[RelationTargetDXNId] = targetDXN;
+  return makeObject(schema, props, meta);
+};
+var isRelation = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {
+    return true;
+  }
+  const kind = value[KindId] ?? value[SnapshotKindId];
+  return kind === EntityKind.Relation;
+};
+var getSourceDXN = (value) => {
+  assertArgument(isRelation(value), "Expected a relation");
+  assumeType(value);
+  const dxn = value[RelationSourceDXNId];
+  invariant(dxn instanceof DXN, void 0, {
+    F: __dxlog_file,
+    L: 188,
+    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: 201,
+    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: 214,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid source: ${relation.id}`"
+    ]
+  });
+  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: 227,
+    S: void 0,
+    A: [
+      "obj !== undefined",
+      "`Invalid target: ${relation.id}`"
+    ]
+  });
+  return obj;
+};
+var change2 = (relation, callback) => {
+  change(relation, callback);
+};
+var getSnapshot2 = getSnapshot;
+var subscribe2 = (rel, callback) => {
+  return subscribe(rel, callback);
+};
+var getValue = (rel, path) => {
+  return getValue$(rel, createJsonPath(path));
+};
+var setValue2 = setValue;
+var getDXN2 = (entity) => getDXN(entity);
+var getTypeDXN2 = getTypeDXN;
+var getSchema2 = getSchema;
+var getTypename2 = (entity) => getTypename(entity);
+var getDatabase2 = (entity) => getDatabase(entity);
+function getMeta(entity) {
+  return getMetaChecked(entity);
+}
+var getKeys2 = (entity, source) => getKeys(entity, source);
+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 setLabel2 = (entity, label) => setLabel(entity, label);
+var getDescription2 = (entity) => getDescription(entity);
+var setDescription2 = (entity, description) => setDescription(entity, description);
+var toJSON = (entity) => objectToJSON(entity);
+var sortByLabel2 = sortByLabel;
+var sortByTypename2 = sortByTypename;
+var sort2 = (...comparators) => sort(...comparators);
+var version2 = (entity) => version(entity);
+
+export {
+  Source,
+  Target,
+  make,
+  isRelation,
+  getSourceDXN,
+  getTargetDXN,
+  getSource,
+  getTarget,
+  change2 as change,
+  getSnapshot2 as getSnapshot,
+  subscribe2 as subscribe,
+  getValue,
+  setValue2 as setValue,
+  getDXN2 as getDXN,
+  getTypeDXN2 as getTypeDXN,
+  getSchema2 as getSchema,
+  getTypename2 as getTypename,
+  getDatabase2 as getDatabase,
+  getMeta,
+  getKeys2 as getKeys,
+  deleteKeys2 as deleteKeys,
+  addTag2 as addTag,
+  removeTag2 as removeTag,
+  isDeleted2 as isDeleted,
+  getLabel2 as getLabel,
+  setLabel2 as setLabel,
+  getDescription2 as getDescription,
+  setDescription2 as setDescription,
+  toJSON,
+  sortByLabel2 as sortByLabel,
+  sortByTypename2 as sortByTypename,
+  sort2 as sort,
+  version2 as version,
+  Relation_exports
+};
+//# sourceMappingURL=chunk-4PNXQA64.mjs.map

package/dist/lib/node-esm/chunk-4PNXQA64.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath, getValue as getValue$ } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, type ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport {\n  type ObjectJSON as APIJSON,\n  ATTR_RELATION_SOURCE,\n  ATTR_RELATION_TARGET,\n  type AnyEntity,\n  type Comparator as ApiComparator,\n  type Meta as ApiMeta,\n  type ReadonlyMeta as ApiReadonlyMeta,\n  type EntityVersion as ApiVersion,\n  type ChangeCallback,\n  EntityKind,\n  type InternalObjectProps,\n  type KindId,\n  MetaId,\n  type Mutable,\n  type ObjectMeta,\n  RelationSourceDXNId,\n  RelationSourceId,\n  RelationTargetDXNId,\n  RelationTargetId,\n  SnapshotKindId,\n  VersionTypeId,\n  addTag as addTag$,\n  change as change$,\n  deleteKeys as deleteKeys$,\n  getDXN as getDXN$,\n  getDatabase as getDatabase$,\n  getDescription as getDescription$,\n  getKeys as getKeys$,\n  getLabel as getLabel$,\n  getMetaChecked as getMeta$,\n  getObjectDXN,\n  getSchema as getSchema$,\n  getSnapshot as getSnapshot$,\n  getTypeAnnotation,\n  getTypeDXN as getTypeDXN$,\n  getTypename as getTypename$,\n  isDeleted as isDeleted$,\n  isVersion,\n  makeObject,\n  removeTag as removeTag$,\n  setDescription as setDescription$,\n  setLabel as setLabel$,\n  setValue as setValue$,\n  sort as sort$,\n  sortByLabel as sortByLabel$,\n  sortByTypename as sortByTypename$,\n  subscribe as subscribe$,\n  objectToJSON as toJSON$,\n  version as version$,\n} from './internal';\nimport type * as Obj from './Obj';\nimport type * as Type from './Type';\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends AnyEntity,\n    Type.Relation.Endpoints<Source, Target>,\n    Entity.OfKind<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 * Relation type with specific source and target types.\n */\nexport type Relation<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 AnyEntity, Type.Relation.Endpoints<Source, Target> {\n  readonly [SnapshotKindId]: EntityKind.Relation;\n  readonly id: ObjectId;\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, KindId> & BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype RelationMakeProps<T extends Unknown> = {\n  id?: ObjectId;\n  [MetaId]?: ObjectMeta;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Type.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema.\n * Takes a schema type (created with Type.Relation) and extracts the props type.\n */\nexport type MakeProps<S extends Type.Relation.Any> = RelationMakeProps<Schema.Schema.Type<S>>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata.\n * @returns\n */\n// NOTE: Writing the definition this way (with generic over schema) makes typescript perfer to infer the type from the first param (this schema) rather than the second param (the props).\n// TODO(dmaretskyi): Move meta into props.\nexport const make = <S extends Type.Relation.Any>(\n  schema: S,\n  props: NoInfer<RelationMakeProps<Schema.Schema.Type<S>>>,\n  meta?: ObjectMeta,\n): Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, 'schema', 'Expected a relation schema');\n\n  if (props[MetaId] != null) {\n    meta = props[MetaId] as any;\n    delete props[MetaId];\n  }\n\n  const sourceDXN = getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[RelationSourceDXNId] = sourceDXN;\n  (props as any)[RelationTargetDXNId] = targetDXN;\n\n  return makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (ATTR_RELATION_SOURCE in value || 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)[SnapshotKindId];\n  return kind === EntityKind.Relation;\n};\n\n/**\n * @returns Relation source DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): Type.Relation.Source<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[RelationSourceId];\n  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\n  return obj as Type.Relation.Source<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): Type.Relation.Target<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as Type.Relation.Target<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.change`.\n */\nexport type { Mutable };\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.change` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.change` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.change\n * Relation.change(worksFor, (r) => {\n *   r.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.change` for objects.\n */\nexport const change = <T extends Unknown>(relation: T, callback: ChangeCallback<T>): void => {\n  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> = 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 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 getValue$(rel, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  setValue$ as any;\n\n//\n// Type\n//\n\n/**\n * Get the DXN of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => getDXN$(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeDXN = getTypeDXN$;\n\n/**\n * Get the schema of the relation.\n * Returns the branded ECHO schema used to create the relation.\n */\nexport const getSchema: (rel: unknown | undefined) => Type.Entity.Any | undefined = getSchema$ as any;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => 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 => getDatabase$(entity);\n\n//\n// Meta\n//\n\n/**\n * Deeply read-only version of ObjectMeta.\n */\nexport type ReadonlyMeta = ApiReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.change` callback.\n */\nexport type Meta = ApiMeta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.change` callback).\n * Returns read-only meta when passed a regular relation or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): ObjectMeta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): ObjectMeta | ReadonlyMeta {\n  return getMeta$(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[] => getKeys$(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => deleteKeys$(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => addTag$(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => 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 => isDeleted$(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => getLabel$(entity);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => 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 => getDescription$(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  setDescription$(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = APIJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => toJSON$(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 = ApiComparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = sortByLabel$ as Comparator;\nexport const sortByTypename: Comparator = sortByTypename$ as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => sort$(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport { VersionTypeId, isVersion };\n\n/**\n * Represent relation version.\n */\nexport type Version = ApiVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => version$(entity);\n"],
+  "mappings": "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",
+  "names": ["addTag", "change", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "raise", "createJsonPath", "getValue", "getValue$", "assertArgument", "invariant", "DXN", "assumeType", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "Relation", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "makeObject", "isRelation", "value", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "KindId", "SnapshotKindId", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "undefined", "id", "getTarget", "change", "callback", "change$", "getSnapshot", "getSnapshot$", "subscribe", "rel", "subscribe$", "getValue", "path", "getValue$", "createJsonPath", "setValue", "setValue$", "getDXN", "entity", "getDXN$", "getTypeDXN", "getTypeDXN$", "getSchema", "getSchema$", "getTypename", "getTypename$", "getDatabase", "getDatabase$", "getMeta", "getMeta$", "getKeys", "source", "getKeys$", "deleteKeys", "deleteKeys$", "addTag", "tag", "addTag$", "removeTag", "removeTag$", "isDeleted", "isDeleted$", "getLabel", "getLabel$", "setLabel", "label", "setLabel$", "getDescription", "getDescription$", "setDescription", "description", "setDescription$", "toJSON", "toJSON$", "sortByLabel", "sortByLabel$", "sortByTypename", "sortByTypename$", "sort", "comparators", "sort$", "version", "entity", "version$"]
+}

package/dist/lib/node-esm/chunk-5OBN7GZW.mjs

@@ -0,0 +1,158 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  is,
+  props,
+  type
+} from "./chunk-QYR67VBV.mjs";
+import {
+  getTypeDXNFromSpecifier
+} from "./chunk-YOLH5KS4.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Query.ts
+var Query_exports = {};
+__export(Query_exports, {
+  all: () => all,
+  fromAst: () => fromAst,
+  is: () => is2,
+  select: () => select,
+  type: () => type2,
+  without: () => without
+});
+var QueryClass = class _QueryClass {
+  ast;
+  static variance = {};
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Query" = _QueryClass.variance;
+  select(filter) {
+    if (is(filter)) {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: filter.ast
+      });
+    } else {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: props(filter).ast
+      });
+    }
+  }
+  reference(key) {
+    return new _QueryClass({
+      type: "reference-traversal",
+      anchor: this.ast,
+      property: key
+    });
+  }
+  referencedBy(target, key) {
+    const dxn = target !== void 0 ? getTypeDXNFromSpecifier(target) : null;
+    return new _QueryClass({
+      type: "incoming-references",
+      anchor: this.ast,
+      property: key ?? null,
+      typename: dxn?.toString() ?? null
+    });
+  }
+  sourceOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "outgoing",
+      filter: type(relation, predicates).ast
+    });
+  }
+  targetOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "incoming",
+      filter: type(relation, predicates).ast
+    });
+  }
+  source() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "source"
+    });
+  }
+  target() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "target"
+    });
+  }
+  orderBy(...order) {
+    return new _QueryClass({
+      type: "order",
+      query: this.ast,
+      order: order.map((o) => o.ast)
+    });
+  }
+  limit(limit) {
+    return new _QueryClass({
+      type: "limit",
+      query: this.ast,
+      limit
+    });
+  }
+  options(options) {
+    return new _QueryClass({
+      type: "options",
+      query: this.ast,
+      options
+    });
+  }
+};
+var is2 = (value) => {
+  return typeof value === "object" && value !== null && "~Query" in value;
+};
+var fromAst = (ast) => {
+  return new QueryClass(ast);
+};
+var select = (filter) => {
+  return new QueryClass({
+    type: "select",
+    filter: filter.ast
+  });
+};
+var type2 = (schema, predicates) => {
+  return new QueryClass({
+    type: "select",
+    filter: type(schema, predicates).ast
+  });
+};
+var all = (...queries) => {
+  if (queries.length === 0) {
+    throw new TypeError("Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())");
+  }
+  return new QueryClass({
+    type: "union",
+    queries: queries.map((q) => q.ast)
+  });
+};
+var without = (source, exclude) => {
+  return new QueryClass({
+    type: "set-difference",
+    source: source.ast,
+    exclude: exclude.ast
+  });
+};
+
+export {
+  is2 as is,
+  fromAst,
+  select,
+  type2 as type,
+  all,
+  without,
+  Query_exports
+};
+//# sourceMappingURL=chunk-5OBN7GZW.mjs.map

package/dist/lib/node-esm/chunk-5OBN7GZW.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Query.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as EffectArray from 'effect/Array';\nimport type * as Schema from 'effect/Schema';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nimport * as Filter from './Filter';\nimport { getTypeDXNFromSpecifier } from './internal';\nimport type * as Order from './Order';\nimport type * as Ref from './Ref';\nimport type * as Type$ from './Type';\n\n// TODO(dmaretskyi): Split up into interfaces for objects and relations so they can have separate verbs.\n// TODO(dmaretskyi): Undirected relation traversals.\n// TODO(wittjosiah): Make Filter & Query pipeable.\n\n/**\n * All property paths inside T that are references.\n */\n// TODO(dmaretskyi): Filter only properties that are references (or optional references, or unions that include references).\ntype RefPropKey<T> = keyof T & string;\n\n// TODO(burdon): Narrow T to Entity.Unknown?\nexport interface Query<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Query': { value: T };\n\n  ast: QueryAST.Query;\n\n  /**\n   * Filter the current selection based on a filter.\n   * @param filter - Filter to select the objects.\n   * @returns Query for the selected objects.\n   */\n  select(filter: Filter.Filter<T>): Query<T>;\n  select(props: Filter.Props<T>): Query<T>;\n\n  /**\n   * Traverse an outgoing reference.\n   * @param key - Property path inside T that is a reference or optional reference.\n   * @returns Query for the target of the reference.\n   */\n  reference<K extends RefPropKey<T>>(\n    key: K,\n  ): Query<\n    T[K] extends Ref.Unknown\n      ? Ref.Target<T[K]>\n      : T[K] extends Ref.Unknown | undefined\n        ? Ref.Target<Exclude<T[K], undefined>>\n        : never\n  >;\n\n  /**\n   * Find objects referencing this object.\n   * @param target - Schema of the referencing object. If not provided, matches any type.\n   * @param key - Property path inside the referencing object that is a reference. If not provided, matches any property.\n   * @returns Query for the referencing objects.\n   */\n  // TODO(dmaretskyi): any way to enforce `Ref.Target<Schema.Schema.Type<S>[key]> == T`?\n  // TODO(dmaretskyi): Ability to go through arrays of references.\n  referencedBy<S extends Schema.Schema.All>(\n    target: S | string,\n    key: RefPropKey<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n  referencedBy<S extends Schema.Schema.All>(target: S | string): Query<Schema.Schema.Type<S>>;\n  referencedBy(): Query<any>;\n\n  /**\n   * Find relations where this object is the source.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  sourceOf<S extends Schema.Schema.All>(\n    relation: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Find relations where this object is the target.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  targetOf<S extends Schema.Schema.All>(\n    relation: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * For a query for relations, get the source objects.\n   * @returns Query for the source objects.\n   */\n  source(): Query<Type$.Relation.Source<T>>;\n\n  /**\n   * For a query for relations, get the target objects.\n   * @returns Query for the target objects.\n   */\n  target(): Query<Type$.Relation.Target<T>>;\n\n  /**\n   * Order the query results.\n   * Orders are specified in priority order. The first order will be applied first, etc.\n   * @param order - Order to sort the results.\n   * @returns Query for the ordered results.\n   */\n  orderBy(...order: EffectArray.NonEmptyArray<Order.Order<T>>): Query<T>;\n\n  /**\n   * Limit the number of results.\n   * @param limit - Maximum number of results to return.\n   * @returns Query for the limited results.\n   */\n  limit(limit: number): Query<T>;\n\n  /**\n   * Add options to a query.\n   */\n  options(options: QueryAST.QueryOptions): Query<T>;\n}\n\nexport type Any = Query<any>;\n\nexport type Type<Q extends Any> = Q extends Query<infer T> ? T : never;\n\nclass QueryClass implements Any {\n  private static variance: Any['~Query'] = {} as Any['~Query'];\n\n  constructor(public readonly ast: QueryAST.Query) {}\n\n  '~Query' = QueryClass.variance;\n\n  select(filter: Filter.Any | Filter.Props<any>): Any {\n    if (Filter.is(filter)) {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: filter.ast,\n      });\n    } else {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: Filter.props(filter).ast,\n      });\n    }\n  }\n\n  reference(key: string): Any {\n    return new QueryClass({\n      type: 'reference-traversal',\n      anchor: this.ast,\n      property: key,\n    });\n  }\n\n  referencedBy(target?: Schema.Schema.All | string, key?: string): Any {\n    const dxn = target !== undefined ? getTypeDXNFromSpecifier(target) : null;\n    return new QueryClass({\n      type: 'incoming-references',\n      anchor: this.ast,\n      property: key ?? null,\n      typename: dxn?.toString() ?? null,\n    });\n  }\n\n  sourceOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'outgoing',\n      filter: Filter.type(relation, predicates).ast,\n    });\n  }\n\n  targetOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'incoming',\n      filter: Filter.type(relation, predicates).ast,\n    });\n  }\n\n  source(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'source',\n    });\n  }\n\n  target(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'target',\n    });\n  }\n\n  orderBy(...order: Order.Order<any>[]): Any {\n    return new QueryClass({\n      type: 'order',\n      query: this.ast,\n      order: order.map((o) => o.ast),\n    });\n  }\n\n  limit(limit: number): Any {\n    return new QueryClass({\n      type: 'limit',\n      query: this.ast,\n      limit,\n    });\n  }\n\n  options(options: QueryAST.QueryOptions): Any {\n    return new QueryClass({\n      type: 'options',\n      query: this.ast,\n      options,\n    });\n  }\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Query' in value;\n};\n\n/** Construct a query from an ast. */\nexport const fromAst = (ast: QueryAST.Query): Any => {\n  return new QueryClass(ast);\n};\n\n/**\n * Select objects based on a filter.\n * @param filter - Filter to select the objects.\n * @returns Query for the selected objects.\n */\nexport const select = <F extends Filter.Any>(filter: F): Query<Filter.Type<F>> => {\n  return new QueryClass({\n    type: 'select',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Query for objects of a given schema.\n * @param schema - Schema of the objects.\n * @param predicates - Predicates to filter the objects.\n * @returns Query for the objects.\n *\n * Shorthand for: `Query.select(Filter.type(schema, predicates))`.\n */\nexport const type = (schema: Schema.Schema.All | string, predicates?: Filter.Props<unknown>): Any => {\n  return new QueryClass({\n    type: 'select',\n    filter: Filter.type(schema, predicates).ast,\n  });\n};\n\n/**\n * Combine results of multiple queries.\n * @param queries - Queries to combine.\n * @returns Query for the combined results.\n */\n// TODO(dmaretskyi): Rename to `combine` or `union`.\nexport const all = (...queries: Any[]): Any => {\n  if (queries.length === 0) {\n    throw new TypeError(\n      'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',\n    );\n  }\n  return new QueryClass({\n    type: 'union',\n    queries: queries.map((q) => q.ast),\n  });\n};\n\n/**\n * Subtract one query from another.\n * @param source - Query to subtract from.\n * @param exclude - Query to subtract.\n * @returns Query for the results of the source query minus the results of the exclude query.\n */\nexport const without = <T>(source: Query<T>, exclude: Query<T>): Query<T> => {\n  return new QueryClass({\n    type: 'set-difference',\n    source: source.ast,\n    exclude: exclude.ast,\n  });\n};\n"],
+  "mappings": "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",
+  "names": ["is", "type", "QueryClass", "variance", "ast", "select", "filter", "is", "type", "selection", "props", "reference", "key", "anchor", "property", "referencedBy", "target", "dxn", "undefined", "getTypeDXNFromSpecifier", "typename", "toString", "sourceOf", "relation", "predicates", "direction", "targetOf", "source", "orderBy", "order", "query", "map", "o", "limit", "options", "value", "fromAst", "schema", "all", "queries", "length", "TypeError", "q", "without", "exclude"]
+}

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

@@ -0,0 +1,22 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Key.ts
+var Key_exports = {};
+__export(Key_exports, {
+  ForeignKey: () => ForeignKey,
+  ObjectId: () => ObjectId,
+  SpaceId: () => SpaceId
+});
+import { ForeignKey } from "@dxos/echo-protocol";
+import { SpaceId, ObjectId } from "@dxos/keys";
+
+export {
+  Key_exports,
+  ForeignKey,
+  SpaceId,
+  ObjectId
+};
+//# sourceMappingURL=chunk-AJEMYSIR.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Key.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// TODO(wittjosiah): Should this be a subset of Type?\n\nexport { ForeignKey } from '@dxos/echo-protocol';\nexport { SpaceId, ObjectId } from '@dxos/keys';\n"],
+  "mappings": ";;;;;;AAAA;;;;;;AAMA,SAASA,kBAAkB;AAC3B,SAASC,SAASC,gBAAgB;",
+  "names": ["ForeignKey", "SpaceId", "ObjectId"]
+}

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

@@ -0,0 +1,98 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+import {
+  addTag,
+  change,
+  getDXN,
+  getDatabase,
+  getDescription,
+  getKeys,
+  getLabel,
+  getMetaChecked,
+  isDeleted,
+  objectToJSON,
+  removeTag,
+  subscribe
+} from "./chunk-LT3H4JOX.mjs";
+import {
+  getEntityKind,
+  getTypeDXN,
+  getTypename
+} from "./chunk-YOLH5KS4.mjs";
+import {
+  EntityKind,
+  EntityKindSchema,
+  KindId,
+  SnapshotKindId
+} from "./chunk-XHJRMQZD.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/Entity.ts
+var Entity_exports = {};
+__export(Entity_exports, {
+  Kind: () => Kind,
+  KindId: () => KindId,
+  KindSchema: () => KindSchema,
+  SnapshotKindId: () => SnapshotKindId,
+  addTag: () => addTag2,
+  change: () => change2,
+  getDXN: () => getDXN2,
+  getDatabase: () => getDatabase2,
+  getDescription: () => getDescription2,
+  getKeys: () => getKeys2,
+  getKind: () => getKind,
+  getLabel: () => getLabel2,
+  getMeta: () => getMeta,
+  getTypeDXN: () => getTypeDXN2,
+  getTypename: () => getTypename2,
+  isDeleted: () => isDeleted2,
+  removeTag: () => removeTag2,
+  subscribe: () => subscribe2,
+  toJSON: () => toJSON
+});
+var Kind = EntityKind;
+var KindSchema = EntityKindSchema;
+var getKind = getEntityKind;
+var getDXN2 = (entity) => getDXN(entity);
+var getTypeDXN2 = getTypeDXN;
+var getTypename2 = (entity) => getTypename(entity);
+var getDatabase2 = (entity) => getDatabase(entity);
+function getMeta(entity) {
+  return getMetaChecked(entity);
+}
+var getKeys2 = (entity, source) => getKeys(entity, source);
+var isDeleted2 = (entity) => isDeleted(entity);
+var getLabel2 = (entity) => getLabel(entity);
+var getDescription2 = (entity) => getDescription(entity);
+var toJSON = (entity) => objectToJSON(entity);
+var subscribe2 = (entity, callback) => {
+  return subscribe(entity, callback);
+};
+var change2 = (entity, callback) => {
+  change(entity, callback);
+};
+var addTag2 = (entity, tag) => addTag(entity, tag);
+var removeTag2 = (entity, tag) => removeTag(entity, tag);
+
+export {
+  Kind,
+  KindSchema,
+  getKind,
+  getDXN2 as getDXN,
+  getTypeDXN2 as getTypeDXN,
+  getTypename2 as getTypename,
+  getDatabase2 as getDatabase,
+  getMeta,
+  getKeys2 as getKeys,
+  isDeleted2 as isDeleted,
+  getLabel2 as getLabel,
+  getDescription2 as getDescription,
+  toJSON,
+  subscribe2 as subscribe,
+  change2 as change,
+  addTag2 as addTag,
+  removeTag2 as removeTag,
+  Entity_exports
+};
+//# sourceMappingURL=chunk-ANLVLWME.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Entity.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport type { DXN, ObjectId } from '@dxos/keys';\n\nimport {\n  type ChangeCallback,\n  EntityKind,\n  EntityKindSchema,\n  KindId,\n  type Mutable,\n  type ObjectJSON,\n  type ObjectMeta,\n  type ReadonlyMeta,\n  SnapshotKindId,\n  addTag as addTag$,\n  change as change$,\n  getDXN as getDXN$,\n  getDatabase as getDatabase$,\n  getDescription as getDescription$,\n  getEntityKind,\n  getKeys as getKeys$,\n  getLabel as getLabel$,\n  getMetaChecked as getMeta$,\n  getTypeDXN as getTypeDXN$,\n  getTypename as getTypename$,\n  isDeleted as isDeleted$,\n  removeTag as removeTag$,\n  subscribe as subscribe$,\n  objectToJSON as toJSON$,\n} from './internal';\n\n// Re-export KindId and SnapshotKindId from internal.\nexport { KindId, SnapshotKindId };\n\n// NOTE: Relation does not extend Obj so that, for example, we can prevent Relations from being used as source and target objects.\n//  However, we generally refer to Obj and Relation instances as \"objects\",\n//  and many API methods accept both Obj.Unknown and Relation.Unknown (i.e., Entity.Unknown) instances.\n\nexport const Kind = EntityKind;\nexport type Kind = EntityKind;\nexport const KindSchema = EntityKindSchema;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n * NOTE: Needed to make `isRelation` and `isObject` checks work.\n */\nexport interface OfKind<K extends Kind> {\n  readonly [KindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Assigns a snapshot kind to an Object or Relation snapshot.\n */\nexport interface SnapshotOfKind<K extends Kind> {\n  readonly [SnapshotKindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Obj or Relation with a specific set of properties.\n */\nexport type Entity<Props> = OfKind<Kind> & Props;\n\n/**\n * Unknown Obj or Relation (reactive).\n */\nexport interface Unknown extends OfKind<Kind> {}\n\n/**\n * Snapshot of an Obj or Relation.\n * Branded with SnapshotKindId instead of KindId.\n */\nexport interface Snapshot extends SnapshotOfKind<Kind> {}\n\n/**\n * Object with arbitrary properties.\n *\n * NOTE: Due to how typescript works, this type is not assignable to a specific schema type.\n * In that case, use `Obj.instanceOf` to check if an object is of a specific type.\n *\n * This type is very permissive and allows accessing any property on the object.\n * We should move to Obj.Unknown that is not permissive and requires explicit instanceof checks..\n */\nexport interface Any extends OfKind<Kind> {\n  [key: string]: unknown;\n}\n\nexport const getKind = getEntityKind;\n\n//\n// Entity-level functions that work on any entity (object or relation).\n// Use these when you don't know or care about the specific entity kind.\n// For kind-specific functions, use Obj.* or Relation.*.\n//\n\n/**\n * JSON representation of an entity.\n */\nexport type JSON = ObjectJSON;\n\n/**\n * Get the DXN of an entity (object or relation).\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => getDXN$(entity);\n\n/**\n * Get the DXN of an entity's type.\n */\nexport const getTypeDXN = getTypeDXN$;\n\n/**\n * Get the typename of an entity's type.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => getTypename$(entity);\n\n/**\n * Get the database an entity belongs to.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): any | undefined => getDatabase$(entity);\n\n/**\n * Get the metadata for an entity.\n * Returns mutable meta when passed a mutable entity (inside change callback).\n * Returns read-only meta when passed a regular entity or snapshot.\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): ObjectMeta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): ObjectMeta | ReadonlyMeta {\n  return getMeta$(entity);\n}\n\n/**\n * Get foreign keys for an entity from the specified source.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => getKeys$(entity, source);\n\n/**\n * Check if an entity is deleted.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => isDeleted$(entity);\n\n/**\n * Get the label of an entity.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => getLabel$(entity);\n\n/**\n * Get the description of an entity.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => getDescription$(entity);\n\n/**\n * Convert an entity to its JSON representation.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => toJSON$(entity);\n\n/**\n * Subscribe to changes on an entity (object or relation).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (entity: Unknown, callback: () => void): (() => void) => {\n  return subscribe$(entity, callback);\n};\n\n//\n// Change\n//\n\n/**\n * Used to provide a mutable view of an entity within `Entity.change`.\n */\nexport type { Mutable };\n\n/**\n * Perform mutations on an entity (object or relation) within a change context.\n *\n * Entities are read-only by default. Mutations are batched and notifications fire\n * when the callback completes. Direct mutations outside of `Entity.change` will throw\n * at runtime.\n *\n * @param entity - The echo entity (object or relation) to mutate.\n * @param callback - Receives a mutable view of the entity. All mutations must occur here.\n *\n * @example\n * ```typescript\n * // Mutate within Entity.change\n * Entity.change(entity, (e) => {\n *   e.name = 'Updated';\n *   e.count = 42;\n * });\n *\n * // Direct mutation throws\n * entity.name = 'Bob'; // Error: Cannot modify outside Entity.change()\n * ```\n *\n * Note: For type-specific operations, prefer `Obj.change` or `Relation.change`.\n */\nexport const change = <T extends Unknown>(entity: T, callback: ChangeCallback<T>): void => {\n  change$(entity, callback);\n};\n\n/**\n * Add a tag to an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => addTag$(entity, tag);\n\n/**\n * Remove a tag from an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => removeTag$(entity, tag);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;gBAAAA;EAAA,cAAAC;EAAA,cAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,eAAAC;EAAA;kBAAAC;EAAA;oBAAAC;EAAA,mBAAAC;EAAA,iBAAAC;EAAA,iBAAAC;EAAA,iBAAAC;EAAA;;AAyCO,IAAMC,OAAOC;AAEb,IAAMC,aAAaC;AAgDnB,IAAMC,UAAUC;AAgBhB,IAAMC,UAAS,CAACC,WAAoCC,OAAQD,MAAAA;AAK5D,IAAME,cAAaC;AAKnB,IAAMC,eAAc,CAACJ,WAAmDK,YAAaL,MAAAA;AAKrF,IAAMM,eAAc,CAACN,WAAgDO,YAAaP,MAAAA;AAUlF,SAASQ,QAAQR,QAA6C;AACnE,SAAOS,eAAST,MAAAA;AAClB;AAKO,IAAMU,WAAU,CAACV,QAA4BW,WAAiCC,QAASZ,QAAQW,MAAAA;AAK/F,IAAME,aAAY,CAACb,WAAwCc,UAAWd,MAAAA;AAKtE,IAAMe,YAAW,CAACf,WAAmDgB,SAAUhB,MAAAA;AAK/E,IAAMiB,kBAAiB,CAACjB,WAAmDkB,eAAgBlB,MAAAA;AAK3F,IAAMmB,SAAS,CAACnB,WAAqCoB,aAAQpB,MAAAA;AAM7D,IAAMqB,aAAY,CAACrB,QAAiBsB,aAAAA;AACzC,SAAOC,UAAWvB,QAAQsB,QAAAA;AAC5B;AAmCO,IAAME,UAAS,CAAoBxB,QAAWsB,aAAAA;AACnDG,SAAQzB,QAAQsB,QAAAA;AAClB;AAMO,IAAMI,UAAS,CAAC1B,QAA0B2B,QAAsBC,OAAQ5B,QAAQ2B,GAAAA;AAMhF,IAAME,aAAY,CAAC7B,QAA0B2B,QAAsBG,UAAW9B,QAAQ2B,GAAAA;",
+  "names": ["addTag", "change", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "subscribe", "Kind", "EntityKind", "KindSchema", "EntityKindSchema", "getKind", "getEntityKind", "getDXN", "entity", "getDXN$", "getTypeDXN", "getTypeDXN$", "getTypename", "getTypename$", "getDatabase", "getDatabase$", "getMeta", "getMeta$", "getKeys", "source", "getKeys$", "isDeleted", "isDeleted$", "getLabel", "getLabel$", "getDescription", "getDescription$", "toJSON", "toJSON$", "subscribe", "callback", "subscribe$", "change", "change$", "addTag", "tag", "addTag$", "removeTag", "removeTag$"]
+}