@dxos/echo 0.8.4-main.ead640a → 0.8.4-main.effb148878

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

@@ -0,0 +1,278 @@
+import {
+  Kind,
+  KindId,
+  SnapshotKindId
+} from "./chunk-L65CW5EI.mjs";
+import {
+  getSchema
+} from "./chunk-UQAMAXDU.mjs";
+import {
+  MetaId,
+  VersionTypeId,
+  addTag,
+  change,
+  deleteKeys,
+  getKeys,
+  getMetaChecked,
+  getSnapshot,
+  getValue,
+  isDeleted,
+  isVersion,
+  makeObject,
+  objectToJSON,
+  removeTag,
+  setValue,
+  sort,
+  sortByLabel,
+  sortByTypename,
+  subscribe,
+  version
+} from "./chunk-LNZIPZX6.mjs";
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  getDatabase,
+  getObjectEchoUri,
+  getUri,
+  isInstanceOf
+} from "./chunk-ZII2BGPM.mjs";
+import {
+  ParentId,
+  TypeAnnotationId,
+  getDescription,
+  getLabel,
+  getType,
+  getTypeAnnotation,
+  getTypeURI,
+  getTypename,
+  setDescription,
+  setLabel
+} from "./chunk-KHRAQDYX.mjs";
+import {
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  EntityKind
+} from "./chunk-A5HDDVKS.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,
+  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: () => getValue2,
+  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 { createJsonPath } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { EchoURI, DXN } 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(EchoURI.isEchoURI(uri), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 120, S: void 0, A: ["EchoURI.isEchoURI(uri)", ""] });
+  return uri;
+};
+var getTargetURI = (value) => {
+  assertArgument(isRelation(value), "Expected a relation");
+  assumeType(value);
+  const uri = value[RelationTargetDXNId];
+  invariant(EchoURI.isEchoURI(uri), void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 131, S: void 0, A: ["EchoURI.isEchoURI(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 getValue2 = (rel, path) => {
+  return getValue(rel, createJsonPath(path));
+};
+var setValue2 = setValue;
+var getURI = (entity) => getUri(entity);
+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);
+
+export {
+  Unknown2 as Unknown,
+  Source,
+  Target,
+  make,
+  instanceOf,
+  isRelation,
+  isSnapshot,
+  getSourceURI,
+  getTargetURI,
+  getSource,
+  getTarget,
+  update,
+  getSnapshot2 as getSnapshot,
+  subscribe2 as subscribe,
+  getValue2 as 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,
+  Relation_exports
+};
+//# sourceMappingURL=chunk-Q7ID37KF.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { EchoURI, type ObjectId, type URI, DXN } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as internal from './internal';\nimport * as entityInternal from './internal/Entity';\nimport * as Obj from './Obj';\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: ObjectId;\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?: ObjectId;\n  [Meta]?: internal.ObjectMeta;\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.ObjectMeta | 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): EchoURI.EchoURI => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(EchoURI.isEchoURI(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): EchoURI.EchoURI => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const uri = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(EchoURI.isEchoURI(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 internal.getValue(rel, 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 EchoURI,\n * but future entity kinds may surface other URI schemes; narrow with `EchoURI.parse(uri)`\n * or `DXN.tryMake(uri)` at the point of use. Accepts both reactive relations and snapshots.\n */\nexport const getURI = (entity: Unknown | Snapshot): URI.URI => internal.getUri(entity);\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 ObjectMeta.\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: string): 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: string): 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"],
+  "mappings": "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",
+  "names": ["Unknown", "VersionTypeId", "addTag", "deleteKeys", "getDatabase", "getDescription", "getKeys", "getLabel", "getSnapshot", "getType", "getTypeURI", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "createJsonPath", "assertArgument", "invariant", "EchoURI", "DXN", "assumeType", "Schema", "Record", "key", "annotations", "TypeAnnotationId", "kind", "Kind", "typename", "version", "sourceSchema", "targetSchema", "assertArgument", "internal", "getTypeAnnotation", "ParentId", "undefined", "meta", "props", "MetaId", "sourceDXN", "getObjectEchoUri", "RelationSourceDXNId", "RelationTargetDXNId", "targetDXN", "entity", "isInstanceOf", "args", "value", "assumeType", "invariant", "EchoURI", "uri", "relation", "RelationSourceId", "obj", "RelationTargetId", "getSnapshot", "subscribe", "getValue", "setValue", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "sortByTypename", "sort", "comparators", "VersionTypeId"]
+}

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

@@ -0,0 +1,205 @@
+import {
+  select
+} from "./chunk-J7QWJQQV.mjs";
+import {
+  Feed
+} from "./chunk-UN7K472Q.mjs";
+import {
+  nothing
+} from "./chunk-F625JEZB.mjs";
+import {
+  Unknown,
+  instanceOf,
+  make
+} from "./chunk-FFCN66OF.mjs";
+import {
+  Ref
+} from "./chunk-4SYHDOQA.mjs";
+import {
+  getSchema,
+  makeObject
+} from "./chunk-UQAMAXDU.mjs";
+import {
+  JsonSchemaType
+} from "./chunk-SSDGRJ3A.mjs";
+import {
+  FormInputAnnotation,
+  IconAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-KHRAQDYX.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/index.ts
+import { QueryAST as QueryAST2 } from "@dxos/echo-protocol";
+import { DXN as DXN3, EchoURI as EchoURI2, URI } from "@dxos/keys";
+
+// src/Hypergraph.ts
+var Hypergraph_exports = {};
+
+// src/Json.ts
+var Json_exports = {};
+__export(Json_exports, {
+  createRefReplacer: () => createRefReplacer
+});
+import { EchoURI } from "@dxos/keys";
+var isEncodedRef = (value) => typeof value === "object" && value !== null && Object.keys(value).length === 1 && typeof value["/"] === "string";
+var toJson = (obj) => typeof obj.toJSON === "function" ? obj.toJSON() : obj;
+var createRefReplacer = ({ db, depth = 1 }) => {
+  const hops = /* @__PURE__ */ new WeakMap();
+  return function(key, value) {
+    const parentHops = this && typeof this === "object" ? hops.get(this) ?? 0 : 0;
+    if (isEncodedRef(value)) {
+      if (parentHops >= depth) {
+        return value;
+      }
+      const dxnString = value["/"];
+      if (!dxnString.startsWith("dxn:") && !dxnString.startsWith("echo:")) {
+        return value;
+      }
+      let echoUri;
+      try {
+        const parsed = EchoURI.tryParse(dxnString);
+        echoUri = parsed ? EchoURI.getObjectId(parsed) : void 0;
+      } catch {
+        return value;
+      }
+      if (!echoUri) {
+        return value;
+      }
+      const target = db.getObjectById(echoUri);
+      if (!target) {
+        return value;
+      }
+      const encoded = toJson(target);
+      if (encoded != null && typeof encoded === "object") {
+        hops.set(encoded, parentHops + 1);
+      }
+      return encoded;
+    }
+    if (value != null && typeof value === "object") {
+      hops.set(value, parentHops);
+    }
+    return value;
+  };
+};
+
+// src/Collection.ts
+var Collection_exports = {};
+__export(Collection_exports, {
+  Collection: () => Collection,
+  isCollection: () => isCollection,
+  make: () => make2
+});
+import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
+var Collection = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  objects: Schema.Array(Ref(Unknown)).pipe(FormInputAnnotation.set(false))
+}).pipe(IconAnnotation.set({
+  icon: "ph--folder--regular",
+  hue: "amber"
+}), makeObject(DXN.make("org.dxos.type.collection", "0.1.0")));
+var make2 = (props = {}) => make(Collection, {
+  objects: [],
+  ...props
+});
+var isCollection = instanceOf(Collection);
+
+// src/View.ts
+var View_exports = {};
+__export(View_exports, {
+  FieldSchema: () => FieldSchema,
+  KeyValueProps: () => KeyValueProps,
+  Projection: () => Projection,
+  View: () => View,
+  createFieldId: () => createFieldId,
+  make: () => make3
+});
+import * as Schema2 from "effect/Schema";
+import { QueryAST } from "@dxos/echo-protocol";
+import { JsonPath } from "@dxos/effect";
+import { DXN as DXN2, PublicKey } from "@dxos/keys";
+var FieldSchema = Schema2.Struct({
+  id: Schema2.String,
+  path: JsonPath,
+  visible: Schema2.optional(Schema2.Boolean),
+  // TODO(wittjosiah): Presentation-specific?
+  referencePath: Schema2.optional(JsonPath)
+});
+var KeyValueProps = Schema2.Record({
+  key: Schema2.String,
+  value: Schema2.Any
+});
+var createFieldId = () => PublicKey.random().truncate();
+var Projection = Schema2.Struct({
+  /**
+  * Optional schema override used to customize the underlying schema.
+  */
+  schema: JsonSchemaType.pipe(Schema2.optional),
+  /**
+  * UX metadata associated with displayed fields (in table, form, etc.)
+  */
+  // TODO(wittjosiah): Should this just be an array of JsonPath?
+  fields: Schema2.Array(FieldSchema),
+  /**
+  * The id for the field used to pivot the view.
+  * E.g., the field to use for kanban columns or the field to use for map coordinates.
+  */
+  pivotFieldId: Schema2.String.pipe(Schema2.optional)
+});
+var ViewSchema = Schema2.Struct({
+  /**
+  * Query used to retrieve data.
+  * Can be a user-provided query grammar string or a query AST.
+  */
+  query: Schema2.Struct({
+    raw: Schema2.optional(Schema2.String),
+    ast: QueryAST.Query
+  }),
+  /**
+  * Projection of the data returned from the query.
+  */
+  projection: Projection
+}).pipe(SystemTypeAnnotation.set(true), IconAnnotation.set({
+  icon: "ph--funnel--regular",
+  hue: "green"
+}), makeObject(DXN2.make("org.dxos.type.view", "0.1.0")));
+var View = ViewSchema;
+var make3 = (props) => {
+  return make(View, {
+    query: {
+      ast: select(nothing()).ast
+    },
+    projection: {
+      fields: []
+    },
+    ...props
+  });
+};
+
+// src/Dataset.ts
+var Dataset_exports = {};
+__export(Dataset_exports, {
+  Dataset: () => Dataset,
+  isDataset: () => isDataset
+});
+import { pipe } from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Schema3 from "effect/Schema";
+var Dataset = Schema3.Union(getSchema(Feed), getSchema(Collection), getSchema(View));
+var isDataset = pipe(instanceOf(Feed), Predicate.or(instanceOf(Collection)), Predicate.or(instanceOf(View)));
+
+export {
+  Hypergraph_exports,
+  Json_exports,
+  Collection_exports,
+  View_exports,
+  Dataset_exports,
+  QueryAST2 as QueryAST,
+  DXN3 as DXN,
+  EchoURI2 as EchoURI,
+  URI
+};
+//# sourceMappingURL=chunk-QLYEQ5VA.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/Hypergraph.ts", "../../../src/Json.ts", "../../../src/Collection.ts", "../../../src/View.ts", "../../../src/Dataset.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport { QueryAST } from '@dxos/echo-protocol';\nexport { DXN, EchoURI, URI } from '@dxos/keys';\n\nexport * as Annotation from './Annotation';\nexport * as Database from './Database';\nexport * as Entity from './Entity';\n// TODO(burdon): Rename to Error (less problematic than Obj/Object).\nexport * as Err from './Err';\nexport * as Feed from './Feed';\nexport * as Filter from './Filter';\nexport * as Format from './Format';\nexport * as Hypergraph from './Hypergraph';\nexport * as Json from './Json';\nexport * as JsonSchema from './JsonSchema';\nexport * as Key from './Key';\nexport * as Migration from './Migration';\nexport * as Obj from './Obj';\nexport * as Order from './Order';\nexport * as Query from './Query';\nexport * as QueryResult from './QueryResult';\nexport * as Ref from './Ref';\nexport * as Relation from './Relation';\nexport * as SchemaRegistry from './SchemaRegistry';\nexport * as Tag from './Tag';\nexport * as Type from './Type';\nexport * as Collection from './Collection';\nexport * as View from './View';\nexport * as Dataset from './Dataset';\nexport * as Extension from './Extension';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type URI } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport type * as internal from './internal';\nimport type * as Key from './Key';\nimport type * as Ref from './Ref';\nimport type * as SchemaRegistry from './SchemaRegistry';\n\n/**\n * Resolution context.\n * Affects how non-absolute DXNs are resolved.\n */\nexport interface RefResolutionContext {\n  /**\n   * Space that the resolution is happening from.\n   */\n  space?: Key.SpaceId;\n\n  /**\n   * Feed that the resolution is happening from.\n   * This feed will be searched first, and then the space it belongs to.\n   */\n  feed?: URI.URI;\n}\n\nexport interface RefResolverOptions {\n  /**\n   * Resolution context.\n   * Affects how non-absolute DXNs are resolved.\n   */\n  context?: RefResolutionContext;\n\n  /**\n   * Middleware to change the resolved object before returning it.\n   * @deprecated On track to be removed.\n   */\n  middleware?: (obj: internal.AnyProperties) => internal.AnyProperties;\n}\n\n/**\n * Manages cross-space database interactions.\n */\nexport interface Hypergraph extends Database.Queryable {\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  /**\n   * Query objects.\n   */\n  query: Database.QueryFn;\n\n  /**\n   * Creates a reference to an existing object in the database.\n   *\n   * NOTE: The reference may be dangling if the object is not present in the database.\n   * NOTE: Difference from `Ref.fromURI`\n   * `Ref.fromURI(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.\n   * `db.makeRef(dxn)` is preferable in cases with access to the database.\n   */\n  makeRef<T extends Entity.Unknown = Entity.Unknown>(uri: URI.URI): Ref.Ref<T>;\n\n  /**\n   * @param hostDb Host database for reference resolution.\n   * @param middleware Called with the loaded object. The caller may change the object.\n   * @returns Result of `onLoad`.\n   */\n  // TODO(dmaretskyi): Restructure API: Remove middleware.\n  createRefResolver(options: RefResolverOptions): Ref.Resolver;\n\n  /**\n   * Get a database by space ID.\n   * @returns The database for the given space ID, or undefined if not found.\n   */\n  getDatabase(spaceId: Key.SpaceId): Database.Database | undefined;\n}\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { EchoURI } from '@dxos/keys';\n\nimport * as Database from './Database';\nimport * as Obj from './Obj';\n\n/**\n * `JSON.stringify` replacer signature.\n *\n * Defined here (rather than re-imported from a UI package) so other ECHO-aware utilities can\n * share a stable signature without creating a dependency edge into the UI tree.\n */\nexport type JsonReplacer = (key: string, value: any) => any;\n\nexport type CreateRefReplacerOptions = {\n  db: Database.Database;\n  /** How many ref hops to follow. `0` leaves all refs as-is. Default: `1`. */\n  depth?: number;\n};\n\nconst isEncodedRef = (value: unknown): value is { '/': string } =>\n  typeof value === 'object' &&\n  value !== null &&\n  Object.keys(value as object).length === 1 &&\n  typeof (value as { '/': unknown })['/'] === 'string';\n\nconst toJson = (obj: Obj.Any): unknown => (typeof (obj as any).toJSON === 'function' ? (obj as any).toJSON() : obj);\n\n/**\n * Returns a {@link JsonReplacer} that inlines ECHO ref objects (`{ \"/\": \"dxn:echo:...\" }`) up to\n * `depth` ref hops. Beyond that depth refs are left in their encoded form.\n *\n * Implemented as a per-call `JSON.stringify` replacer (not a one-shot tree walk at root) so it\n * composes with wrappers like `safeStringify` that intercept the root call. JSON.stringify\n * already drives the recursion; we only need to (a) detect a ref at the current callback,\n * (b) resolve and return the target if hop budget remains, and (c) tag the returned object\n * with its hop count so children know how far in they are.\n *\n * The hop count is tracked per-object via a `WeakMap`: a ref-resolved target's children inherit\n * `parentHops + 1`; a regular intermediate object's children inherit `parentHops`. This makes the\n * budget count *ref hops*, not tree depth — a ref deep in a tree still resolves once when\n * `depth >= 1`.\n *\n * Note: ECHO objects' `toJSON` runs before the replacer is invoked, so by the time we see a\n * value refs are already encoded as `{ \"/\": \"dxn:...\" }`.\n */\nexport const createRefReplacer = ({ db, depth = 1 }: CreateRefReplacerOptions): JsonReplacer => {\n  // Per-object hop count. Set when we return an object (via ref resolution or pass-through) so\n  // the child callbacks (which carry that object as `this`) can read it.\n  const hops = new WeakMap<object, number>();\n\n  return function (this: any, key: string, value: any) {\n    // Hop count for this call: hops at the parent, or 0 for the root.\n    const parentHops = this && typeof this === 'object' ? (hops.get(this) ?? 0) : 0;\n    if (isEncodedRef(value)) {\n      if (parentHops >= depth) {\n        return value;\n      }\n\n      // The `{ '/': string }` shape is shared with non-DXN IPLD-style refs (e.g. CIDs);\n      // an unparseable string would otherwise crash the whole `JSON.stringify`.\n      // Treat any parse miss as \"leave as-is\" rather than propagating.\n      const dxnString = value['/'];\n      if (!dxnString.startsWith('dxn:') && !dxnString.startsWith('echo:')) {\n        return value;\n      }\n\n      let echoUri: string | undefined;\n      try {\n        const parsed = EchoURI.tryParse(dxnString);\n        echoUri = parsed ? EchoURI.getObjectId(parsed) : undefined;\n      } catch {\n        return value;\n      }\n\n      if (!echoUri) {\n        return value;\n      }\n      const target = db.getObjectById(echoUri);\n      if (!target) {\n        return value;\n      }\n\n      const encoded = toJson(target);\n      if (encoded != null && typeof encoded === 'object') {\n        // Children of the resolved target are one hop deeper.\n        hops.set(encoded as object, parentHops + 1);\n      }\n      return encoded;\n    }\n\n    // Pass-through object: children inherit the parent's hop count (this branch doesn't burn\n    // budget).\n    if (value != null && typeof value === 'object') {\n      hops.set(value, parentHops);\n    }\n\n    return value;\n  };\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Ref from './Ref';\nimport * as Type from './Type';\n\n/**\n * A an ordered set of objects.\n */\nexport const Collection = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n  objects: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(internal.FormInputAnnotation.set(false)),\n}).pipe(\n  Annotation.IconAnnotation.set({\n    icon: 'ph--folder--regular',\n    hue: 'amber',\n  }),\n  Type.makeObject(DXN.make('org.dxos.type.collection', '0.1.0')),\n);\n\nexport type Collection = Type.InstanceType<typeof Collection>;\n\nexport const make = (props: Partial<Obj.MakeProps<typeof Collection>> = {}): Collection =>\n  Obj.make(Collection, { objects: [], ...props });\n\nexport const isCollection: (value: unknown) => value is Collection = Obj.instanceOf(Collection);\n", "//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport { QueryAST } from '@dxos/echo-protocol';\nimport { JsonPath } from '@dxos/effect';\nimport { DXN, PublicKey } from '@dxos/keys';\n\nimport * as Annotation from './Annotation';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Query from './Query';\nimport * as Type from './Type';\n\n/**\n * Stored field metadata (e.g., for UX).\n */\nexport const FieldSchema = Schema.Struct({\n  id: Schema.String,\n  path: JsonPath,\n  visible: Schema.optional(Schema.Boolean),\n\n  // TODO(wittjosiah): Presentation-specific?\n  referencePath: Schema.optional(JsonPath),\n});\n\nexport type FieldType = Schema.Schema.Type<typeof FieldSchema>;\n\nexport const KeyValueProps = Schema.Record({ key: Schema.String, value: Schema.Any });\n\nexport const createFieldId = () => PublicKey.random().truncate();\n\nexport const Projection = Schema.Struct({\n  /**\n   * Optional schema override used to customize the underlying schema.\n   */\n  schema: internal.JsonSchemaType.pipe(Schema.optional),\n\n  /**\n   * UX metadata associated with displayed fields (in table, form, etc.)\n   */\n  // TODO(wittjosiah): Should this just be an array of JsonPath?\n  fields: Schema.Array(FieldSchema),\n\n  /**\n   * The id for the field used to pivot the view.\n   * E.g., the field to use for kanban columns or the field to use for map coordinates.\n   */\n  pivotFieldId: Schema.String.pipe(Schema.optional),\n});\n\nexport type Projection = Schema.Schema.Type<typeof Projection>;\n\n/**\n * Views are generated or user-defined projections of a schema's properties.\n * They are used to configure the visual representation of the data.\n */\nconst ViewSchema = Schema.Struct({\n  /**\n   * Query used to retrieve data.\n   * Can be a user-provided query grammar string or a query AST.\n   */\n  query: Schema.Struct({\n    raw: Schema.optional(Schema.String),\n    ast: QueryAST.Query,\n  }),\n\n  /**\n   * Projection of the data returned from the query.\n   */\n  projection: Projection,\n}).pipe(\n  internal.SystemTypeAnnotation.set(true),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--funnel--regular',\n    hue: 'green',\n  }),\n  Type.makeObject(DXN.make('org.dxos.type.view', '0.1.0')),\n);\n\n// NOTE: Declared as a named interface and the `View` const is annotated `Type.Obj<View>` so\n//   downstream consumers see a named `View` type instead of the inlined `QueryAST.Query` union.\n//   Without the named interface, embedding `Type.getSchema(View.View)` in a downstream\n//   `Schema.Struct` triggers TS2742 portability errors (e.g. plugin-kanban, plugin-table).\n// TODO(wittjosiah): Find a better solution that doesn't require manually keeping the interface in sync.\nexport interface View extends Type.InstanceType<typeof ViewSchema> {}\n\nexport const View: Type.Obj<View> = ViewSchema as any;\n\nexport const make = (props: Partial<Obj.MakeProps<typeof View>>): View => {\n  return Obj.make(View, {\n    query: { ast: Query.select(Filter.nothing()).ast },\n    projection: { fields: [] },\n    ...props,\n  });\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\n\nimport { pipe } from 'effect/Function';\nimport * as Predicate from 'effect/Predicate';\nimport * as Schema from 'effect/Schema';\n\nimport * as Collection from './Collection';\nimport * as Feed from './Feed';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\nimport * as View from './View';\n\n/**\n * Abstract set of objects, represented by a view, feed, or collection.\n * Schema-level union of the underlying type entities (rebuilt via\n * `Type.getSchema`) so this can still be consumed by Schema-side APIs such\n * as `Filter.type(...)` on a union.\n */\nexport type Dataset = Feed.Feed | Collection.Collection | View.View;\nexport const Dataset = Schema.Union(\n  Type.getSchema(Feed.Feed),\n  Type.getSchema(Collection.Collection),\n  Type.getSchema(View.View),\n);\n\nexport const isDataset: (value: unknown) => value is Dataset = pipe(\n  Obj.instanceOf(Feed.Feed),\n  Predicate.or(Obj.instanceOf(Collection.Collection)),\n  Predicate.or(Obj.instanceOf(View.View)),\n);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,SAASA,YAAAA,iBAAgB;AACzB,SAASC,OAAAA,MAAKC,WAAAA,UAASC,WAAW;;;ACLlC;;;ACAA;;;;AAIA,SAASC,eAAe;AAmBxB,IAAMC,eAAe,CAACC,UACpB,OAAOA,UAAU,YACjBA,UAAU,QACVC,OAAOC,KAAKF,KAAAA,EAAiBG,WAAW,KACxC,OAAQH,MAA2B,GAAA,MAAS;AAE9C,IAAMI,SAAS,CAACC,QAA2B,OAAQA,IAAYC,WAAW,aAAcD,IAAYC,OAAM,IAAKD;AAoBxG,IAAME,oBAAoB,CAAC,EAAEC,IAAIC,QAAQ,EAAC,MAA4B;AAG3E,QAAMC,OAAO,oBAAIC,QAAAA;AAEjB,SAAO,SAAqBC,KAAaZ,OAAU;AAEjD,UAAMa,aAAa,QAAQ,OAAO,SAAS,WAAYH,KAAKI,IAAI,IAAI,KAAK,IAAK;AAC9E,QAAIf,aAAaC,KAAAA,GAAQ;AACvB,UAAIa,cAAcJ,OAAO;AACvB,eAAOT;MACT;AAKA,YAAMe,YAAYf,MAAM,GAAA;AACxB,UAAI,CAACe,UAAUC,WAAW,MAAA,KAAW,CAACD,UAAUC,WAAW,OAAA,GAAU;AACnE,eAAOhB;MACT;AAEA,UAAIiB;AACJ,UAAI;AACF,cAAMC,SAASpB,QAAQqB,SAASJ,SAAAA;AAChCE,kBAAUC,SAASpB,QAAQsB,YAAYF,MAAAA,IAAUG;MACnD,QAAQ;AACN,eAAOrB;MACT;AAEA,UAAI,CAACiB,SAAS;AACZ,eAAOjB;MACT;AACA,YAAMsB,SAASd,GAAGe,cAAcN,OAAAA;AAChC,UAAI,CAACK,QAAQ;AACX,eAAOtB;MACT;AAEA,YAAMwB,UAAUpB,OAAOkB,MAAAA;AACvB,UAAIE,WAAW,QAAQ,OAAOA,YAAY,UAAU;AAElDd,aAAKe,IAAID,SAAmBX,aAAa,CAAA;MAC3C;AACA,aAAOW;IACT;AAIA,QAAIxB,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9CU,WAAKe,IAAIzB,OAAOa,UAAAA;IAClB;AAEA,WAAOb;EACT;AACF;;;ACtGA;;;;cAAA0B;;AAMA,YAAYC,YAAY;AAExB,SAASC,WAAW;AAWb,IAAMC,aAAoBC,cAAO;EACtCC,MAAaC,cAAOC,KAAYC,eAAQ;EACxCC,SAAgBC,aAAUC,IAAQC,OAAO,CAAA,EAAGL,KAAcM,oBAAoBC,IAAI,KAAA,CAAA;AACpF,CAAA,EAAGP,KACUQ,eAAeD,IAAI;EAC5BE,MAAM;EACNC,KAAK;AACP,CAAA,GACKC,WAAWC,IAAIC,KAAK,4BAA4B,OAAA,CAAA,CAAA;AAKhD,IAAMA,QAAO,CAACC,QAAmD,CAAC,MACnED,KAAKjB,YAAY;EAAEM,SAAS,CAAA;EAAI,GAAGY;AAAM,CAAA;AAExC,IAAMC,eAA4DC,WAAWpB,UAAAA;;;ACnCpF;;;;;;;cAAAqB;;AAMA,YAAYC,aAAY;AAExB,SAASC,gBAAgB;AACzB,SAASC,gBAAgB;AACzB,SAASC,OAAAA,MAAKC,iBAAiB;AAYxB,IAAMC,cAAqBC,eAAO;EACvCC,IAAWC;EACXC,MAAMC;EACNC,SAAgBC,iBAAgBC,eAAO;;EAGvCC,eAAsBF,iBAASF,QAAAA;AACjC,CAAA;AAIO,IAAMK,gBAAuBC,eAAO;EAAEC,KAAYT;EAAQU,OAAcC;AAAI,CAAA;AAE5E,IAAMC,gBAAgB,MAAMC,UAAUC,OAAM,EAAGC,SAAQ;AAEvD,IAAMC,aAAoBlB,eAAO;;;;EAItCmB,QAAiBC,eAAeC,KAAYf,gBAAQ;;;;;EAMpDgB,QAAeC,cAAMxB,WAAAA;;;;;EAMrByB,cAAqBtB,eAAOmB,KAAYf,gBAAQ;AAClD,CAAA;AAQA,IAAMmB,aAAoBzB,eAAO;;;;;EAK/B0B,OAAc1B,eAAO;IACnB2B,KAAYrB,iBAAgBJ,cAAM;IAClC0B,KAAKC,SAASC;EAChB,CAAA;;;;EAKAC,YAAYb;AACd,CAAA,EAAGG,KACQW,qBAAqBC,IAAI,IAAA,GACvBC,eAAeD,IAAI;EAC5BE,MAAM;EACNC,KAAK;AACP,CAAA,GACKC,WAAWC,KAAIC,KAAK,sBAAsB,OAAA,CAAA,CAAA;AAU1C,IAAMC,OAAuBf;AAE7B,IAAMc,QAAO,CAACE,UAAAA;AACnB,SAAWF,KAAKC,MAAM;IACpBd,OAAO;MAAEE,KAAWc,OAAcC,QAAO,CAAA,EAAIf;IAAI;IACjDG,YAAY;MAAET,QAAQ,CAAA;IAAG;IACzB,GAAGmB;EACL,CAAA;AACF;;;ACpGA;;;;;AAMA,SAASG,YAAY;AACrB,YAAYC,eAAe;AAC3B,YAAYC,aAAY;AAejB,IAAMC,UAAiBC,cACvBC,UAAeC,IAAI,GACnBD,UAAqBE,UAAU,GAC/BF,UAAeG,IAAI,CAAA;AAGnB,IAAMC,YAAkDC,KACzDC,WAAgBL,IAAI,GACdM,aAAOD,WAAsBJ,UAAU,CAAA,GACvCK,aAAOD,WAAgBH,IAAI,CAAA,CAAA;",
+  "names": ["QueryAST", "DXN", "EchoURI", "URI", "EchoURI", "isEncodedRef", "value", "Object", "keys", "length", "toJson", "obj", "toJSON", "createRefReplacer", "db", "depth", "hops", "WeakMap", "key", "parentHops", "get", "dxnString", "startsWith", "echoUri", "parsed", "tryParse", "getObjectId", "undefined", "target", "getObjectById", "encoded", "set", "make", "Schema", "DXN", "Collection", "Struct", "name", "String", "pipe", "optional", "objects", "Array", "Ref", "Unknown", "FormInputAnnotation", "set", "IconAnnotation", "icon", "hue", "makeObject", "DXN", "make", "props", "isCollection", "instanceOf", "make", "Schema", "QueryAST", "JsonPath", "DXN", "PublicKey", "FieldSchema", "Struct", "id", "String", "path", "JsonPath", "visible", "optional", "Boolean", "referencePath", "KeyValueProps", "Record", "key", "value", "Any", "createFieldId", "PublicKey", "random", "truncate", "Projection", "schema", "JsonSchemaType", "pipe", "fields", "Array", "pivotFieldId", "ViewSchema", "query", "raw", "ast", "QueryAST", "Query", "projection", "SystemTypeAnnotation", "set", "IconAnnotation", "icon", "hue", "makeObject", "DXN", "make", "View", "props", "select", "nothing", "pipe", "Predicate", "Schema", "Dataset", "Union", "getSchema", "Feed", "Collection", "View", "isDataset", "pipe", "instanceOf", "or"]
+}