@dxos/echo 0.8.4-main.bc674ce → 0.8.4-main.c351d160a8

package/dist/lib/neutral/{chunk-2MTHJ5UW.mjs → chunk-4JRI2ZJI.mjs}

@@ -1,7 +1,10 @@
 import {
-  Kind
-} from "./chunk-6QPSGMEF.mjs";
+  Kind,
+  KindId,
+  SnapshotKindId
+} from "./chunk-ROAGDPV7.mjs";
 import {
+  EchoObjectSchema,
   MetaId,
   VersionTypeId,
   addTag,
@@ -13,19 +16,16 @@ import {
   encodeVersion,
   getDXN,
   getDatabase,
-  getDescription,
   getKeys,
-  getLabel,
   getMetaChecked,
   getSnapshot,
+  getValue,
   isDeleted,
   isVersion,
   makeObject,
   objectFromJSON,
   objectToJSON,
   removeTag,
-  setDescription,
-  setLabel,
   setValue,
   sort,
   sortByLabel,
@@ -33,17 +33,27 @@ import {
   subscribe,
   version,
   versionValid
-} from "./chunk-SU2LVM7J.mjs";
+} from "./chunk-C4JZK4J7.mjs";
 import {
+  ParentId,
+  getDescription,
+  getLabel,
   getSchema,
   getTypeAnnotation,
   getTypeDXN,
   getTypename,
-  isInstanceOf
-} from "./chunk-CUDIBUM4.mjs";
+  isInstanceOf,
+  setDescription,
+  setLabel
+} from "./chunk-SEMVAGBM.mjs";
+import {
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  SchemaKindId
+} from "./chunk-WYOKA6AE.mjs";
 import {
-  KindId
-} from "./chunk-YQYMWZAD.mjs";
+  GetReactiveError
+} from "./chunk-UBEZSGXY.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -53,14 +63,16 @@ var Obj_exports = {};
 __export(Obj_exports, {
   ID: () => ID,
   Meta: () => Meta,
-  VersionTypeId: () => VersionTypeId,
+  Parent: () => Parent,
+  Unknown: () => Unknown2,
+  VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
   change: () => change2,
   clone: () => clone2,
-  compareVersions: () => compareVersions,
-  decodeVersion: () => decodeVersion,
+  compareVersions: () => compareVersions2,
+  decodeVersion: () => decodeVersion2,
   deleteKeys: () => deleteKeys2,
-  encodeVersion: () => encodeVersion,
+  encodeVersion: () => encodeVersion2,
   fromJSON: () => fromJSON,
   getDXN: () => getDXN2,
   getDatabase: () => getDatabase2,
@@ -68,39 +80,67 @@ __export(Obj_exports, {
   getKeys: () => getKeys2,
   getLabel: () => getLabel2,
   getMeta: () => getMeta,
+  getParent: () => getParent,
+  getReactive: () => getReactive,
+  getReactiveOption: () => getReactiveOption,
+  getReactiveOrThrow: () => getReactiveOrThrow,
   getSchema: () => getSchema2,
   getSnapshot: () => getSnapshot2,
   getTypeDXN: () => getTypeDXN2,
   getTypename: () => getTypename2,
-  getValue: () => getValue,
+  getValue: () => getValue2,
   instanceOf: () => instanceOf,
   isDeleted: () => isDeleted2,
   isObject: () => isObject,
-  isVersion: () => isVersion,
+  isSnapshot: () => isSnapshot,
+  isVersion: () => isVersion2,
   make: () => make,
   removeTag: () => removeTag2,
   setDescription: () => setDescription2,
   setLabel: () => setLabel2,
+  setParent: () => setParent,
   setValue: () => setValue2,
+  snapshotOf: () => snapshotOf,
   sort: () => sort2,
   sortByLabel: () => sortByLabel2,
   sortByTypename: () => sortByTypename2,
   subscribe: () => subscribe2,
   toJSON: () => toJSON,
   version: () => version2,
-  versionValid: () => versionValid
+  versionValid: () => versionValid2
 });
+import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import { createJsonPath, getValue as getValue$ } from "@dxos/effect";
+import { createJsonPath } from "@dxos/effect";
 import { assertArgument } from "@dxos/invariant";
 import { ObjectId } from "@dxos/keys";
 import { assumeType } from "@dxos/util";
+var Unknown2 = Schema.Struct({
+  id: Schema.String
+}).pipe(
+  Schema.extend(Schema.Record({
+    key: Schema.String,
+    value: Schema.Unknown
+  })),
+  // TODO(dmaretskyi): Clean this up.
+  // NOTE: The EchoObjectSchema annotation is required for Ref.Ref(Obj.Unknown) to work.
+  //   The typename/version only satisfy ECHO schema machinery for reference targets.
+  EchoObjectSchema({
+    typename: ANY_OBJECT_TYPENAME,
+    version: ANY_OBJECT_VERSION
+  }),
+  (schema) => Object.assign(schema, {
+    [SchemaKindId]: schema[SchemaKindId]
+  })
+);
 var defaultMeta = {
   keys: []
 };
-var make = (schema, props, meta) => {
+var make = (schema, props) => {
   assertArgument(getTypeAnnotation(schema)?.kind === Kind.Object, "schema", "Expected an object schema");
+  let meta = void 0;
   if (props[MetaId] != null) {
     meta = {
       ...structuredClone(defaultMeta),
@@ -109,6 +149,12 @@ var make = (schema, props, meta) => {
     delete props[MetaId];
   }
   const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== void 0));
+  for (const sym of Object.getOwnPropertySymbols(props)) {
+    const value = props[sym];
+    if (value !== void 0) {
+      filterUndefined[sym] = value;
+    }
+  }
   return makeObject(schema, filterUndefined, {
     ...defaultMeta,
     ...meta
@@ -118,16 +164,39 @@ var isObject = (obj) => {
   assumeType(obj);
   return typeof obj === "object" && obj !== null && obj[KindId] === Kind.Object;
 };
+var isSnapshot = (obj) => {
+  assumeType(obj);
+  return typeof obj === "object" && obj !== null && obj[SnapshotKindId] === Kind.Object;
+};
 var subscribe2 = (obj, callback) => {
   return subscribe(obj, callback);
 };
 var getSnapshot2 = getSnapshot;
+var getReactive = (snapshot) => Effect.gen(function* () {
+  const db = getDatabase(snapshot);
+  if (!db) {
+    return yield* Effect.fail(new GetReactiveError({
+      reason: "no-database",
+      snapshotId: snapshot.id
+    }));
+  }
+  const obj = db.getObjectById(snapshot.id);
+  if (!obj) {
+    return yield* Effect.fail(new GetReactiveError({
+      reason: "object-not-found",
+      snapshotId: snapshot.id
+    }));
+  }
+  return obj;
+});
+var getReactiveOption = (snapshot) => getReactive(snapshot).pipe(Effect.map(Option.some), Effect.catchAll(() => Effect.succeed(Option.none())));
+var getReactiveOrThrow = (snapshot) => Effect.runSync(getReactive(snapshot));
 var clone2 = clone;
 var change2 = (obj, callback) => {
   change(obj, callback);
 };
-var getValue = (obj, path) => {
-  return getValue$(obj, createJsonPath(path));
+var getValue2 = (obj, path) => {
+  return getValue(obj, createJsonPath(path));
 };
 var setValue2 = setValue;
 var ID = ObjectId;
@@ -137,6 +206,13 @@ var instanceOf = (...args) => {
   }
   return isInstanceOf(args[0], args[1]);
 };
+var snapshotOf = (...args) => {
+  const check = (entity) => entity != null && typeof entity === "object" && SnapshotKindId in entity && isInstanceOf(args[0], entity);
+  if (args.length === 1) {
+    return (entity) => check(entity);
+  }
+  return check(args[1]);
+};
 var getDXN2 = (entity) => {
   assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
   return getDXN(entity);
@@ -158,24 +234,49 @@ var getLabel2 = (entity) => getLabel(entity);
 var setLabel2 = (entity, label) => setLabel(entity, label);
 var getDescription2 = (entity) => getDescription(entity);
 var setDescription2 = (entity, description) => setDescription(entity, description);
+var Parent = ParentId;
+var getParent = (entity) => {
+  assertArgument(isObject(entity), "Expected an object");
+  assumeType(entity);
+  return entity[ParentId];
+};
+var setParent = (entity, parent) => {
+  assertArgument(isObject(entity), "Expected an object");
+  assertArgument(parent === void 0 || isObject(parent), "Expected an object");
+  assumeType(entity);
+  assumeType(parent);
+  entity[ParentId] = parent;
+};
 var toJSON = (entity) => objectToJSON(entity);
 var fromJSON = objectFromJSON;
 var sortByLabel2 = sortByLabel;
 var sortByTypename2 = sortByTypename;
 var sort2 = (...comparators) => sort(...comparators);
+var VersionTypeId2 = VersionTypeId;
+var isVersion2 = isVersion;
+var versionValid2 = versionValid;
+var compareVersions2 = compareVersions;
+var encodeVersion2 = encodeVersion;
+var decodeVersion2 = decodeVersion;
 var version2 = (entity) => version(entity);
 
 export {
+  Unknown2 as Unknown,
   make,
   isObject,
+  isSnapshot,
   subscribe2 as subscribe,
   getSnapshot2 as getSnapshot,
+  getReactive,
+  getReactiveOption,
+  getReactiveOrThrow,
   clone2 as clone,
   change2 as change,
-  getValue,
+  getValue2 as getValue,
   setValue2 as setValue,
   ID,
   instanceOf,
+  snapshotOf,
   getDXN2 as getDXN,
   getTypeDXN2 as getTypeDXN,
   getSchema2 as getSchema,
@@ -192,12 +293,21 @@ export {
   setLabel2 as setLabel,
   getDescription2 as getDescription,
   setDescription2 as setDescription,
+  Parent,
+  getParent,
+  setParent,
   toJSON,
   fromJSON,
   sortByLabel2 as sortByLabel,
   sortByTypename2 as sortByTypename,
   sort2 as sort,
+  VersionTypeId2 as VersionTypeId,
+  isVersion2 as isVersion,
+  versionValid2 as versionValid,
+  compareVersions2 as compareVersions,
+  encodeVersion2 as encodeVersion,
+  decodeVersion2 as decodeVersion,
   version2 as version,
   Obj_exports
 };
-//# sourceMappingURL=chunk-2MTHJ5UW.mjs.map
+//# sourceMappingURL=chunk-4JRI2ZJI.mjs.map

package/dist/lib/neutral/chunk-4JRI2ZJI.mjs.map

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

package/dist/lib/neutral/chunk-6DNYDXCV.mjs

@@ -0,0 +1,159 @@
+import {
+  select
+} from "./chunk-6GPU7XC3.mjs";
+import {
+  Feed
+} from "./chunk-7VNVH63N.mjs";
+import {
+  object
+} from "./chunk-YMNSMKKW.mjs";
+import {
+  nothing
+} from "./chunk-NXMFBIT5.mjs";
+import {
+  Ref
+} from "./chunk-FXEG7EOK.mjs";
+import {
+  Unknown,
+  instanceOf,
+  make
+} from "./chunk-4JRI2ZJI.mjs";
+import {
+  JsonSchemaType
+} from "./chunk-BOZZPUXE.mjs";
+import {
+  FormInputAnnotation,
+  IconAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-SEMVAGBM.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/index.ts
+import { QueryAST as QueryAST2 } from "@dxos/echo-protocol";
+import { DXN } from "@dxos/keys";
+
+// src/Hypergraph.ts
+var Hypergraph_exports = {};
+
+// src/Collection.ts
+var Collection_exports = {};
+__export(Collection_exports, {
+  Collection: () => Collection,
+  isCollection: () => isCollection,
+  make: () => make2
+});
+import * as Schema from "effect/Schema";
+var Collection = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  objects: Schema.Array(Ref(Unknown)).pipe(FormInputAnnotation.set(false))
+}).pipe(object({
+  typename: "org.dxos.type.collection",
+  version: "0.1.0"
+}), IconAnnotation.set({
+  icon: "ph--folder--regular",
+  hue: "neutral"
+}));
+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 { 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(object({
+  typename: "org.dxos.type.view",
+  version: "0.1.0"
+}), SystemTypeAnnotation.set(true), IconAnnotation.set({
+  icon: "ph--funnel--regular",
+  hue: "green"
+}));
+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(Feed, Collection, View);
+var isDataset = pipe(instanceOf(Feed), Predicate.or(instanceOf(Collection)), Predicate.or(instanceOf(View)));
+
+export {
+  Hypergraph_exports,
+  Collection_exports,
+  View_exports,
+  Dataset_exports,
+  QueryAST2 as QueryAST,
+  DXN
+};
+//# sourceMappingURL=chunk-6DNYDXCV.mjs.map

package/dist/lib/neutral/chunk-6DNYDXCV.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/Hypergraph.ts", "../../../src/Collection.ts", "../../../src/View.ts", "../../../src/Dataset.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport { QueryAST } from '@dxos/echo-protocol';\n// TODO(wittjosiah): Refactor DXN to not use statics similar to Query.\nexport { DXN } from '@dxos/keys';\n\nexport * as Annotation from './Annotation';\nexport * as Database from './Database';\nexport * as Entity from './Entity';\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 JsonSchema from './JsonSchema';\nexport * as Key from './Key';\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';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type DXN } 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   * Queue that the resolution is happening from.\n   * This queue will be searched first, and then the space it belongs to.\n   */\n  queue?: DXN;\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.fromDXN`\n   * `Ref.fromDXN(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>(dxn: DXN): 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 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport * as internal from './internal';\nimport * as Annotation from './Annotation';\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  Type.object({\n    typename: 'org.dxos.type.collection',\n    version: '0.1.0',\n  }),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--folder--regular',\n    hue: 'neutral',\n  }),\n);\n\nexport interface Collection extends Schema.Schema.Type<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 { PublicKey } from '@dxos/keys';\n\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';\nimport * as Annotation from './Annotation';\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  Type.object({\n    typename: 'org.dxos.type.view',\n    version: '0.1.0',\n  }),\n  internal.SystemTypeAnnotation.set(true),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--funnel--regular',\n    hue: 'green',\n  }),\n);\n\nexport interface View extends Schema.Schema.Type<typeof ViewSchema> {}\n\n/**\n * View instance type.\n */\n// NOTE: This interface is explicitly defined rather than derived from the schema to avoid\n//   TypeScript \"cannot be named\" portability errors. The schema contains QueryAST.Query which\n//   references internal @dxos/echo-protocol module paths. Without this explicit interface,\n//   any schema using Ref.Ref(View) would inherit the non-portable type and fail to compile.\n// TODO(wittjosiah): Find a better solution that doesn't require manually keeping the interface in sync.\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 View from './View';\n\n/**\n * Abstart set of objects, represented by a view, feed, or collection.\n */\nexport const Dataset = Schema.Union(Feed.Feed, Collection.Collection, View.View);\nexport type Dataset = Feed.Feed | Collection.Collection | View.View;\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;AAEzB,SAASC,WAAW;;;ACNpB;;;ACAA;;;;cAAAC;;AAMA,YAAYC,YAAY;AAWjB,IAAMC,aAAoBC,cAAO;EACtCC,MAAaC,cAAOC,KAAYC,eAAQ;EACxCC,SAAgBC,aAAUC,IAAQC,OAAO,CAAA,EAAGL,KAAcM,oBAAoBC,IAAI,KAAA,CAAA;AACpF,CAAA,EAAGP,KACIQ,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACWC,eAAeJ,IAAI;EAC5BK,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAKK,IAAMC,QAAO,CAACC,QAAmD,CAAC,MACnED,KAAKlB,YAAY;EAAEM,SAAS,CAAA;EAAI,GAAGa;AAAM,CAAA;AAExC,IAAMC,eAA4DC,WAAWrB,UAAAA;;;ACpCpF;;;;;;;cAAAsB;;AAMA,YAAYC,aAAY;AAExB,SAASC,gBAAgB;AACzB,SAASC,gBAAgB;AACzB,SAASC,iBAAiB;AAYnB,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,KACIW,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,qBAAqBC,IAAI,IAAA,GACvBC,eAAeD,IAAI;EAC5BE,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAaK,IAAMC,OAAuBf;AAE7B,IAAMgB,QAAO,CAACC,UAAAA;AACnB,SAAWD,KAAKD,MAAM;IACpBd,OAAO;MAAEE,KAAWe,OAAcC,QAAO,CAAA,EAAIhB;IAAI;IACjDG,YAAY;MAAET,QAAQ,CAAA;IAAG;IACzB,GAAGoB;EACL,CAAA;AACF;;;AC1GA;;;;;AAMA,SAASG,YAAY;AACrB,YAAYC,eAAe;AAC3B,YAAYC,aAAY;AAUjB,IAAMC,UAAiBC,cAAWC,MAAiBC,YAAiBC,IAAI;AAGxE,IAAMC,YAAkDC,KACzDC,WAAgBL,IAAI,GACdM,aAAOD,WAAsBJ,UAAU,CAAA,GACvCK,aAAOD,WAAgBH,IAAI,CAAA,CAAA;",
+  "names": ["QueryAST", "DXN", "make", "Schema", "Collection", "Struct", "name", "String", "pipe", "optional", "objects", "Array", "Ref", "Unknown", "FormInputAnnotation", "set", "object", "typename", "version", "IconAnnotation", "icon", "hue", "make", "props", "isCollection", "instanceOf", "make", "Schema", "QueryAST", "JsonPath", "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", "object", "typename", "version", "SystemTypeAnnotation", "set", "IconAnnotation", "icon", "hue", "View", "make", "props", "select", "nothing", "pipe", "Predicate", "Schema", "Dataset", "Union", "Feed", "Collection", "View", "isDataset", "pipe", "instanceOf", "or"]
+}