@dxos/echo 0.8.4-main.4a85c3132b → 0.8.4-main.4f23b4e393

package/dist/lib/neutral/{chunk-BRJSLACP.mjs → chunk-C6LDQTNO.mjs}

@@ -1,41 +1,88 @@
 import {
   select
-} from "./chunk-AQP4QKYP.mjs";
+} from "./chunk-SRX3EZY3.mjs";
 import {
   Feed
-} from "./chunk-GFNCSK7F.mjs";
+} from "./chunk-KBZ4RAXR.mjs";
 import {
   object
-} from "./chunk-T4MPQJ7X.mjs";
+} from "./chunk-AHWSAJHU.mjs";
 import {
   nothing
-} from "./chunk-ALOGSVBP.mjs";
-import {
-  Ref
-} from "./chunk-QXF3LGN2.mjs";
+} from "./chunk-PHOHAIEE.mjs";
 import {
   Unknown,
   instanceOf,
   make
-} from "./chunk-KGV3QIRX.mjs";
+} from "./chunk-W7U2XGZ3.mjs";
+import {
+  Ref
+} from "./chunk-N7VOEPSV.mjs";
 import {
   JsonSchemaType
-} from "./chunk-PP4DNUZU.mjs";
+} from "./chunk-MLS7U7AT.mjs";
 import {
   FormInputAnnotation,
+  IconAnnotation,
   SystemTypeAnnotation
-} from "./chunk-F7KMHDPJ.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
 
 // src/index.ts
 import { QueryAST as QueryAST2 } from "@dxos/echo-protocol";
-import { DXN } from "@dxos/keys";
+import { DXN as DXN2 } from "@dxos/keys";
 
 // src/Hypergraph.ts
 var Hypergraph_exports = {};
 
+// src/Json.ts
+var Json_exports = {};
+__export(Json_exports, {
+  createRefReplacer: () => createRefReplacer
+});
+import { DXN } 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:")) {
+        return value;
+      }
+      let echoId;
+      try {
+        echoId = DXN.parse(dxnString).asEchoDXN()?.echoId;
+      } catch {
+        return value;
+      }
+      if (!echoId) {
+        return value;
+      }
+      const target = db.getObjectById(echoId);
+      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, {
@@ -48,8 +95,11 @@ var Collection = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
   objects: Schema.Array(Ref(Unknown)).pipe(FormInputAnnotation.set(false))
 }).pipe(object({
-  typename: "dxos.org/type/Collection",
+  typename: "org.dxos.type.collection",
   version: "0.1.0"
+}), IconAnnotation.set({
+  icon: "ph--folder--regular",
+  hue: "amber"
 }));
 var make2 = (props = {}) => make(Collection, {
   objects: [],
@@ -113,9 +163,12 @@ var ViewSchema = Schema2.Struct({
   */
   projection: Projection
 }).pipe(object({
-  typename: "dxos.org/type/View",
-  version: "0.5.0"
-}), SystemTypeAnnotation.set(true));
+  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, {
@@ -143,10 +196,11 @@ var isDataset = pipe(instanceOf(Feed), Predicate.or(instanceOf(Collection)), Pre
 
 export {
   Hypergraph_exports,
+  Json_exports,
   Collection_exports,
   View_exports,
   Dataset_exports,
   QueryAST2 as QueryAST,
-  DXN
+  DXN2 as DXN
 };
-//# sourceMappingURL=chunk-BRJSLACP.mjs.map
+//# sourceMappingURL=chunk-C6LDQTNO.mjs.map

package/dist/lib/neutral/chunk-C6LDQTNO.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';\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';\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 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   * Feed that the resolution is happening from (as the underlying queue DXN).\n   * This feed will be searched first, and then the space it belongs to.\n   */\n  feed?: 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 2026 DXOS.org\n//\n\nimport { DXN } 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:')) {\n        return value;\n      }\n\n      let echoId: string | undefined;\n      try {\n        echoId = DXN.parse(dxnString).asEchoDXN()?.echoId;\n      } catch {\n        return value;\n      }\n\n      if (!echoId) {\n        return value;\n      }\n      const target = db.getObjectById(echoId);\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 * 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  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: 'amber',\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 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  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": "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",
+  "names": ["QueryAST", "DXN", "DXN", "isEncodedRef", "value", "Object", "keys", "length", "toJson", "obj", "toJSON", "createRefReplacer", "db", "depth", "hops", "WeakMap", "key", "parentHops", "get", "dxnString", "startsWith", "echoId", "parse", "asEchoDXN", "target", "getObjectById", "encoded", "set", "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"]
+}

package/dist/lib/neutral/{chunk-ZWKJ4LZJ.mjs → chunk-GKBXQFQK.mjs}

@@ -1,10 +1,10 @@
 import {
   Unknown
-} from "./chunk-KGV3QIRX.mjs";
+} from "./chunk-W7U2XGZ3.mjs";
 import {
   KindId,
   SnapshotKindId
-} from "./chunk-W7OP5HGZ.mjs";
+} from "./chunk-NWXJZVWD.mjs";
 import {
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
@@ -20,9 +20,7 @@ import {
   deleteKeys,
   getDXN,
   getDatabase,
-  getDescription,
   getKeys,
-  getLabel,
   getMetaChecked,
   getObjectDXN,
   getSnapshot,
@@ -32,26 +30,28 @@ import {
   makeObject,
   objectToJSON,
   removeTag,
-  setDescription,
-  setLabel,
   setValue,
   sort,
   sortByLabel,
   sortByTypename,
   subscribe,
   version
-} from "./chunk-PP4DNUZU.mjs";
+} from "./chunk-ZVQ26DCR.mjs";
 import {
   ParentId,
+  getDescription,
+  getLabel,
   getSchema,
   getTypeAnnotation,
   getTypeDXN,
-  getTypename
-} from "./chunk-F7KMHDPJ.mjs";
+  getTypename,
+  setDescription,
+  setLabel
+} from "./chunk-TNBK56IN.mjs";
 import {
   EntityKind,
   SchemaKindId
-} from "./chunk-4KG6IGL4.mjs";
+} from "./chunk-N4B7FHQT.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -65,7 +65,6 @@ __export(Relation_exports, {
   Unknown: () => Unknown3,
   VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
-  change: () => change2,
   deleteKeys: () => deleteKeys2,
   getDXN: () => getDXN2,
   getDatabase: () => getDatabase2,
@@ -96,6 +95,7 @@ __export(Relation_exports, {
   sortByTypename: () => sortByTypename2,
   subscribe: () => subscribe2,
   toJSON: () => toJSON,
+  update: () => update,
   version: () => version2
 });
 import * as Schema from "effect/Schema";
@@ -116,7 +116,7 @@ var Unknown3 = Schema.Struct({
   // NOTE: The EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.
   //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.
   EchoRelationSchema({
-    typename: "dxos.org/schema/AnyRelation",
+    typename: "org.dxos.schema.anyRelation",
     version: "0.0.0",
     source: Unknown,
     target: Unknown
@@ -161,63 +161,35 @@ var getSourceDXN = (value) => {
   assertArgument(isRelation(value), "Expected a relation");
   assumeType(value);
   const dxn = value[RelationSourceDXNId];
-  invariant(dxn instanceof DXN, void 0, {
-    F: __dxlog_file,
-    L: 211,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
+  invariant(dxn instanceof DXN, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 100, S: void 0, A: ["dxn instanceof DXN", ""] });
   return dxn;
 };
 var getTargetDXN = (value) => {
   assertArgument(isRelation(value), "Expected a relation");
   assumeType(value);
   const dxn = value[RelationTargetDXNId];
-  invariant(dxn instanceof DXN, void 0, {
-    F: __dxlog_file,
-    L: 224,
-    S: void 0,
-    A: [
-      "dxn instanceof DXN",
-      ""
-    ]
-  });
+  invariant(dxn instanceof DXN, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 111, S: void 0, A: ["dxn instanceof DXN", ""] });
   return dxn;
 };
 var getSource = (relation) => {
   assertArgument(isRelation(relation), "Expected a relation");
   assumeType(relation);
   const obj = relation[RelationSourceId];
-  invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 237,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid source: ${relation.id}`"
-    ]
-  });
+  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];
-  invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
-    F: __dxlog_file,
-    L: 250,
-    S: void 0,
-    A: [
-      "obj !== undefined",
-      "`Invalid target: ${relation.id}`"
-    ]
-  });
+  if (obj === void 0) {
+    throw new Error(`Relation target could not be resolved.`);
+  }
   return obj;
 };
-var change2 = (relation, callback) => {
+var update = (relation, callback) => {
   change(relation, callback);
 };
 var getSnapshot2 = getSnapshot;
@@ -265,7 +237,7 @@ export {
   getTargetDXN,
   getSource,
   getTarget,
-  change2 as change,
+  update,
   getSnapshot2 as getSnapshot,
   subscribe2 as subscribe,
   getValue2 as getValue,
@@ -295,4 +267,4 @@ export {
   version2 as version,
   Relation_exports
 };
-//# sourceMappingURL=chunk-ZWKJ4LZJ.mjs.map
+//# sourceMappingURL=chunk-GKBXQFQK.mjs.map

package/dist/lib/neutral/chunk-GKBXQFQK.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 { DXN, type ObjectId } 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 type * 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: Type.Relation<Unknown, Obj.Any, Obj.Any> = 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 EchoRelationSchema annotation is required for Ref.Ref(Relation.Unknown) to work.\n  //   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.\n  internal.EchoRelationSchema({\n    typename: 'org.dxos.schema.anyRelation',\n    version: '0.0.0',\n    source: Obj.Unknown,\n    target: Obj.Unknown,\n  }),\n  (schema) =>\n    Object.assign(schema, {\n      [internal.SchemaKindId]: (schema as any)[internal.SchemaKindId],\n    }) as unknown as Type.Relation<Unknown, Obj.Any, Obj.Any>,\n);\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 Unknown> = {\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.\n * Takes a schema type (created with Type.Relation) and extracts the props type.\n */\nexport type MakeProps<S extends Type.AnyRelation> = MakePropsInternal<Schema.Schema.Type<S>>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata. (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 = <S extends Type.AnyRelation>(\n  schema: S,\n  props: NoInfer<MakeProps<S>>,\n): Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation> => {\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.getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = internal.getObjectDXN(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  return internal.makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (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 DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<internal.InternalObjectProps>(value);\n  const dxn = (value as internal.InternalObjectProps)[internal.RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): 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 DXN of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => internal.getDXN(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeDXN = internal.getTypeDXN;\n\n/**\n * Get the schema of the relation.\n * Returns the branded ECHO schema used to create the relation.\n */\nexport const getSchema: (rel: unknown | undefined) => Type.AnyEntity | undefined = internal.getSchema as any;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => 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 */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;iBAAAA;EAAA,qBAAAC;EAAA,cAAAC;EAAA,kBAAAC;EAAA,cAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,eAAAC;EAAA,gBAAAC;EAAA;mBAAAC;EAAA,mBAAAC;EAAA;;;;oBAAAC;EAAA,mBAAAC;EAAA,gBAAAC;EAAA,iBAAAC;EAAA;;mBAAAC;EAAA;mBAAAC;EAAA,sBAAAC;EAAA,gBAAAC;EAAA,gBAAAC;EAAA,YAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,iBAAAC;EAAA;;iBAAAC;;AAMA,YAAYC,YAAY;AAExB,SAASC,aAAa;AAEtB,SAASC,sBAAsB;AAC/B,SAASC,gBAAgBC,iBAAiB;AAC1C,SAASC,WAA0B;AACnC,SAASC,kBAAkB;AA8B3B,IAAA,eAAA;AAoBO,IACLC,WAAqBC,cAAO;EAAEC,IAAKF;;EAAsBA,cAAc,cAAA;IAAC,KACxE;IACA,OAAA;EACA,CAAA,CAAA;;;;EAGEG,mBAAS;IACTC,UAAQC;IACRC,SAAQD;IAEV,QACEE;YACGC;;EACH,CAAA,WACF,OAAA,OAAA,QAAA;IAkCK,CAAMC,YAAwBC,GAAAA,OAAeC,YAAwB;EAG5E,CAAA;AAAA;AA6BA,IAAA,SAAA;;AAkBEC,IAAAA,OAAeC,CAAAA,QAAML,UAASM;AAE9B,iBAA4CC,kBAAAA,MAAAA,GAAAA,SAAAA,WAAAA,UAAAA,UAAAA,4BAAAA;AAE5C,iBAAUP,MAAoB,QAAM,MAAA,QAAA,SAAA,qCAAA;MAClCQ,OAAOH;MACP,MAAaL,MAAAA,KAASS,MAAO;AAC/B,WAAA,MAAA,MAAA;AAEA,WAAMC,MAAYV,MAASW;EAC3B;AAECN,QAAcL,YAASY,aAAuBF,MAAAA,MAAAA,CAAAA,KAAAA,MAAAA,IAAAA,MAAAA,4BAAAA,CAAAA;AAC9CL,QAAcL,YAASa,aAAuBC,MAAAA,MAAAA,CAAAA,KAAAA,MAAAA,IAAAA,MAAAA,4BAAAA,CAAAA;AAE/C,QAAOd,mBAA2Ce,IAAQV;AAC1D,QAAA,mBAAA,IAAA;AAEF,SAAA,WAAA,QAAA,OAAA,IAAA;;AAMI,IAAO,aAAA,CAAA,UAAA;AACT,MAAA,OAAA,UAAA,YAAA,UAAA,MAAA;AACIL,WAAAA;;AAEJ,MAAA,wBAAA,SAAA,wBAAA,OAAA;AAEA,WAAA;EACA;AAEA,QAAA,OAAA,MAAA,MAAA,KAAA,MAAA,cAAA;AAEF,SAAO,SAAoBgB,WAAAA;;IAEvB,aAAO,CAAA,UAAA;AACT,MAAA,OAAA,UAAA,YAAA,UAAA,MAAA;AACA,WAAQA;EACR;AAEF,SAAA,MAAA,cAAA,MAAA,WAAA;;AAOEC,IAAyCD,eAAAA,CAAAA,UAAAA;AACzC,iBAAaA,WAAuChB,KAASY,GAAAA,qBAAoB;AACjFM,aAAUC,KAAAA;AACV,QAAA,MAAOA,MAAAA,mBAAAA;AACP,YAAA,eAAA,KAAA,QAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,KAAA,GAAA,QAAA,GAAA,CAAA,sBAAA,EAAA,EAAA,CAAA;AAEF,SAAA;;AAOEF,IAAyCD,eAAAA,CAAAA,UAAAA;AACzC,iBAAaA,WAAuChB,KAASa,GAAAA,qBAAoB;AACjFK,aAAUC,KAAAA;AACV,QAAA,MAAOA,MAAAA,mBAAAA;AACP,YAAA,eAAA,KAAA,QAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,KAAA,GAAA,QAAA,GAAA,CAAA,sBAAA,EAAA,EAAA,CAAA;AAEF,SAAA;;AAOEF,IAAyCG,YAAAA,CAAAA,aAAAA;AACzC,iBAAaA,WAA0CpB,QAASG,GAAAA,qBAAiB;AACjF,aAAIkB,QAAQd;QACV,MAAM,SAAW,gBAAA;AACnB,MAAA,QAAA,QAAA;AACA,UAAOc,IAAAA,MAAAA,wCAAAA;EACP;AAEF,SAAA;;AAOEJ,IAAyCG,YAAAA,CAAAA,aAAAA;AACzC,iBAAaA,WAA0CpB,QAASsB,GAAAA,qBAAiB;AACjF,aAAID,QAAQd;QACV,MAAM,SAAW,gBAAA;AACnB,MAAA,QAAA,QAAA;AACA,UAAOc,IAAAA,MAAAA,wCAAAA;EACP;AAYF,SAAA;;AA4BE,IAAA,SAAA,CAAA,UAAA,aAAA;AAEA,EAAA,OAAA,UAAA,QAAA;AACF;AAWA,IAAYE,eAAA;AAWV,IAAAC,aAAA,CAAA,KAAA,aAAA;AAEA,SAAA,UAAA,KAAA,QAAA;AACF;AASE,IAAAC,YAAA,CAAA,KAAA,SAAA;AAEF,SAAA,SAAA,KAAA,eAAA,IAAA,CAAA;;AAWO,IAAAC,YAAA;;;;AA2BI,IAAAC,eAAA,CAAA,WAAA,YAAA,MAAA;AAUJ,IAAAC,eAAA,CAAA,WAAA,YAAA,MAAA;AA6BE5B,IAAAA,OAAS6B;AAClB,SAAA,QAAA,QAAA;AAEA,SAAA,eAAA,MAAA;;;;;;AAwCA,IAAcC,aAAA,CAAA,WAAA,UAAA,MAAA;;;;;AA4DP,IAAMC,SAAAA,CAAAA,WAAsCA,aAA6B,MAAA;AACzE,IAAMC,eAAWC;AAEtB,IAAAF,kBAAA;AACF,IAAUC,QAAA,IAAA,gBAAA,KAAA,GAAA,WAAA;AAWV,IAAAE,iBAAA;;;",
+  "names": ["Unknown", "VersionTypeId", "addTag", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "Schema", "raise", "createJsonPath", "assertArgument", "invariant", "DXN", "assumeType", "Schema", "Record", "key", "version", "source", "Obj", "target", "Object", "internal", "Source", "entityInternal", "RelationSourceId", "assertArgument", "props", "ParentId", "undefined", "meta", "MetaId", "sourceDXN", "getObjectDXN", "RelationSourceDXNId", "RelationTargetDXNId", "targetDXN", "schema", "value", "assumeType", "invariant", "dxn", "relation", "obj", "RelationTargetId", "getSnapshot", "subscribe", "getValue", "setValue", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "sortByTypename", "sort", "comparators", "VersionTypeId"]
+}

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

@@ -0,0 +1,50 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Extension.ts
+var Extension_exports = {};
+__export(Extension_exports, {
+  Key: () => Key,
+  TypeId: () => TypeId,
+  Values: () => Values,
+  get: () => get,
+  make: () => make,
+  set: () => set
+});
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+var TypeId = "~@dxos/echo/Extension";
+var make = (key, valueSchema) => {
+  return {
+    [TypeId]: {},
+    key: Key.make(key),
+    valueSchema
+  };
+};
+var Key = Schema.String.pipe(Schema.brand("~@dxos/echo/ExtensionKey"));
+var Values = Schema.Record({
+  key: Key,
+  value: Schema.Unknown
+});
+var get = Function.dual(2, (values, extension) => {
+  if (!(extension.key in values)) {
+    return Option.none();
+  }
+  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);
+});
+var set = Function.dual(3, (values, extension, value) => {
+  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);
+});
+
+export {
+  TypeId,
+  make,
+  Key,
+  Values,
+  get,
+  set,
+  Extension_exports
+};
+//# sourceMappingURL=chunk-GWFFC34K.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Extension.ts"],
+  "sourcesContent": ["// @import-as-namespace\n//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\n// @import-as-namespace\n\n/**\n * Extensions allow objects to contain typed properties that are not part of the schema.\n */\n\nexport const TypeId = '~@dxos/echo/Extension' as const;\nexport type TypeId = typeof TypeId;\n\nexport interface Extension<T> extends Record<\n  TypeId,\n  {\n    _Type: T;\n  }\n> {\n  readonly [TypeId]: {\n    _Type: T;\n  };\n\n  readonly key: Key;\n  readonly valueSchema: Schema.Schema<T>;\n}\n\n/**\n * Create a new typed extension.\n *\n * ```ts\n * const ColorExtension = Extension.make('color', Schema.String);\n *\n * const obj = Obj.make(Person, {\n *   [Obj.Meta]: { keys: [{ source: 'external', id: '123' }] },\n *   name: 'John',\n *   email: 'john@example.com',\n * });\n *\n * Obj.update(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n *\n * console.log(Extension.get(obj.extensions, ColorExtension)); // 'red'\n * ```\n */\nexport const make = <S extends Schema.Schema.AnyNoContext>(\n  key: string,\n  valueSchema: S,\n): Extension<Schema.Schema.Type<S>> => {\n  return {\n    [TypeId]: {} as any,\n    key: Key.make(key),\n    valueSchema,\n  };\n};\n\n/**\n * Unique identifier for an extension.\n */\n// TODO(dmaretskyi): filter to be fully qualified: (e.g., org.dxos.extension.color)\nexport const Key = Schema.String.pipe(Schema.brand('~@dxos/echo/ExtensionKey'));\nexport type Key = Schema.Schema.Type<typeof Key>;\n\n/**\n * Set of extension values.\n *\n * Can be used inside an object/relation schema:\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n *   extensions: Extension.Values,\n * });\n * ```\n */\nexport const Values = Schema.Record({ key: Key, value: Schema.Unknown });\nexport interface Values extends Schema.Schema.Type<typeof Values> {}\n\n/**\n * Get the value of an extension from a set of values.\n */\nexport const get: {\n  <T>(extension: Extension<T>): (values: Values) => Option.Option<T>;\n  <T>(values: Values, extension: Extension<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(extension: Extension<T>) => (values: Values) => Option.Option<T>,\n  <T>(values: Values, extension: Extension<T>) => Option.Option<T>\n>(2, (values, extension) => {\n  if (!(extension.key in values)) {\n    return Option.none();\n  }\n\n  return Function.pipe(values[extension.key], Schema.decodeUnknownSync(extension.valueSchema), Option.some);\n});\n\n/**\n * Set the value of an extension in a set of values.\n *\n * Can also be used within Obj.update callback:\n *\n * ```ts\n * Obj.update(obj, (obj) => {\n *   Extension.set(obj.extensions, ColorExtension, 'red');\n * });\n * ```\n */\nexport const set: {\n  <T>(extension: Extension<T>, value: T): (values: Values) => void;\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T): void;\n} = Function.dual<\n  <T>(extension: Extension<T>, value: T) => (values: Values) => void,\n  <T>(values: Types.Mutable<Values>, extension: Extension<T>, value: T) => void\n>(3, (values, extension, value) => {\n  values[extension.key] = Schema.encodeSync(extension.valueSchema)(value);\n});\n"],
+  "mappings": ";;;;;AAAA;;;;;;;;;AAKA,YAAYA,cAAc;AAC1B,YAAYC,YAAY;AACxB,YAAYC,YAAY;AASjB,IAAMC,SAAS;AAoCf,IAAMC,OAAO,CAClBC,KACAC,gBAAAA;AAEA,SAAO;IACL,CAACH,MAAAA,GAAS,CAAC;IACXE,KAAKE,IAAIH,KAAKC,GAAAA;IACdC;EACF;AACF;AAMO,IAAMC,MAAaC,cAAOC,KAAYC,aAAM,0BAAA,CAAA;AAe5C,IAAMC,SAAgBC,cAAO;EAAEP,KAAKE;EAAKM,OAAcC;AAAQ,CAAA;AAM/D,IAAMC,MAGAC,cAGX,GAAG,CAACC,QAAQC,cAAAA;AACZ,MAAI,EAAEA,UAAUb,OAAOY,SAAS;AAC9B,WAAcE,YAAI;EACpB;AAEA,SAAgBV,cAAKQ,OAAOC,UAAUb,GAAG,GAAUe,yBAAkBF,UAAUZ,WAAW,GAAUe,WAAI;AAC1G,CAAA;AAaO,IAAMC,MAGAN,cAGX,GAAG,CAACC,QAAQC,WAAWL,UAAAA;AACvBI,SAAOC,UAAUb,GAAG,IAAWkB,kBAAWL,UAAUZ,WAAW,EAAEO,KAAAA;AACnE,CAAA;",
+  "names": ["Function", "Option", "Schema", "TypeId", "make", "key", "valueSchema", "Key", "String", "pipe", "brand", "Values", "Record", "value", "Unknown", "get", "dual", "values", "extension", "none", "decodeUnknownSync", "some", "set", "encodeSync"]
+}

package/dist/lib/neutral/{chunk-5ELDDYWE.mjs → chunk-I2DARWPX.mjs}

@@ -1,9 +1,9 @@
 import {
   isInstanceOf
-} from "./chunk-F7KMHDPJ.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   ObjectNotFoundError
-} from "./chunk-MXQJZCPY.mjs";
+} from "./chunk-ZISMEVKD.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -23,9 +23,11 @@ __export(Database_exports, {
   makeService: () => makeService,
   notAvailable: () => notAvailable,
   query: () => query,
+  registerSchema: () => registerSchema,
   remove: () => remove,
   resolve: () => resolve,
   runQuery: () => runQuery,
+  runQueryFirst: () => runQueryFirst,
   runSchemaQuery: () => runSchemaQuery,
   schemaQuery: () => schemaQuery,
   spaceId: () => spaceId
@@ -76,33 +78,27 @@ var resolve = (ref, schema) => Effect.gen(function* () {
   if (!object) {
     return yield* Effect.fail(new ObjectNotFoundError(dxn));
   }
-  invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", {
-    F: __dxlog_file,
-    L: 228,
-    S: this,
-    A: [
-      "!schema || isInstanceOf(schema, object)",
-      "'Object type mismatch.'"
-    ]
-  });
+  invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 67, S: this, A: ["!schema || isInstanceOf(schema, object)", "'Object type mismatch.'"] });
   return object;
-});
-var load = Effect.fn(function* (ref) {
+}).pipe(Effect.withSpan("Database.resolve"));
+var load = Effect.fn("Database.load")(function* (ref) {
   const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
   if (!object) {
     return yield* Effect.fail(new ObjectNotFoundError(ref.dxn));
   }
   return object;
 });
-var loadOption = Effect.fn(function* (ref) {
+var loadOption = Effect.fn("Database.loadOption")(function* (ref) {
   const object = yield* load(ref).pipe(Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(void 0)));
   return Option.fromNullable(object);
 });
-var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj)));
-var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj)));
-var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
+var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan("Database.add"));
+var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan("Database.remove"));
+var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(Effect.withSpan("Database.flush"));
 var query = (queryOrFilter) => Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Database.query"));
-var runQuery = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
+var runQuery = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())), Effect.withSpan("Database.runQuery"));
+var runQueryFirst = (queryOrFilter) => query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined()))), Effect.withSpan("Database.runQueryFirst"));
+var registerSchema = (input) => Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))), Effect.withSpan("Database.registerSchema"));
 var schemaQuery = (schemaQueryOptions) => Service.pipe(Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)), Effect.withSpan("Database.schemaQuery"));
 var runSchemaQuery = (schemaQueryOptions) => schemaQuery(schemaQueryOptions).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
 
@@ -123,8 +119,10 @@ export {
   flush,
   query,
   runQuery,
+  runQueryFirst,
+  registerSchema,
   schemaQuery,
   runSchemaQuery,
   Database_exports
 };
-//# sourceMappingURL=chunk-5ELDDYWE.mjs.map
+//# sourceMappingURL=chunk-I2DARWPX.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, type SpaceId } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport * as Err from './Err';\nimport type * as Filter from './Filter';\nimport type * as Hypergraph from './Hypergraph';\nimport { isInstanceOf } from './internal/Annotation';\nimport { type AnyProperties } from './internal/common/types';\nimport type { Ref } from './internal/Ref/ref';\nimport type * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport type * as SchemaRegistry from './SchemaRegistry';\nimport type * as Type from './Type';\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\nexport interface QueryFn {\n  <Q extends Query.Any>(query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n  <F extends Filter.Any>(filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database, Feed, and Hypergraph.\n */\nexport interface Queryable {\n  query: QueryFn;\n}\n\nexport type GetObjectByIdOptions = {\n  deleted?: boolean;\n};\n\nexport type ObjectPlacement = 'root-doc' | 'linked-doc';\n\nexport type AddOptions = {\n  /**\n   * Where to place the object in the Automerge document tree.\n   * Root document is always loaded with the space.\n   * Linked documents are loaded lazily.\n   * Placing large number of objects in the root document may slow down the initial load.\n   *\n   * @default 'linked-doc'\n   */\n  placeIn?: ObjectPlacement;\n};\n\nexport type FlushOptions = {\n  /**\n   * Write any pending changes to disk.\n   * @default true\n   */\n  disk?: boolean;\n\n  /**\n   * Wait for pending index updates.\n   * @default true\n   */\n  indexes?: boolean;\n\n  /**\n   * Flush pending updates to objects and queries.\n   * @default false\n   */\n  updates?: boolean;\n};\n\n/**\n * Identifier denoting an ECHO Database.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Database');\nexport type TypeId = typeof TypeId;\n\n/**\n * ECHO Database interface.\n */\nexport interface Database extends Queryable {\n  readonly [TypeId]: TypeId;\n\n  get spaceId(): SpaceId;\n\n  // TODO(burdon): Can we move this into graph?\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  get graph(): Hypergraph.Hypergraph;\n\n  toJSON(): object;\n\n  /**\n   * Return object by local ID.\n   */\n  getObjectById<T extends Obj.Unknown = Obj.OfShape<AnyProperties>>(\n    id: string,\n    opts?: GetObjectByIdOptions,\n  ): T | undefined;\n\n  /**\n   * Query objects.\n   */\n  query: 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<T>;\n\n  /**\n   * Adds object to the database.\n   */\n  add<T extends Entity.Unknown = Entity.Unknown>(obj: T, opts?: AddOptions): T;\n\n  /**\n   * Removes object from the database.\n   */\n  // TODO(burdon): Return true if removed (currently throws if not present).\n  remove(obj: Entity.Unknown): void;\n\n  /**\n   * Wait for all pending changes to be saved to disk.\n   * Optionaly waits for changes to be propagated to indexes and event handlers.\n   */\n  flush(opts?: FlushOptions): Promise<void>;\n}\n\nexport const isDatabase = (obj: unknown): obj is Database => {\n  return obj ? typeof obj === 'object' && TypeId in obj && obj[TypeId] === TypeId : false;\n};\n\nexport const Database: Schema.Schema<Database> = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));\n\n/**\n * Effect service tag for Database dependency injection.\n */\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {}\n\n/**\n * Layer that provides a Database service that throws when accessed.\n * Useful as a default layer when no database is available.\n */\nexport const notAvailable = Layer.succeed(Service, {\n  get db(): Database {\n    throw new Error('Database not available');\n  },\n});\n\n/**\n * Creates a Database service instance from a Database.\n */\nexport const makeService = (db: Database): Context.Tag.Service<Service> => {\n  return {\n    get db() {\n      return db;\n    },\n  };\n};\n\n/**\n * Creates a Layer that provides the Database service.\n */\nexport const layer = (db: Database): Layer.Layer<Service> => {\n  return Layer.succeed(Service, makeService(db));\n};\n\n/**\n * Returns the space ID of the database.\n */\nexport const spaceId = Effect.gen(function* () {\n  const { db } = yield* Service;\n  return db.spaceId;\n});\n\n/**\n * Resolves an object by its DXN.\n */\nexport const resolve: {\n  // No type check.\n  (ref: DXN | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n  // Check matches schema.\n  <S extends Type.AnyEntity>(\n    ref: DXN | Ref<any>,\n    schema: S,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n} = (<S extends Type.AnyEntity>(\n  ref: DXN | Ref<any>,\n  schema?: S,\n): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service> =>\n  Effect.gen(function* () {\n    const { db } = yield* Service;\n    const dxn = ref instanceof DXN ? ref : ref.dxn;\n    const object = yield* promiseWithCauseCapture(() =>\n      db.graph\n        .createRefResolver({\n          context: {\n            space: db.spaceId,\n          },\n        })\n        .resolve(dxn),\n    );\n\n    if (!object) {\n      return yield* Effect.fail(new Err.ObjectNotFoundError(dxn));\n    }\n    invariant(!schema || isInstanceOf(schema, object), 'Object type mismatch.');\n    return object as any;\n  }).pipe(Effect.withSpan('Database.resolve'))) as any;\n\n/**\n * Loads an object reference.\n */\nexport const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn('Database.load')(\n  function* (ref) {\n    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());\n    if (!object) {\n      return yield* Effect.fail(new Err.ObjectNotFoundError(ref.dxn));\n    }\n    return object;\n  },\n);\n\n/**\n * Loads an object reference option.\n */\n// TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.\nexport const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(\n  'Database.loadOption',\n)(function* (ref) {\n  const object = yield* load(ref).pipe(Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)));\n\n  return Option.fromNullable(object);\n});\n\n/**\n * Adds an object to the database.\n * @see {@link Database.add}\n */\nexport const add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan('Database.add'));\n\n/**\n * Removes an object from the database.\n * @see {@link Database.remove}\n */\nexport const remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan('Database.remove'));\n\n/**\n * Flushes pending changes to disk.\n * @see {@link Database.flush}\n */\nexport const flush = (opts?: FlushOptions) =>\n  Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(\n    Effect.withSpan('Database.flush'),\n  );\n\n/**\n * Creates a `QueryResult` object that can be subscribed to.\n */\nexport const query: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  Service.pipe(\n    Effect.map(({ db }) => db.query(queryOrFilter as any) as QueryResult.QueryResult<any>),\n    Effect.withSpan('Database.query'),\n  );\n\n/**\n * Executes the query once and returns the results.\n */\nexport const runQuery: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n    Effect.withSpan('Database.runQuery'),\n  );\n\n/**\n * Executes the query once and returns the first result as or None.\n */\nexport const runQueryFirst: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Option.Option<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Option.Option<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(\n    Effect.flatMap((queryResult) =>\n      promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined())),\n    ),\n    Effect.withSpan('Database.runQueryFirst'),\n  );\n\n/**\n * Persists schemas in the database so they replicate to other clients.\n * @see {@link SchemaRegistry.SchemaRegistry.register}\n */\nexport const registerSchema = (\n  input: SchemaRegistry.RegisterSchemaInput[],\n): Effect.Effect<Type.RuntimeType[], never, Service> =>\n  Service.pipe(\n    Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))),\n    Effect.withSpan('Database.registerSchema'),\n  );\n\n/**\n * Creates a schema query result that can be subscribed to.\n */\n// TODO(dmaretskyi): Change API to `yield* Database.querySchema(...).first` and `yield* Database.querySchema(...).schema`.\nexport const schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<QueryResult.QueryResult<SchemaRegistry.ExtractQueryResult<Q>>, never, Service> =>\n  Service.pipe(\n    Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)),\n    Effect.withSpan('Database.schemaQuery'),\n  );\n\n/**\n * Executes a schema query once and returns the results.\n */\nexport const runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<SchemaRegistry.ExtractQueryResult<Q>[], never, Service> =>\n  schemaQuery(schemaQueryOptions).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n  );\n"],
+  "mappings": ";;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAMA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,YAAY;AAGxB,SAASC,+BAA+B;AACxC,SAASC,iBAAiB;AAC1B,SAASC,WAAyB;AAqElC,IAAA,eAAA;AA+DSC,IAAM,SAAOA,uBAAQ,IAAA,qBAAsBA;AAClD,IAAA,aAAA,CAAA,QAAA;AAEF,SAAO,MAAMC,OAAoCC,QAAOC,YAASD,UAAc,OAACE,IAAUC,MAAAA,MAAWD,SAAS;AAE9G;;AAUA,IAAA,UAAA,cAAA,YAAA,6BAAA,EAAA,EAAA;;AAMI,IAAM,eAAU,cAAA,SAAA;EAClB,IAAA,KAAA;AACC,UAAA,IAAA,MAAA,wBAAA;EAEH;;AAKI,IAAIE,cAAK,CAAA,OAAA;;IAET,IAAA,KAAA;AACF,aAAA;IACA;EAEF;;AAKE,IAAA,QAAA,CAAA,OAAA;AAEF,SAAA,cAAA,SAAA,YAAA,EAAA,CAAA;;AAKSA,IAAGC,UAAO,WAAA,aAAA;AAChB,QAAA,EAAA,GAAA,IAAA,OAAA;AAEH,SAAA,GAAA;;AAiBI,IAAMC,UAAMC,CAAAA,KAAAA,WAA2BA,WAAID,aAAG;AAC9C,QAAME,EAAAA,GAAAA,IAAS,OAAOC;cAGhBC,eAAS,MAAA,MAAA,IAAA;iBACPR,OAAUG,wBAAO,MAAA,GAAA,MAAA,kBAAA;IACnB,SAAA;MAEDM,OAAQL,GAAAA;IAGRE;EACH,CAAA,EAAA,QAAO,GAAOI,CAAAA;AAChB,MAAA,CAAA,QAAA;AACAC,WAAWC,OAAUC,YAAAA,IAAaD,oBAAiB,GAAA,CAAA;EACnD;AACCE,YAAKJ,CAAOK,UAAS,aAAA,QAA6B,MAAA,GAAA,yBAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,IAAA,GAAA,MAAA,GAAA,CAAA,2CAAA,yBAAA,EAAA,CAAA;AAEvD,SAAA;;AAMST,IAAQ,OAAA,UAAA,eAAA,EAAA,WAAA,KAAA;QACX,SAAO,OAAOI,wBAAoBM,MAAAA,IAAAA,QAAwBZ,CAAAA;AAC5D,MAAA,CAAA,QAAA;AACA,WAAOE,OAAAA,YAAAA,IAAAA,oBAAAA,IAAAA,GAAAA,CAAAA;EAET;AAEF,SAAA;;AASE,IAAOW,aAAoBX,UAAAA,qBAAAA,EAAAA,WAAAA,KAAAA;AAC1B,QAAA,SAAA,OAAA,KAAA,GAAA,EAAA,KAAA,gBAAA,uBAAA,MAAA,eAAA,MAAA,CAAA,CAAA;AAEH,SAAA,oBAAA,MAAA;;;;;;;;;;;",
+  "names": ["Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "DXN", "obj", "Database", "Schema", "Any", "space", "isDatabase", "db", "spaceId", "dxn", "ref", "object", "promiseWithCauseCapture", "context", "resolve", "Effect", "invariant", "schema", "isInstanceOf", "pipe", "withSpan", "ObjectNotFoundError", "Option"]
+}