@dxos/echo 0.10.0 → 0.11.1

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

@@ -1,75 +0,0 @@
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Err.ts
-var Err_exports = {};
-__export(Err_exports, {
-  EntityNotFoundError: () => EntityNotFoundError,
-  GetReactiveError: () => GetReactiveError,
-  SchemaNotFoundError: () => SchemaNotFoundError,
-  TextEditNotFoundError: () => TextEditNotFoundError,
-  TextNotSupportedError: () => TextNotSupportedError
-});
-import { BaseError } from "@dxos/errors";
-var SchemaNotFoundError = class extends BaseError.extend("SchemaNotFoundError", "Schema not found") {
-  constructor(schema, options) {
-    super({
-      context: {
-        schema
-      },
-      ...options
-    });
-  }
-};
-var EntityNotFoundError = class extends BaseError.extend("EntityNotFoundError", "Entity not found") {
-  constructor(uri, options) {
-    super({
-      context: {
-        uri
-      },
-      ...options
-    });
-  }
-};
-var TextNotSupportedError = class extends BaseError.extend("TextNotSupportedError", "Text operation is not supported for this object") {
-  constructor(operation, options) {
-    super({
-      context: {
-        operation
-      },
-      ...options
-    });
-  }
-};
-var TextEditNotFoundError = class extends BaseError.extend("TextEditNotFoundError", "Edit text not found") {
-  constructor(oldString, options) {
-    super({
-      context: {
-        oldString
-      },
-      ...options
-    });
-  }
-};
-var GetReactiveError = class extends BaseError.extend("GetReactiveError", "Failed to get reactive object from snapshot") {
-  constructor(options) {
-    super({
-      context: {
-        reason: options.reason,
-        snapshotId: options.snapshotId
-      },
-      ...options
-    });
-  }
-};
-
-export {
-  SchemaNotFoundError,
-  EntityNotFoundError,
-  TextNotSupportedError,
-  TextEditNotFoundError,
-  GetReactiveError,
-  Err_exports
-};
-//# sourceMappingURL=chunk-TOCVVFK2.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Err.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\nimport { type URI } from '@dxos/keys';\n\nexport class SchemaNotFoundError extends BaseError.extend('SchemaNotFoundError', 'Schema not found') {\n  constructor(schema: string, options?: BaseErrorOptions) {\n    super({ context: { schema }, ...options });\n  }\n}\n\nexport class EntityNotFoundError extends BaseError.extend('EntityNotFoundError', 'Entity not found') {\n  constructor(uri: URI.URI, options?: BaseErrorOptions) {\n    super({ context: { uri }, ...options });\n  }\n}\n\n/**\n * Thrown when a `Text` mutation is attempted on an object whose reactive handler does not implement\n * string CRDT editing (e.g. a snapshot or a non-reactive value).\n */\nexport class TextNotSupportedError extends BaseError.extend(\n  'TextNotSupportedError',\n  'Text operation is not supported for this object',\n) {\n  constructor(operation: string, options?: BaseErrorOptions) {\n    super({ context: { operation }, ...options });\n  }\n}\n\n/**\n * Thrown by `Text.apply` when a non-`replaceAll` edit's `oldString` is not found in the text.\n */\nexport class TextEditNotFoundError extends BaseError.extend('TextEditNotFoundError', 'Edit text not found') {\n  constructor(oldString: string, options?: BaseErrorOptions) {\n    super({ context: { oldString }, ...options });\n  }\n}\n\n/**\n * Reason why getting a reactive object from a snapshot failed.\n * - `no-database`: The snapshot is not associated with a database.\n * - `object-not-found`: The object was removed or does not exist in the database.\n */\nexport type GetReactiveErrorReason = 'no-database' | 'object-not-found';\n\n/**\n * Error thrown when a reactive object cannot be resolved from a snapshot.\n * Extends `BaseError` with a `reason` and optional `snapshotId` in its context.\n */\nexport class GetReactiveError extends BaseError.extend(\n  'GetReactiveError',\n  'Failed to get reactive object from snapshot',\n) {\n  constructor(options: { reason: GetReactiveErrorReason; snapshotId?: string } & BaseErrorOptions) {\n    super({ context: { reason: options.reason, snapshotId: options.snapshotId }, ...options });\n  }\n}\n"],
-  "mappings": ";;;;;AAAA;;;;;;;;AAMA,SAASA,iBAAwC;AAG1C,IAAMC,sBAAN,cAAkCD,UAAUE,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYC,QAAgBC,SAA4B;AACtD,UAAM;MAAEC,SAAS;QAAEF;MAAO;MAAG,GAAGC;IAAQ,CAAA;EAC1C;AACF;AAEO,IAAME,sBAAN,cAAkCN,UAAUE,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYK,KAAcH,SAA4B;AACpD,UAAM;MAAEC,SAAS;QAAEE;MAAI;MAAG,GAAGH;IAAQ,CAAA;EACvC;AACF;AAMO,IAAMI,wBAAN,cAAoCR,UAAUE,OACnD,yBACA,iDAAA,EAAA;EAEA,YAAYO,WAAmBL,SAA4B;AACzD,UAAM;MAAEC,SAAS;QAAEI;MAAU;MAAG,GAAGL;IAAQ,CAAA;EAC7C;AACF;AAKO,IAAMM,wBAAN,cAAoCV,UAAUE,OAAO,yBAAyB,qBAAA,EAAA;EACnF,YAAYS,WAAmBP,SAA4B;AACzD,UAAM;MAAEC,SAAS;QAAEM;MAAU;MAAG,GAAGP;IAAQ,CAAA;EAC7C;AACF;AAaO,IAAMQ,mBAAN,cAA+BZ,UAAUE,OAC9C,oBACA,6CAAA,EAAA;EAEA,YAAYE,SAAqF;AAC/F,UAAM;MAAEC,SAAS;QAAEQ,QAAQT,QAAQS;QAAQC,YAAYV,QAAQU;MAAW;MAAG,GAAGV;IAAQ,CAAA;EAC1F;AACF;",
-  "names": ["BaseError", "SchemaNotFoundError", "extend", "schema", "options", "context", "EntityNotFoundError", "uri", "TextNotSupportedError", "operation", "TextEditNotFoundError", "oldString", "GetReactiveError", "reason", "snapshotId"]
-}

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

@@ -1,41 +0,0 @@
-import {
-  getSchema
-} from "./chunk-XB6ISRAO.mjs";
-import {
-  getSchemaURI
-} from "./chunk-3TN2VMI4.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Migration.ts
-var Migration_exports = {};
-__export(Migration_exports, {
-  define: () => define
-});
-var define = (options) => {
-  const fromSchema = getSchema(options.from);
-  const toSchema = getSchema(options.to);
-  const fromType = getSchemaURI(fromSchema);
-  if (!fromType) {
-    throw new Error("Invalid from schema");
-  }
-  const toType = getSchemaURI(toSchema);
-  if (!toType) {
-    throw new Error("Invalid to schema");
-  }
-  return {
-    fromType,
-    toType,
-    fromSchema,
-    toSchema,
-    transform: options.transform,
-    onMigration: options.onMigration
-  };
-};
-
-export {
-  define,
-  Migration_exports
-};
-//# sourceMappingURL=chunk-U53LSQQA.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Migration.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { type EntityMeta, MetaId, getSchemaURI } from './internal';\nimport * as Type from './Type';\n\n/**\n * Result returned by a migration's `transform` callback.\n * The data shape matches the target schema; the optional `[Obj.Meta]` symbol key lets the\n * transform update the object's meta (e.g. `key` / `version`) atomically with the data swap.\n */\ntype MigrationSchemaInput = Type.AnyEntity;\n\ntype MigrationInstanceType<S> = S extends Type.AnyEntity\n  ? Type.InstanceType<S>\n  : S extends Schema.Schema.AnyNoContext\n    ? Schema.Schema.Type<S>\n    : never;\n\nexport type TransformResult<To> = Omit<MigrationInstanceType<To>, 'id' | Entity.KindId> & {\n  [MetaId]?: Partial<EntityMeta>;\n};\n\ntype DefineObjectMigrationOptions<From extends MigrationSchemaInput, To extends MigrationSchemaInput> = {\n  from: From;\n  to: To;\n  /**\n   * Pure function that converts the old object data to the new object data.\n   *\n   * The returned object may include an optional `[Obj.Meta]` entry to update the object's meta\n   * (e.g. registry `key` / `version`) atomically with the data swap.\n   */\n  // TODO(dmaretskyi): `id` should not be a part of the schema.\n  transform: (from: MigrationInstanceType<From>, context: ObjectMigrationContext) => Promise<TransformResult<To>>;\n\n  /**\n   * Callback that is called after the object is migrated. Called for every object that is migrated.\n   *\n   * NOTE: Database mutations performed in this callback are not guaranteed to be idempotent.\n   *       If multiple peers run the migration separately, the effects may be applied multiple times.\n   */\n  onMigration?: (params: OnMigrateProps<From, To>) => Promise<void>;\n};\n\n/**\n * Context passed to object migration callbacks.\n */\nexport type ObjectMigrationContext = {\n  db: Database.Database;\n};\n\ntype OnMigrateProps<From, To> = {\n  before: MigrationInstanceType<From>;\n  object: MigrationInstanceType<To>;\n  db: Database.Database;\n};\n\n/**\n * Definition of a migration from one object schema version to another.\n */\nexport type ObjectMigration = {\n  fromType: URI.URI;\n  toType: URI.URI;\n  fromSchema: Schema.Schema.AnyNoContext;\n  toSchema: Schema.Schema.AnyNoContext;\n  transform: (from: unknown, context: ObjectMigrationContext) => Promise<unknown>;\n  onMigration?: (params: OnMigrateProps<any, any>) => Promise<void>;\n};\n\n/**\n * Define a migration between two object schemas.\n *\n * @example\n * ```ts\n * const migration = Migration.define({\n *   from: ContactV1,\n *   to: ContactV2,\n *   transform: async (from) => ({ name: `${from.firstName} ${from.lastName}` }),\n *   onMigration: async () => {},\n * });\n * ```\n */\nexport const define = <From extends MigrationSchemaInput, To extends MigrationSchemaInput>(\n  options: DefineObjectMigrationOptions<From, To>,\n): ObjectMigration => {\n  const fromSchema = Type.getSchema(options.from);\n  const toSchema = Type.getSchema(options.to);\n  const fromType = getSchemaURI(fromSchema);\n  if (!fromType) {\n    throw new Error('Invalid from schema');\n  }\n  const toType = getSchemaURI(toSchema);\n  if (!toType) {\n    throw new Error('Invalid to schema');\n  }\n\n  return {\n    fromType,\n    toType,\n    fromSchema,\n    toSchema,\n    transform: options.transform as any,\n    onMigration: options.onMigration as any,\n  };\n};\n"],
-  "mappings": ";;;;;;;;;;;AAAA;;;;AA2FO,IAAMA,SAAS,CACpBC,YAAAA;AAEA,QAAMC,aAAkBC,UAAUF,QAAQG,IAAI;AAC9C,QAAMC,WAAgBF,UAAUF,QAAQK,EAAE;AAC1C,QAAMC,WAAWC,aAAaN,UAAAA;AAC9B,MAAI,CAACK,UAAU;AACb,UAAM,IAAIE,MAAM,qBAAA;EAClB;AACA,QAAMC,SAASF,aAAaH,QAAAA;AAC5B,MAAI,CAACK,QAAQ;AACX,UAAM,IAAID,MAAM,mBAAA;EAClB;AAEA,SAAO;IACLF;IACAG;IACAR;IACAG;IACAM,WAAWV,QAAQU;IACnBC,aAAaX,QAAQW;EACvB;AACF;",
-  "names": ["define", "options", "fromSchema", "getSchema", "from", "toSchema", "to", "fromType", "getSchemaURI", "Error", "toType", "transform", "onMigration"]
-}

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

@@ -1,27 +0,0 @@
-import {
-  JsonSchemaType,
-  toEffectSchema,
-  toJsonSchema
-} from "./chunk-4A2NWKRJ.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/JsonSchema.ts
-var JsonSchema_exports = {};
-__export(JsonSchema_exports, {
-  JsonSchema: () => JsonSchema,
-  toEffectSchema: () => toEffectSchema2,
-  toJsonSchema: () => toJsonSchema2
-});
-var toEffectSchema2 = toEffectSchema;
-var toJsonSchema2 = toJsonSchema;
-var JsonSchema = JsonSchemaType;
-
-export {
-  toEffectSchema2 as toEffectSchema,
-  toJsonSchema2 as toJsonSchema,
-  JsonSchema,
-  JsonSchema_exports
-};
-//# sourceMappingURL=chunk-UGFFV2FR.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/JsonSchema.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as jsonSchemaInternal from './internal/JsonSchema';\n\n/**\n * Decode JSON Schema to Effect Schema.\n */\nexport const toEffectSchema = jsonSchemaInternal.toEffectSchema;\n\n/**\n * Encode Effect Schema to JSON Schema.\n */\nexport const toJsonSchema = jsonSchemaInternal.toJsonSchema;\n\n/**\n * Serializable JsonSchema type definition.\n */\nexport type JsonSchema = jsonSchemaInternal.JsonSchemaType;\n\nexport const JsonSchema: Schema.Schema<jsonSchemaInternal.JsonSchemaType> = jsonSchemaInternal.JsonSchemaType;\n"],
-  "mappings": ";;;;;;;;;;AAAA;;;wBAAAA;EAAA,oBAAAC;;AAaO,IAAMC,kBAAoCA;AAK1C,IAAMC,gBAAkCA;AAOxC,IAAMC,aAAkFC;",
-  "names": ["toEffectSchema", "toJsonSchema", "toEffectSchema", "toJsonSchema", "JsonSchema", "JsonSchemaType"]
-}

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

@@ -1,7 +0,0 @@
-// src/QueryResult.ts
-var QueryResult_exports = {};
-
-export {
-  QueryResult_exports
-};
-//# sourceMappingURL=chunk-UWLP4RFM.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/QueryResult.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Atom from '@effect-atom/atom/Atom';\nimport type * as Effect from 'effect/Effect';\nimport type * as Option from 'effect/Option';\n\nimport { type CleanupFn } from '@dxos/async';\n\nimport type * as Entity from './Entity';\n\n/**\n * Individual query result entry.\n */\nexport type Entry<T> = {\n  id: string;\n\n  /**\n   * May not be present for remote results.\n   */\n  result?: T;\n\n  match?: {\n    // TODO(dmaretskyi): text positional info.\n\n    /**\n     * Higher means better match.\n     */\n    rank: number;\n  };\n\n  /**\n   * Query resolution metadata.\n   */\n  // TODO(dmaretskyi): Rename to meta?\n  resolution?: {\n    // TODO(dmaretskyi): Make this more generic.\n    source: 'remote' | 'local' | 'index';\n\n    /**\n     * Query resolution time in milliseconds.\n     */\n    time: number;\n  };\n};\n\n/**\n * Invidual query result entry for a database Entity.\n */\nexport type EntityEntry<T extends Entity.Unknown = Entity.Unknown> = Entry<T>;\n\nexport type RunOptions = {\n  timeout?: number;\n};\n\nexport type SubscriptionOptions = {\n  /**\n   * Fire the callback immediately.\n   */\n  fire?: boolean;\n};\n\n// TODO(burdon): Should T be constrained to Entity.Any?\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\n   */\n  readonly results: T[];\n\n  /**\n   * Returns all known results.\n   */\n  run(opts?: RunOptions): Promise<T[]>;\n\n  /**\n   * Returns all known results along with their match metadata.\n   */\n  runEntries(opts?: RunOptions): Promise<Entry<T>[]>;\n\n  /**\n   * Returns currently available results synchronously.\n   */\n  runSync(): T[];\n\n  /**\n   * Returns currently available results synchronously along with their match metadata.\n   */\n  runSyncEntries(): Entry<T>[];\n\n  /**\n   * Returns first result.\n   */\n  first(opts?: RunOptions): Promise<T>;\n\n  /**\n   * Returns first result if there is one.\n   */\n  firstOrUndefined(opts?: RunOptions): Promise<T | undefined>;\n\n  /**\n   * Subscribes to changes in query results.\n   */\n  subscribe(callback?: (query: QueryResult<T>) => void, opts?: SubscriptionOptions): CleanupFn;\n\n  /**\n   * Self-updating atom. Updates automatically when query results change.\n   *\n   * Memoized per QueryResult instance — repeated accesses on the same instance return the same\n   * Atom. Safe only when the QueryResult is itself held stable across re-renders (e.g. behind a\n   * `useMemo`). It must NOT be used in graph-builder connectors/actions or other atom computes,\n   * where `db.query(...)` is called fresh on each re-evaluation: every run constructs a new\n   * QueryResult and so a new atom + subscription, leaking the previous ones. Use the memoized\n   * {@link atom} family there instead.\n   */\n  readonly atom: Atom.Atom<T[]>;\n}\n\n/**\n * Effect that returns a QueryResult when evaluated, but also has shorthand methods for running the query or getting the first result.\n */\nexport interface QueryResultEffect<T, E, R> extends Effect.Effect<QueryResult<T>, E, R> {\n  run: Effect.Effect<T[], E, R>;\n  first: Effect.Effect<Option.Option<T>, E, R>;\n\n  // TODO(dmaretskyi): Considering adding `atom`, but since `Database.query` is used in imperative code only, I dont think it will be useful.\n}\n"],
-  "mappings": ";AAAA;",
-  "names": []
-}

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

@@ -1,283 +0,0 @@
-import {
-  Kind,
-  KindId,
-  SnapshotKindId
-} from "./chunk-BEFR7LEA.mjs";
-import {
-  getSchema
-} from "./chunk-XB6ISRAO.mjs";
-import {
-  VersionTypeId,
-  getSnapshot,
-  isDeleted,
-  isVersion,
-  makeRelation,
-  objectToJSON,
-  setValue,
-  sort,
-  sortByLabel,
-  sortByTypename,
-  version
-} from "./chunk-ACFAOTKJ.mjs";
-import {
-  addTag,
-  deleteKeys,
-  getKeys,
-  getMetaChecked,
-  makeObject,
-  removeTag
-} from "./chunk-2HKGAQM4.mjs";
-import {
-  change,
-  subscribe
-} from "./chunk-L3E5IXAE.mjs";
-import {
-  ATTR_RELATION_SOURCE,
-  ATTR_RELATION_TARGET,
-  MetaId,
-  ParentId,
-  RelationSourceDXNId,
-  RelationSourceId,
-  RelationTargetDXNId,
-  RelationTargetId,
-  TypeAnnotationId,
-  getDatabase,
-  getDescription,
-  getLabel,
-  getObjectEchoUri,
-  getType,
-  getTypeAnnotation,
-  getTypeURI,
-  getTypename,
-  getUri,
-  isInstanceOf,
-  setDescription,
-  setLabel
-} from "./chunk-3TN2VMI4.mjs";
-import {
-  ANY_OBJECT_TYPENAME,
-  ANY_OBJECT_VERSION,
-  EntityKind
-} from "./chunk-2ZHECXUR.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Relation.ts
-var Relation_exports = {};
-__export(Relation_exports, {
-  Meta: () => Meta,
-  Source: () => Source,
-  Target: () => Target,
-  Unknown: () => Unknown2,
-  VersionTypeId: () => VersionTypeId2,
-  addTag: () => addTag2,
-  atom: () => atom,
-  deleteKeys: () => deleteKeys2,
-  getDatabase: () => getDatabase2,
-  getDescription: () => getDescription2,
-  getKeys: () => getKeys2,
-  getLabel: () => getLabel2,
-  getMeta: () => getMeta,
-  getSnapshot: () => getSnapshot2,
-  getSource: () => getSource,
-  getSourceURI: () => getSourceURI,
-  getTarget: () => getTarget,
-  getTargetURI: () => getTargetURI,
-  getType: () => getType2,
-  getTypeURI: () => getTypeURI2,
-  getTypename: () => getTypename2,
-  getURI: () => getURI,
-  getValue: () => getValue,
-  instanceOf: () => instanceOf,
-  isDeleted: () => isDeleted2,
-  isRelation: () => isRelation,
-  isSnapshot: () => isSnapshot,
-  isVersion: () => isVersion2,
-  make: () => make,
-  removeTag: () => removeTag2,
-  setDescription: () => setDescription2,
-  setLabel: () => setLabel2,
-  setValue: () => setValue2,
-  sort: () => sort2,
-  sortByLabel: () => sortByLabel2,
-  sortByTypename: () => sortByTypename2,
-  subscribe: () => subscribe2,
-  toJSON: () => toJSON,
-  update: () => update,
-  version: () => version2
-});
-import * as Schema from "effect/Schema";
-import { raise } from "@dxos/debug";
-import { SchemaEx } from "@dxos/effect";
-import { assertArgument, invariant } from "@dxos/invariant";
-import { DXN, EID } from "@dxos/keys";
-import { assumeType } from "@dxos/util";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
-var Unknown2 = Schema.Struct({
-  id: Schema.String
-}).pipe(Schema.extend(Schema.Record({
-  key: Schema.String,
-  value: Schema.Unknown
-})), Schema.annotations({
-  [TypeAnnotationId]: {
-    kind: Kind.Relation,
-    typename: "org.dxos.schema.anyRelation",
-    version: "0.0.0",
-    sourceSchema: DXN.make(ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION),
-    targetSchema: DXN.make(ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION)
-  }
-}));
-var Source = RelationSourceId;
-var Target = RelationTargetId;
-var make = (type, props) => {
-  const schema = getSchema(type);
-  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, "schema", "Expected a relation schema");
-  assertArgument(props[ParentId] === void 0, "props", "Parent is not allowed for relations");
-  let meta = void 0;
-  if (props[MetaId] != null) {
-    meta = props[MetaId];
-    delete props[MetaId];
-  }
-  const sourceDXN = getObjectEchoUri(props[Source]) ?? raise(new Error("Unresolved relation source"));
-  const targetDXN = getObjectEchoUri(props[Target]) ?? raise(new Error("Unresolved relation target"));
-  props[RelationSourceDXNId] = sourceDXN;
-  props[RelationTargetDXNId] = targetDXN;
-  return makeObject(schema, props, meta, type);
-};
-var instanceOf = (...args) => {
-  if (args.length === 1) {
-    return (entity) => isInstanceOf(args[0], entity);
-  }
-  return isInstanceOf(args[0], args[1]);
-};
-var isRelation = (value) => {
-  if (typeof value !== "object" || value === null) {
-    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 isSnapshot = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  return value[SnapshotKindId] === EntityKind.Relation;
-};
-var getSourceURI = (value) => {
-  assertArgument(isRelation(value), "Expected a relation");
-  assumeType(value);
-  const uri = value[RelationSourceDXNId];
-  invariant(EID.isEID(uri), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 121, S: void 0, A: ["EID.isEID(uri)", ""] });
-  return uri;
-};
-var getTargetURI = (value) => {
-  assertArgument(isRelation(value), "Expected a relation");
-  assumeType(value);
-  const uri = value[RelationTargetDXNId];
-  invariant(EID.isEID(uri), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 132, S: void 0, A: ["EID.isEID(uri)", ""] });
-  return uri;
-};
-var getSource = (relation) => {
-  assertArgument(isRelation(relation), "Expected a relation");
-  assumeType(relation);
-  const obj = relation[RelationSourceId];
-  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];
-  if (obj === void 0) {
-    throw new Error(`Relation target could not be resolved.`);
-  }
-  return obj;
-};
-var update = (relation, callback) => {
-  change(relation, callback);
-};
-var getSnapshot2 = getSnapshot;
-var subscribe2 = (rel, callback) => {
-  return subscribe(rel, callback);
-};
-var getValue = (rel, path) => {
-  return SchemaEx.getValue(rel, SchemaEx.createJsonPath(path));
-};
-var setValue2 = setValue;
-var getURI = (entity, options) => getUri(entity, options);
-var getTypeURI2 = getTypeURI;
-var getType2 = (relation) => getType(relation);
-var getTypename2 = (entity) => getTypename(entity);
-var getDatabase2 = (entity) => getDatabase(entity);
-var Meta = MetaId;
-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, options) => getLabel(entity, options);
-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 VersionTypeId2 = VersionTypeId;
-var isVersion2 = isVersion;
-var version2 = (entity) => version(entity);
-var atom = makeRelation;
-
-export {
-  Unknown2 as Unknown,
-  Source,
-  Target,
-  make,
-  instanceOf,
-  isRelation,
-  isSnapshot,
-  getSourceURI,
-  getTargetURI,
-  getSource,
-  getTarget,
-  update,
-  getSnapshot2 as getSnapshot,
-  subscribe2 as subscribe,
-  getValue,
-  setValue2 as setValue,
-  getURI,
-  getTypeURI2 as getTypeURI,
-  getType2 as getType,
-  getTypename2 as getTypename,
-  getDatabase2 as getDatabase,
-  Meta,
-  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,
-  VersionTypeId2 as VersionTypeId,
-  isVersion2 as isVersion,
-  version2 as version,
-  atom,
-  Relation_exports
-};
-//# sourceMappingURL=chunk-UZHCQ6NI.mjs.map

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

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

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

@@ -1,36 +0,0 @@
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Scope.ts
-var Scope_exports = {};
-__export(Scope_exports, {
-  feed: () => feed,
-  registry: () => registry,
-  space: () => space
-});
-var space = (options) => ({
-  _tag: "space",
-  ...options?.id !== void 0 ? {
-    spaceId: options.id
-  } : {},
-  ...options?.includeAllFeeds ? {
-    includeAllFeeds: true
-  } : {}
-});
-var registry = (location = "local") => ({
-  _tag: "registry",
-  location
-});
-var feed = (feedUri) => ({
-  _tag: "feed",
-  feedUri
-});
-
-export {
-  space,
-  registry,
-  feed,
-  Scope_exports
-};
-//# sourceMappingURL=chunk-WISOH2XH.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Scope.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\n/**\n * Scope targeting a space's automerge documents.\n *\n * With no `spaceId`, targets the owning space — i.e. the space of whichever database\n * executes the query — so callers can reference \"this space\" without looking up its id.\n *\n * @example\n * ```ts\n * db.query(Filter.type(Person).from(Scope.space()));            // owning space\n * db.query(Filter.type(Person).from(Scope.space({ id: otherSpaceId }))); // a specific space\n * ```\n */\nexport const space = (options?: { id?: string; includeAllFeeds?: boolean }): QueryAST.SpaceScope => ({\n  _tag: 'space',\n  ...(options?.id !== undefined ? { spaceId: options.id } : {}),\n  ...(options?.includeAllFeeds ? { includeAllFeeds: true } : {}),\n});\n\n/**\n * Scope targeting a code-shipped object/type registry.\n *\n * - `'local'`  — the in-process registry attached to the hypergraph (default).\n * - `'remote'` — a remote registry service (not yet implemented).\n *\n * @example\n * ```ts\n * // Discover all types — persisted in the space and code-shipped in the registry.\n * db.query(Filter.type(Type.Type).from(Scope.space(), Scope.registry()));\n * ```\n */\nexport const registry = (location: 'local' | 'remote' = 'local'): QueryAST.RegistryScope => ({\n  _tag: 'registry',\n  location,\n});\n\n/**\n * Scope targeting a specific feed (by its underlying queue EID).\n */\nexport const feed = (feedUri: string): QueryAST.FeedScope => ({\n  _tag: 'feed',\n  feedUri,\n});\n"],
-  "mappings": ";;;;;AAAA;;;;;;AAoBO,IAAMA,QAAQ,CAACC,aAA+E;EACnGC,MAAM;EACN,GAAID,SAASE,OAAOC,SAAY;IAAEC,SAASJ,QAAQE;EAAG,IAAI,CAAC;EAC3D,GAAIF,SAASK,kBAAkB;IAAEA,iBAAiB;EAAK,IAAI,CAAC;AAC9D;AAcO,IAAMC,WAAW,CAACC,WAA+B,aAAqC;EAC3FN,MAAM;EACNM;AACF;AAKO,IAAMC,OAAO,CAACC,aAAyC;EAC5DR,MAAM;EACNQ;AACF;",
-  "names": ["space", "options", "_tag", "id", "undefined", "spaceId", "includeAllFeeds", "registry", "location", "feed", "feedUri"]
-}

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

@@ -1,34 +0,0 @@
-import {
-  Ref
-} from "./chunk-L3E5IXAE.mjs";
-
-// src/internal/Ref/ref-array.ts
-import { isNonNullable } from "@dxos/util";
-var RefArray = Object.freeze({
-  /**
-  * @returns all resolved targets.
-  */
-  targets: (refs) => {
-    return refs.map((ref) => ref.target).filter(isNonNullable);
-  },
-  /**
-  * Load all referenced objects.
-  */
-  loadAll: (refs) => {
-    return Promise.all(refs.map((ref) => ref.load()));
-  },
-  /**
-  * Removes the ref with the given id.
-  */
-  removeById: (refs, id) => {
-    const index = refs.findIndex(Ref.hasEntityId(id));
-    if (index >= 0) {
-      refs.splice(index, 1);
-    }
-  }
-});
-
-export {
-  RefArray
-};
-//# sourceMappingURL=chunk-WKIT2YY5.mjs.map

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

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