@dxos/echo 0.10.0 → 0.11.1

package/dist/lib/Ref.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Ref.mjs","names":[],"sources":["../../src/Ref.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport type * as internal from './internal';\nimport * as refInternal from './internal/Ref';\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Obj from './Obj';\nimport type * as Relation from './Relation';\n// eslint-disable-next-line @dxos/rules/import-as-namespace\nimport type * as Type$ from './Type';\n\n/**\n * Instance type for a reference.\n *\n * Reference can point to any object or relation.\n * References are lazy loaded.\n *\n * `ref.dxn` is the DXN of the referenced object.\n *\n * @example\n * ```ts\n * const taskRef: Ref<Task> = Ref.make(task);\n *\n * await taskRef.load(); // Returns Promise<Task>\n * yield* Database.load(taskRef); // Effectful version.\n *\n * database.makeRef(dxn); // Create a ref from a DXN.\n * ```\n */\nexport type Ref<T> = refInternal.Ref<T>;\nexport type Unknown = refInternal.Ref<Obj.Unknown>;\n\n/**\n * Factory function to create a Ref schema for the given target schema.\n * Use this in schema definitions to declare reference fields.\n *\n * @example\n * ```ts\n * class Task extends Type.makeObject<Task>(DXN.make('com.example.type.task', '0.1.0'))(\n *   Schema.Struct({\n *     assignee: Ref.Ref(Person),  // Creates a Ref schema\n *   }),\n * ) {}\n * ```\n */\nexport const Ref: {\n  <S extends Type$.AnyObj>(type: S): RefSchema<Type$.InstanceType<S> & Obj.Unknown>;\n\n  // Relations are entities too and can be referenced. The instance type already\n  // carries the relation kind brand, so intersect with `Relation.Unknown` (not\n  // `Obj.Unknown`, whose object kind brand conflicts and collapses to `never`).\n  <S extends Type$.AnyRelation>(type: S): RefSchema<Type$.InstanceType<S> & Relation.Unknown>;\n\n  // `Type.Type` entities (the meta-schema kind) can be referenced too — e.g. a\n  // trigger that points to a stored function/workflow definition.\n  <T extends Type$.Type<any>>(type: T): RefSchema<Type$.InstanceType<T>>;\n\n  // Schema-side overload for the well-known \"any object\" / \"any relation\" schemas.\n  // Other raw `Schema.Schema` values are intentionally rejected — callers should\n  // pass a `Type.Type` entity instead.\n  <S extends internal.UnknownTypeSchema<any, any>>(schema: S): RefSchema<Schema.Schema.Type<S> & Obj.Unknown>;\n} = refInternal.Ref as any;\n\nexport const Array = refInternal.RefArray;\n\n/**\n * TypeScript type for a Ref schema.\n * This is the type of the SCHEMA itself, not the runtime ref instance.\n * For the instance type, use `Ref.Ref<T>` from the Ref module.\n *\n * @example\n * ```ts\n * // Schema type annotation (rarely needed, usually inferred):\n * const refSchema: Ref.RefSchema<typeof Task> = Ref.Ref(Task);\n *\n * // Instance type annotation (use Ref.Ref instead):\n * const refInstance: Ref.Ref<Task> = Ref.make(task);\n * ```\n */\n// TODO(dmaretskyi): Investigate if we can remove this type.\n//                   Post DX-836 it will become just `Schema.Schema<Ref.Ref<T>>`.\n//                   NOTE: This could be Type.Ref<T> instead, but since it going to be removed, it's better to keep it here, self-contained.\nexport interface RefSchema<T extends Entity.Unknown> extends refInternal.RefSchema<T> {}\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Unknown> = R extends refInternal.Ref<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = refInternal.RefResolver;\n\nexport const isRef: (value: unknown) => value is Unknown = refInternal.Ref.isRef;\n\nexport const make = refInternal.Ref.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept URI.\nexport const fromURI = (uri: URI.URI): refInternal.Ref<any> => refInternal.Ref.fromURI(uri);\n\nexport const hasEntityId = refInternal.Ref.hasEntityId;\n\n// TODO(wittjosiah): Factor out?\nexport const isRefType = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation<JsonSchema.JsonSchema>(ast, SchemaAST.JSONSchemaAnnotationId).pipe(\n    Option.flatMap((jsonSchema) => ('$id' in jsonSchema ? Option.some(jsonSchema) : Option.none())),\n    Option.flatMap((jsonSchema) => {\n      const { typename } = refInternal.getSchemaReference(jsonSchema) ?? {};\n      return typename ? Option.some(true) : Option.some(false);\n    }),\n    Option.getOrElse(() => false),\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,IAAa,MAgBT;AAEJ,IAAa,QAAQ;AA+BrB,IAAa,QAAA,MAA8D;AAE3E,IAAa,OAAA,MAAuB;AAGpC,IAAa,WAAW,QAAA,MAAuD,QAAQ,GAAG;AAE1F,IAAa,cAAA,MAA8B;AAG3C,IAAa,aAAa,QAAgC;CACxD,OAAO,UAAU,cAAqC,KAAK,UAAU,sBAAsB,CAAC,CAAC,KAC3F,OAAO,SAAS,eAAgB,SAAS,aAAa,OAAO,KAAK,UAAU,IAAI,OAAO,KAAK,CAAE,GAC9F,OAAO,SAAS,eAAe;EAC7B,MAAM,EAAE,aAAa,mBAA+B,UAAU,KAAK,CAAC;EACpE,OAAO,WAAW,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK;CACzD,CAAC,GACD,OAAO,gBAAgB,KAAK,CAC9B;AACF"}

package/dist/lib/Registry.mjs

@@ -0,0 +1,35 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import * as Effect from "effect/Effect";
+import * as Context from "effect/Context";
+//#region src/Registry.ts
+var Registry_exports = /* @__PURE__ */ __exportAll({
+	Service: () => Service,
+	TypeId: () => TypeId,
+	isRegistry: () => isRegistry,
+	runQuery: () => runQuery
+});
+/**
+* Identifier denoting an ECHO Registry.
+*/
+var TypeId = Symbol.for("@dxos/echo/Registry");
+/**
+* Type guard for {@link Registry}.
+*/
+var isRegistry = (obj) => obj != null && typeof obj === "object" && TypeId in obj && obj[TypeId] === TypeId;
+/**
+* Effect Context tag for {@link Registry}.
+* Use this to inject a registry into Effect-based code.
+*/
+var Service = class extends Context.Tag("@dxos/echo/Registry/Service")() {};
+/**
+* Executes a query against the registry and returns the results.
+* Analogous to {@link Database.query} `.run` for the in-process registry.
+*/
+var runQuery = (queryOrFilter) => Effect.gen(function* () {
+	const registry = yield* Service;
+	return yield* Effect.promise(() => registry.query(queryOrFilter).run());
+});
+//#endregion
+export { Service, TypeId, isRegistry, runQuery, Registry_exports as t };
+
+//# sourceMappingURL=Registry.mjs.map

package/dist/lib/Registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.mjs","names":[],"sources":["../../src/Registry.ts"],"sourcesContent":["// Copyright 2026 DXOS.org\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\n\nimport { type ReadOnlyEvent } from '@dxos/async';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport type * as Filter from './Filter';\nimport type * as Query from './Query';\n\n/**\n * Identifier denoting an ECHO Registry.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Registry');\nexport type TypeId = typeof TypeId;\n\n/**\n * Composable, in-memory registry of keyed ECHO entities.\n *\n * Entities are stored by id and queried via the standard ECHO Query API.\n * A registry may delegate to an optional upstream registry: results from the local\n * registry take precedence and upstream results fill in anything not found locally.\n *\n * Intended use cases include caches of schemas, operations, skills, routines, plugins,\n * etc., sourced from 3rd-party plugins, local code, or local space objects.\n *\n * Types (schema-definition entities produced by `Type.makeObject` / `Type.makeRelation`) are\n * stored the same way as any other entity — via `add()`. Use `list().filter(Type.isType)` to\n * retrieve them.\n *\n * Scope: a Registry is independent of any ECHO space or Hypergraph — it is a process-local,\n * in-memory cache. Wire one per space (e.g. as a Layer scoped to the space's Effect runtime)\n * or share a single instance across spaces depending on the use case.\n *\n * The concrete implementation (and the `makeRegistry` / `registryLayer` factories) lives in\n * `@dxos/echo-client`; this module declares only the interface so that the `@dxos/echo` API surface\n * stays free of query-matching dependencies.\n */\nexport interface Registry {\n  readonly [TypeId]: TypeId;\n\n  /**\n   * Stable per-instance identifier. Used to key process-local resources (e.g. memoized\n   * reactive atoms) to a specific registry instance, analogous to {@link Database.spaceId}.\n   */\n  readonly id: string;\n\n  /**\n   * Fires whenever local registry contents change (add, remove, or clear).\n   */\n  readonly changed: ReadOnlyEvent<void>;\n\n  /**\n   * All locally-stored entities.\n   * Does not include upstream entities — use {@link list} for that.\n   */\n  readonly local: readonly Entity.Unknown[];\n\n  /**\n   * Add or replace one or more entities in the local registry.\n   * Existing entries with the same id are replaced.\n   * Also indexes type entities by DXN for fast lookup.\n   */\n  add(entities: readonly Entity.Unknown[]): void;\n\n  /**\n   * Remove an entity by id from the local registry.\n   * @returns true if an entity was removed, false if it was not found.\n   */\n  remove(id: string): boolean;\n\n  /**\n   * Remove all locally-stored entities.\n   * Does not affect the upstream registry.\n   */\n  clear(): void;\n\n  /**\n   * Get an entity by id.\n   * Searches the local registry first, then falls back to the upstream registry.\n   */\n  get(id: string): Entity.Unknown | undefined;\n\n  /**\n   * Get an entity by one of its addressing URIs — a type entity by its typename DXN (or, when\n   * persisted, its identifier EID), a keyed entity by its `dxn:<key>[:<version>]`. Accepts legacy\n   * DXN forms (normalized internally). Searches the local registry first, then falls back to the\n   * upstream registry. Narrow the result with `Type.isType` when a type entity is required.\n   */\n  getByURI(uri: string): Entity.Unknown | undefined;\n\n  /**\n   * List all entities.\n   * Local entities take precedence over upstream entities with the same id.\n   */\n  list(): Entity.Unknown[];\n\n  /**\n   * Run an ECHO query against the registry's entities (implements {@link Database.Queryable}).\n   *\n   * Matching happens in-memory over {@link list}. Scope (`from`) clauses are unwrapped and\n   * ignored — a direct registry query always targets the registry's own entities. The primary\n   * way to query registry contents is still through the database (`db.query(...).from(Scope.registry())`),\n   * which fans the database and registry together; this method is for querying a registry directly.\n   *\n   * Only locally-evaluable AST nodes are supported: `select`, `filter`, `limit`, `from`, `options`,\n   * and boolean combinators. Server-side concerns (order, traversal, text/timestamp filters) throw.\n   */\n  query: Database.QueryFn;\n}\n\n/**\n * Type guard for {@link Registry}.\n */\nexport const isRegistry = (obj: unknown): obj is Registry =>\n  obj != null && typeof obj === 'object' && TypeId in obj && (obj as { [TypeId]?: unknown })[TypeId] === TypeId;\n\n/**\n * Options for the registry factory (`makeRegistry` in `@dxos/echo-client`).\n */\nexport type Options = {\n  /**\n   * Optional upstream registry. Queries fall back to upstream when an entity\n   * is not present in the local registry.\n   */\n  upstream?: Registry;\n\n  /**\n   * Initial set of entities to seed the local registry with.\n   */\n  initial?: readonly Entity.Unknown[];\n};\n\n/**\n * Effect Context tag for {@link Registry}.\n * Use this to inject a registry into Effect-based code.\n */\nexport class Service extends Context.Tag('@dxos/echo/Registry/Service')<Service, Registry>() {}\n\n/**\n * Executes a query against the registry and returns the results.\n * Analogous to {@link Database.query} `.run` for the in-process registry.\n */\nexport const runQuery: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  Effect.gen(function* () {\n    const registry = yield* Service;\n    return (yield* Effect.promise(() => registry.query(queryOrFilter as any).run())) as any;\n  });\n"],"mappings":";;;;;;;;;;;;;AAiBA,IAAa,SAAS,OAAO,IAAI,qBAAqB;;;;AAqGtD,IAAa,cAAc,QACzB,OAAO,QAAQ,OAAO,QAAQ,YAAY,UAAU,OAAQ,IAA+B,YAAY;;;;;AAsBzG,IAAa,UAAb,cAA6B,QAAQ,IAAI,6BAA6B,CAAC,CAAoB,CAAC,CAAC,CAAC;;;;;AAM9F,IAAa,YAGR,kBACH,OAAO,IAAI,aAAa;CACtB,MAAM,WAAW,OAAO;CACxB,OAAQ,OAAO,OAAO,cAAc,SAAS,MAAM,aAAoB,CAAC,CAAC,IAAI,CAAC;AAChF,CAAC"}

package/dist/lib/Relation.mjs

@@ -0,0 +1,397 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { c as getKeys$1, l as getMetaChecked, o as addTag$1, s as deleteKeys$1, u as removeTag$1 } from "./chunk-atom-snapshot.mjs";
+import { A as isVersion$1, Ct as sortByLabel$1, St as sort$1, T as objectToJSON, Tt as VersionTypeId$1, U as makeObject, d as makeRelation, h as isDeleted$1, j as version$1, m as setValue$1, p as getSnapshot$1, wt as sortByTypename$1 } from "./chunk-internal.mjs";
+import { a as ANY_OBJECT_VERSION, i as ANY_OBJECT_TYPENAME, o as EntityKind } from "./chunk-util.mjs";
+import { $t as RelationTargetId, Ct as getTypename$1, Dt as setLabel$1, E as getObjectEchoUri, Gt as MetaId, Lt as getType$1, Mt as ParentId, Qt as RelationTargetDXNId, S as isInstanceOf, St as getTypeURI$1, T as getUri, Tt as setDescription$1, Xt as RelationSourceDXNId, Zt as RelationSourceId, bt as getTypeAnnotation, ct as getDescription$1, pt as getLabel$1, rt as TypeAnnotationId, w as getDatabase$1 } from "./chunk-Database.mjs";
+import { g as subscribe$1, h as change } from "./chunk-ref.mjs";
+import { getSchema } from "./Type.mjs";
+import { Kind, KindId, SnapshotKindId } from "./Entity.mjs";
+import { isObject } from "./Obj.mjs";
+import { DXN, EID } from "@dxos/keys";
+import * as Schema from "effect/Schema";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { SchemaEx } from "@dxos/effect";
+import { assumeType } from "@dxos/util";
+import { raise } from "@dxos/debug";
+//#region src/Relation.ts
+var Relation_exports = /* @__PURE__ */ __exportAll({
+	Meta: () => Meta,
+	Source: () => Source,
+	Target: () => Target,
+	Unknown: () => Unknown,
+	VersionTypeId: () => VersionTypeId,
+	addTag: () => addTag,
+	atom: () => atom,
+	deleteKeys: () => deleteKeys,
+	getDatabase: () => getDatabase,
+	getDescription: () => getDescription,
+	getKeys: () => getKeys,
+	getLabel: () => getLabel,
+	getMeta: () => getMeta,
+	getSnapshot: () => getSnapshot,
+	getSource: () => getSource,
+	getSourceURI: () => getSourceURI,
+	getTarget: () => getTarget,
+	getTargetURI: () => getTargetURI,
+	getType: () => getType,
+	getTypeURI: () => getTypeURI,
+	getTypename: () => getTypename,
+	getURI: () => getURI,
+	getValue: () => getValue,
+	instanceOf: () => instanceOf,
+	isDeleted: () => isDeleted,
+	isRelation: () => isRelation,
+	isSnapshot: () => isSnapshot,
+	isVersion: () => isVersion,
+	make: () => make,
+	removeTag: () => removeTag,
+	setDescription: () => setDescription,
+	setLabel: () => setLabel,
+	setParent: () => setParent,
+	setValue: () => setValue,
+	sort: () => sort,
+	sortByLabel: () => sortByLabel,
+	sortByTypename: () => sortByTypename,
+	subscribe: () => subscribe,
+	toJSON: () => toJSON,
+	update: () => update,
+	version: () => version
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Relation.ts";
+/**
+* Runtime Effect schema for any ECHO relation.
+* Use for validation, parsing, or as a reference target for collections.
+* A relation has `id`, source, and target fields plus any additional properties.
+*
+* NOTE: `Schema.is(Type.Relation)` does STRUCTURAL validation only (checks for `id` field).
+* Use `Relation.isRelation()` for proper ECHO instance type guards that check the KindId brand.
+*
+* @example
+* ```ts
+* // Structural type guard (accepts any object with id field)
+* if (Schema.is(Type.Relation)(unknownValue)) { ... }
+*
+* // ECHO instance type guard (checks KindId brand)
+* if (Relation.isRelation(unknownValue)) { ... }
+* ```
+*/
+var Unknown = 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;
+/**
+* Creates new relation.
+* @param schema - Relation schema.
+* @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.
+* @param meta - Relation metadata. (deprecated; use [Obj.Meta] instead)
+* @returns
+*/
+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(/* @__PURE__ */ new Error("Unresolved relation source"));
+	const targetDXN = getObjectEchoUri(props[Target]) ?? raise(/* @__PURE__ */ new Error("Unresolved relation target"));
+	props[RelationSourceDXNId] = sourceDXN;
+	props[RelationTargetDXNId] = targetDXN;
+	return makeObject(schema, props, meta, type);
+};
+/**
+* Test if a value is an instance of a given relation type.
+*
+* Mirrors `Obj.instanceOf` but only accepts `Type.AnyRelation` — use
+* `Obj.instanceOf` for objects and `Type.isType` for `Type.Type` entities.
+*
+* @example
+* ```ts
+* const isEmployedBy = Relation.instanceOf(EmployedBy);
+* if (isEmployedBy(relation)) {
+*   // relation is EmployedBy
+* }
+* ```
+*/
+var instanceOf = ((...args) => {
+	if (args.length === 1) return (entity) => isInstanceOf(args[0], entity);
+	return isInstanceOf(args[0], args[1]);
+});
+/**
+* Type guard for relations.
+* Returns true for both reactive relations and relation snapshots.
+*/
+var isRelation = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	if ("@relationSource" in value || "@relationTarget" in value) return true;
+	return (value[KindId] ?? value[SnapshotKindId]) === EntityKind.Relation;
+};
+var isSnapshot = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	return value[SnapshotKindId] === EntityKind.Relation;
+};
+/**
+* Sets a relation as the parent of an object: the object cascade-deletes with the relation and is
+* persisted transitively when the relation is added. The delete-cascade resolves the parent by id
+* regardless of kind. The object-parent counterpart is {@link Obj.setParent}.
+*/
+var setParent = (entity, parent) => {
+	assertArgument(isObject(entity), "Expected an object");
+	assertArgument(isRelation(parent), "Expected a relation");
+	assumeType(entity);
+	assumeType(parent);
+	entity[ParentId] = parent;
+	return entity;
+};
+/**
+* @returns Relation source URI.
+* Accepts both reactive relations and snapshots.
+* @throws If the object is not a 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: 256,
+		S: void 0,
+		A: ["EID.isEID(uri)", ""]
+	});
+	return uri;
+};
+/**
+* @returns Relation target URI.
+* Accepts both reactive relations and snapshots.
+* @throws If the object is not a relation.
+*/
+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: 269,
+		S: void 0,
+		A: ["EID.isEID(uri)", ""]
+	});
+	return uri;
+};
+/**
+* @returns Relation source.
+* Accepts both reactive relations and snapshots.
+* @throws If the object is not a relation.
+*/
+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;
+};
+/**
+* @returns Relation target.
+* Accepts both reactive relations and snapshots.
+* @throws If the object is not a relation.
+*/
+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;
+};
+/**
+* Perform mutations on an echo relation within a controlled context.
+*
+* All mutations within the callback are batched and trigger a single notification
+* when the callback completes. Direct mutations outside of `Relation.update` will throw
+* an error for echo relations.
+*
+* @param relation - The echo relation to mutate. Use `Obj.update` for objects.
+* @param callback - The callback that performs mutations on the relation.
+*
+* @example
+* ```ts
+* const worksFor = Relation.make(EmployedBy, {
+*   [Relation.Source]: person,
+*   [Relation.Target]: company,
+*   role: 'Engineer',
+* });
+*
+* // Mutate within Relation.update
+* Relation.update(worksFor, (obj) => {
+*   obj.role = 'Senior Engineer';
+* });
+* ```
+*
+* Note: Only accepts relations. Use `Obj.update` for objects.
+*/
+var update = (relation, callback) => {
+	change(relation, callback);
+};
+/**
+* Returns an immutable snapshot of a relation.
+* The snapshot is branded with SnapshotKindId instead of KindId,
+* making it distinguishable from the reactive relation at the type level.
+*/
+var getSnapshot = getSnapshot$1;
+/**
+* Subscribe to relation updates.
+* The callback is called synchronously when the relation is modified.
+* Only accepts reactive relations (not snapshots).
+* @returns Unsubscribe function.
+*/
+var subscribe = (rel, callback) => {
+	return subscribe$1(rel, callback);
+};
+/**
+* Get a deeply nested property from a relation.
+* Accepts both reactive relations and snapshots.
+*/
+var getValue = (rel, path) => {
+	return SchemaEx.getValue(rel, SchemaEx.createJsonPath(path));
+};
+/**
+* Set a deeply nested property on a relation.
+* Must be called within a `Relation.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var setValue = setValue$1;
+/**
+* Get the canonical URI of the relation. Returns `URI.URI` — today always an EID,
+* but future entity kinds may surface other URI schemes; narrow with `EID.parse(uri)`
+* or `DXN.tryMake(uri)` at the point of use. Accepts both reactive relations and snapshots.
+*
+* @param options.prefer - Controls the URI form (see {@link internal.GetURIOptions}).
+*/
+var getURI = (entity, options) => getUri(entity, options);
+/**
+* @returns The DXN of the relation's type.
+*/
+var getTypeURI = getTypeURI$1;
+/**
+* Get the type entity (`Type.AnyRelation`) the relation was created from.
+*
+* Returns `undefined` when the relation's type isn't registered in this
+* runtime (e.g. a freshly deserialized snapshot whose type entity hasn't been
+* wired up yet, or a relation loaded from storage before its schema is known).
+* To get the Effect Schema from the returned entity, use `Type.getSchema(...)`.
+*/
+var getType = (relation) => getType$1(relation);
+/**
+* @returns The typename of the relation's type.
+* Accepts both reactive relations and snapshots.
+*/
+var getTypename = (entity) => getTypename$1(entity);
+/**
+* Get the database the relation belongs to.
+* Accepts both reactive relations and snapshots.
+*/
+var getDatabase = (entity) => getDatabase$1(entity);
+/**
+* Property that accesses metadata for an entity.
+*
+* Alias for `Entity.Meta`.
+*/
+var Meta = MetaId;
+function getMeta(entity) {
+	return getMetaChecked(entity);
+}
+/**
+* @returns Foreign keys for the relation from the specified source.
+* Accepts both reactive relations and snapshots.
+*/
+var getKeys = (entity, source) => getKeys$1(entity, source);
+/**
+* Delete all keys from the relation for the specified source.
+* Must be called within a `Relation.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var deleteKeys = (entity, source) => deleteKeys$1(entity, source);
+/**
+* Add a tag to the relation.
+* Must be called within a `Relation.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var addTag = (entity, tag) => addTag$1(entity, tag);
+/**
+* Remove a tag from the relation.
+* Must be called within a `Relation.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var removeTag = (entity, tag) => removeTag$1(entity, tag);
+/**
+* Check if the relation is deleted.
+* Accepts both reactive relations and snapshots.
+*/
+var isDeleted = (entity) => isDeleted$1(entity);
+/**
+* Get the label of the relation.
+* Accepts both reactive relations and snapshots.
+*
+* @param options.fallback `'typename'` returns the relation's typename when no
+*   label is set (e.g. `org.dxos.type.table`).
+*/
+var getLabel = (entity, options) => getLabel$1(entity, options);
+/**
+* Set the label of the relation.
+* Must be called within a `Relation.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var setLabel = (entity, label) => setLabel$1(entity, label);
+/**
+* Get the description of the relation.
+* Accepts both reactive relations and snapshots.
+*/
+var getDescription = (entity) => getDescription$1(entity);
+/**
+* Set the description of the relation.
+* Must be called within a `Relation.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var setDescription = (entity, description) => setDescription$1(entity, description);
+/**
+* Converts relation to its JSON representation.
+* Accepts both reactive relations and snapshots.
+*/
+var toJSON = (entity) => objectToJSON(entity);
+var sortByLabel = sortByLabel$1;
+var sortByTypename = sortByTypename$1;
+var sort = (...comparators) => sort$1(...comparators);
+var VersionTypeId = VersionTypeId$1;
+var isVersion = isVersion$1;
+/**
+* Returns the version of the relation.
+* Accepts both reactive relations and snapshots.
+*/
+var version = (entity) => version$1(entity);
+var atom = makeRelation;
+//#endregion
+export { Meta, Source, Target, Unknown, VersionTypeId, addTag, atom, deleteKeys, getDatabase, getDescription, getKeys, getLabel, getMeta, getSnapshot, getSource, getSourceURI, getTarget, getTargetURI, getType, getTypeURI, getTypename, getURI, getValue, instanceOf, isDeleted, isRelation, isSnapshot, isVersion, make, removeTag, setDescription, setLabel, setParent, setValue, sort, sortByLabel, sortByTypename, subscribe, Relation_exports as t, toJSON, update, version };
+
+//# sourceMappingURL=Relation.mjs.map

package/dist/lib/Relation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Relation.mjs","names":[],"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 * Sets a relation as the parent of an object: the object cascade-deletes with the relation and is\n * persisted transitively when the relation is added. The delete-cascade resolves the parent by id\n * regardless of kind. The object-parent counterpart is {@link Obj.setParent}.\n */\nexport const setParent = (entity: Obj.Unknown, parent: Unknown): Obj.Unknown => {\n  assertArgument(Obj.isObject(entity), 'Expected an object');\n  assertArgument(isRelation(parent), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(entity);\n  assumeType<internal.InternalObjectProps>(parent);\n  entity[internal.ParentId] = parent;\n  return entity;\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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"}

package/dist/lib/Scope.mjs

@@ -0,0 +1,51 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+//#region src/Scope.ts
+var Scope_exports = /* @__PURE__ */ __exportAll({
+	feed: () => feed,
+	registry: () => registry,
+	space: () => space
+});
+/**
+* Scope targeting a space's automerge documents.
+*
+* With no `spaceId`, targets the owning space — i.e. the space of whichever database
+* executes the query — so callers can reference "this space" without looking up its id.
+*
+* @example
+* ```ts
+* db.query(Filter.type(Person).from(Scope.space()));            // owning space
+* db.query(Filter.type(Person).from(Scope.space({ id: otherSpaceId }))); // a specific space
+* ```
+*/
+var space = (options) => ({
+	_tag: "space",
+	...options?.id !== void 0 ? { spaceId: options.id } : {},
+	...options?.includeAllFeeds ? { includeAllFeeds: true } : {}
+});
+/**
+* Scope targeting a code-shipped object/type registry.
+*
+* - `'local'`  — the in-process registry attached to the hypergraph (default).
+* - `'remote'` — a remote registry service (not yet implemented).
+*
+* @example
+* ```ts
+* // Discover all types — persisted in the space and code-shipped in the registry.
+* db.query(Filter.type(Type.Type).from(Scope.space(), Scope.registry()));
+* ```
+*/
+var registry = (location = "local") => ({
+	_tag: "registry",
+	location
+});
+/**
+* Scope targeting a specific feed (by its underlying queue EID).
+*/
+var feed = (feedUri) => ({
+	_tag: "feed",
+	feedUri
+});
+//#endregion
+export { feed, registry, space, Scope_exports as t };
+
+//# sourceMappingURL=Scope.mjs.map

package/dist/lib/Scope.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scope.mjs","names":[],"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":";;;;;;;;;;;;;;;;;;;AAoBA,IAAa,SAAS,aAA+E;CACnG,MAAM;CACN,GAAI,SAAS,OAAO,KAAA,IAAY,EAAE,SAAS,QAAQ,GAAG,IAAI,CAAC;CAC3D,GAAI,SAAS,kBAAkB,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAC9D;;;;;;;;;;;;;AAcA,IAAa,YAAY,WAA+B,aAAqC;CAC3F,MAAM;CACN;AACF;;;;AAKA,IAAa,QAAQ,aAAyC;CAC5D,MAAM;CACN;AACF"}

package/dist/lib/Tag.mjs

@@ -0,0 +1,70 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { _ as TagTypeDXN } from "./chunk-atom-snapshot.mjs";
+import { G as HiddenAnnotation, Y as LabelAnnotation } from "./chunk-Database.mjs";
+import { makeObject } from "./Type.mjs";
+import { Meta, getMeta, make as make$1, update } from "./Obj.mjs";
+import { foreignKeys, type } from "./Filter.mjs";
+import * as Schema from "effect/Schema";
+//#region src/Tag.ts
+var Tag_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	createTagList: () => createTagList,
+	findOrCreate: () => findOrCreate,
+	findTagByLabel: () => findTagByLabel,
+	make: () => make,
+	sortTags: () => sortTags
+});
+var Tag = class extends makeObject(TagTypeDXN)(Schema.Struct({
+	label: Schema.String,
+	hue: Schema.optional(Schema.String)
+}).pipe(LabelAnnotation.set(["label"]), HiddenAnnotation.set(true))) {};
+var make = (props) => make$1(Tag, props);
+var sortTags = ({ label: a }, { label: b }) => a.localeCompare(b);
+var createTagList = (tags) => Object.entries(tags).map(([id, tag]) => ({
+	...tag,
+	id
+})).sort(sortTags);
+var findTagByLabel = (tags, name) => {
+	const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());
+	return entry ? {
+		...entry[1],
+		id: entry[0]
+	} : void 0;
+};
+/**
+* Finds or creates a {@link Tag} object in the database.
+*
+* - With a foreign `key` (system/provider tags): matched by that key; the label is kept current on
+*   re-sync. Use a stable key (e.g. `{ source: 'google.com/gmail/label', id }`) for tags whose
+*   identity is external or well-known.
+* - Without a key (user tags): matched by case-insensitive label among tags that carry **no**
+*   foreign key, so it never collides with a keyed system/provider tag of the same label.
+*/
+var findOrCreate = async (db, options) => {
+	const { label, hue, key } = options;
+	const withHue = hue ? { hue } : {};
+	if (key) {
+		const [existing] = await db.query(foreignKeys(Tag, [key])).run();
+		if (existing) {
+			if (existing.label !== label || hue !== void 0 && existing.hue !== hue) update(existing, (existing) => {
+				existing.label = label;
+				if (hue !== void 0) existing.hue = hue;
+			});
+			return existing;
+		}
+		return db.add(make$1(Tag, {
+			[Meta]: { keys: [key] },
+			label,
+			...withHue
+		}));
+	}
+	const lowered = label.toLowerCase();
+	return (await db.query(type(Tag)).run()).find((tag) => tag.label.toLowerCase() === lowered && (getMeta(tag).keys ?? []).length === 0) ?? db.add(make({
+		label,
+		...withHue
+	}));
+};
+//#endregion
+export { Tag, createTagList, findOrCreate, findTagByLabel, make, sortTags, Tag_exports as t };
+
+//# sourceMappingURL=Tag.mjs.map

package/dist/lib/Tag.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tag.mjs","names":[],"sources":["../../src/Tag.ts"],"sourcesContent":["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\n\nimport type * as Database from './Database';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\nexport class Tag extends Type.makeObject<Tag>(internal.TagTypeDXN)(\n  Schema.Struct({\n    label: Schema.String,\n    hue: Schema.optional(Schema.String), // TODO(burdon): Color name?\n  }).pipe(internal.LabelAnnotation.set(['label']), internal.HiddenAnnotation.set(true)),\n) {}\n\nexport const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);\n\nexport type Map = Record<string, Type.InstanceType<typeof Tag>>;\n\nexport const sortTags = ({ label: a }: Type.InstanceType<typeof Tag>, { label: b }: Type.InstanceType<typeof Tag>) =>\n  a.localeCompare(b);\n\nexport const createTagList = (tags: Map): Type.InstanceType<typeof Tag>[] =>\n  Object.entries(tags)\n    .map(([id, tag]) => ({ ...tag, id }))\n    .sort(sortTags);\n\nexport const findTagByLabel = (tags: Map | undefined, name: string): Type.InstanceType<typeof Tag> | undefined => {\n  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());\n  return entry ? { ...entry[1], id: entry[0] } : undefined;\n};\n\n/**\n * Finds or creates a {@link Tag} object in the database.\n *\n * - With a foreign `key` (system/provider tags): matched by that key; the label is kept current on\n *   re-sync. Use a stable key (e.g. `{ source: 'google.com/gmail/label', id }`) for tags whose\n *   identity is external or well-known.\n * - Without a key (user tags): matched by case-insensitive label among tags that carry **no**\n *   foreign key, so it never collides with a keyed system/provider tag of the same label.\n */\nexport const findOrCreate = async (\n  db: Pick<Database.Database, 'query' | 'add'>,\n  options: { label: string; hue?: string; key?: ForeignKey },\n): Promise<Type.InstanceType<typeof Tag>> => {\n  const { label, hue, key } = options;\n  const withHue = hue ? { hue } : {};\n  if (key) {\n    const [existing] = await db.query(Filter.foreignKeys(Tag, [key])).run();\n    if (existing) {\n      // Keep label (and hue, when provided) current on re-sync. `hue` is only touched when supplied,\n      // so a label-only re-sync (e.g. Gmail) doesn't wipe a user-set colour.\n      if (existing.label !== label || (hue !== undefined && existing.hue !== hue)) {\n        Obj.update(existing, (existing) => {\n          existing.label = label;\n          if (hue !== undefined) {\n            existing.hue = hue;\n          }\n        });\n      }\n      return existing;\n    }\n\n    return db.add(Obj.make(Tag, { [Obj.Meta]: { keys: [key] }, label, ...withHue }));\n  }\n\n  const lowered = label.toLowerCase();\n  const candidates = await db.query(Filter.type(Tag)).run();\n  const existing = candidates.find(\n    (tag) => tag.label.toLowerCase() === lowered && (Obj.getMeta(tag).keys ?? []).length === 0,\n  );\n  return existing ?? db.add(make({ label, ...withHue }));\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,IAAa,MAAb,cAAyB,WAAqB,UAAmB,CAAC,CAChE,OAAO,OAAO;CACZ,OAAO,OAAO;CACd,KAAK,OAAO,SAAS,OAAO,MAAM;AACpC,CAAC,CAAC,CAAC,KAAA,gBAA8B,IAAI,CAAC,OAAO,CAAC,GAAA,iBAA6B,IAAI,IAAI,CAAC,CACtF,CAAC,CAAC,CAAC;AAEH,IAAa,QAAQ,UAAqC,OAAS,KAAK,KAAK;AAI7E,IAAa,YAAY,EAAE,OAAO,KAAoC,EAAE,OAAO,QAC7E,EAAE,cAAc,CAAC;AAEnB,IAAa,iBAAiB,SAC5B,OAAO,QAAQ,IAAI,CAAA,CAChB,KAAK,CAAC,IAAI,UAAU;CAAE,GAAG;CAAK;AAAG,EAAE,CAAA,CACnC,KAAK,QAAQ;AAElB,IAAa,kBAAkB,MAAuB,SAA4D;CAChH,MAAM,QAAQ,OAAO,QAAQ,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,IAAI,MAAM,YAAY,MAAM,KAAK,YAAY,CAAC;CAC1G,OAAO,QAAQ;EAAE,GAAG,MAAM;EAAI,IAAI,MAAM;CAAG,IAAI,KAAA;AACjD;;;;;;;;;;AAWA,IAAa,eAAe,OAC1B,IACA,YAC2C;CAC3C,MAAM,EAAE,OAAO,KAAK,QAAQ;CAC5B,MAAM,UAAU,MAAM,EAAE,IAAI,IAAI,CAAC;CACjC,IAAI,KAAK;EACP,MAAM,CAAC,YAAY,MAAM,GAAG,MAAM,YAAmB,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI;EACtE,IAAI,UAAU;GAGZ,IAAI,SAAS,UAAU,SAAU,QAAQ,KAAA,KAAa,SAAS,QAAQ,KACrE,OAAW,WAAW,aAAa;IACjC,SAAS,QAAQ;IACjB,IAAI,QAAQ,KAAA,GACV,SAAS,MAAM;GAEnB,CAAC;GAEH,OAAO;EACT;EAEA,OAAO,GAAG,IAAI,OAAS,KAAK;IAAG,OAAW,EAAE,MAAM,CAAC,GAAG,EAAE;GAAG;GAAO,GAAG;EAAQ,CAAC,CAAC;CACjF;CAEA,MAAM,UAAU,MAAM,YAAY;CAKlC,QAHiB,MADQ,GAAG,MAAM,KAAY,GAAG,CAAC,CAAC,CAAC,IAAI,EAAA,CAC5B,MACzB,QAAQ,IAAI,MAAM,YAAY,MAAM,YAAY,QAAY,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAA,CAAG,WAAW,CAEpF,KAAY,GAAG,IAAI,KAAK;EAAE;EAAO,GAAG;CAAQ,CAAC,CAAC;AACvD"}