@dxos/echo 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/dist/lib/neutral/Relation.mjs

@@ -0,0 +1,90 @@
+import {
+  Meta,
+  Source,
+  Target,
+  Unknown,
+  VersionTypeId,
+  addTag,
+  change,
+  deleteKeys,
+  getDXN,
+  getDatabase,
+  getDescription,
+  getKeys,
+  getLabel,
+  getMeta,
+  getSchema,
+  getSnapshot,
+  getSource,
+  getSourceDXN,
+  getTarget,
+  getTargetDXN,
+  getTypeDXN,
+  getTypename,
+  getValue,
+  isDeleted,
+  isRelation,
+  isSnapshot,
+  isVersion,
+  make,
+  removeTag,
+  setDescription,
+  setLabel,
+  setValue,
+  sort,
+  sortByLabel,
+  sortByTypename,
+  subscribe,
+  toJSON,
+  version
+} from "./chunk-ZWKJ4LZJ.mjs";
+import "./chunk-KGV3QIRX.mjs";
+import "./chunk-W7OP5HGZ.mjs";
+import "./chunk-PP4DNUZU.mjs";
+import "./chunk-M2KVTHZM.mjs";
+import "./chunk-5ELDDYWE.mjs";
+import "./chunk-F7KMHDPJ.mjs";
+import "./chunk-4KG6IGL4.mjs";
+import "./chunk-MXQJZCPY.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  Meta,
+  Source,
+  Target,
+  Unknown,
+  VersionTypeId,
+  addTag,
+  change,
+  deleteKeys,
+  getDXN,
+  getDatabase,
+  getDescription,
+  getKeys,
+  getLabel,
+  getMeta,
+  getSchema,
+  getSnapshot,
+  getSource,
+  getSourceDXN,
+  getTarget,
+  getTargetDXN,
+  getTypeDXN,
+  getTypename,
+  getValue,
+  isDeleted,
+  isRelation,
+  isSnapshot,
+  isVersion,
+  make,
+  removeTag,
+  setDescription,
+  setLabel,
+  setValue,
+  sort,
+  sortByLabel,
+  sortByTypename,
+  subscribe,
+  toJSON,
+  version
+};
+//# sourceMappingURL=Relation.mjs.map

package/dist/lib/neutral/Relation.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/SchemaRegistry.mjs

@@ -0,0 +1,2 @@
+import "./chunk-T6JEFNP6.mjs";
+//# sourceMappingURL=SchemaRegistry.mjs.map

package/dist/lib/neutral/SchemaRegistry.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/Tag.mjs

@@ -0,0 +1,25 @@
+import {
+  Tag,
+  createTagList,
+  findTagByLabel,
+  make,
+  sortTags
+} from "./chunk-GAWKQ5DZ.mjs";
+import "./chunk-T4MPQJ7X.mjs";
+import "./chunk-KGV3QIRX.mjs";
+import "./chunk-W7OP5HGZ.mjs";
+import "./chunk-PP4DNUZU.mjs";
+import "./chunk-M2KVTHZM.mjs";
+import "./chunk-5ELDDYWE.mjs";
+import "./chunk-F7KMHDPJ.mjs";
+import "./chunk-4KG6IGL4.mjs";
+import "./chunk-MXQJZCPY.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  Tag,
+  createTagList,
+  findTagByLabel,
+  make,
+  sortTags
+};
+//# sourceMappingURL=Tag.mjs.map

package/dist/lib/neutral/Tag.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/Type.mjs

@@ -0,0 +1,34 @@
+import {
+  PersistentType,
+  RuntimeType,
+  getDXN,
+  getMeta,
+  getTypename,
+  getVersion,
+  isMutable,
+  isObjectSchema,
+  isRelationSchema,
+  object,
+  relation
+} from "./chunk-T4MPQJ7X.mjs";
+import "./chunk-PP4DNUZU.mjs";
+import "./chunk-M2KVTHZM.mjs";
+import "./chunk-5ELDDYWE.mjs";
+import "./chunk-F7KMHDPJ.mjs";
+import "./chunk-4KG6IGL4.mjs";
+import "./chunk-MXQJZCPY.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  PersistentType,
+  RuntimeType,
+  getDXN,
+  getMeta,
+  getTypename,
+  getVersion,
+  isMutable,
+  isObjectSchema,
+  isRelationSchema,
+  object,
+  relation
+};
+//# sourceMappingURL=Type.mjs.map

package/dist/lib/neutral/Type.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/chunk-4KG6IGL4.mjs

@@ -0,0 +1,67 @@
+// src/internal/types/entity.ts
+import * as Schema from "effect/Schema";
+var KindId = "~@dxos/echo/Kind";
+var SchemaKindId = "~@dxos/echo/SchemaKind";
+var SnapshotKindId = "~@dxos/echo/SnapshotKind";
+var EntityKind = /* @__PURE__ */ (function(EntityKind2) {
+  EntityKind2["Object"] = "object";
+  EntityKind2["Relation"] = "relation";
+  return EntityKind2;
+})({});
+var EntityKindSchema = Schema.Enums(EntityKind);
+var ANY_OBJECT_TYPENAME = "dxos.org/schema/AnyObject";
+var ANY_OBJECT_VERSION = "0.0.0";
+
+// src/internal/annotations/util.ts
+import * as SchemaAST from "effect/SchemaAST";
+import { assertArgument } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var createAnnotationHelper = (id) => {
+  return {
+    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),
+    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),
+    set: (value) => (schema) => schema.annotations({
+      [id]: value
+    })
+  };
+};
+var unwrapOptional = (property) => {
+  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {
+    return property;
+  }
+  return property.type.types[0];
+};
+var makeTypeJsonSchemaAnnotation = (options) => {
+  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), "relationSource");
+  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), "relationTarget");
+  const obj = {
+    // TODO(dmaretskyi): Should this include the version?
+    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),
+    entityKind: options.kind,
+    version: options.version,
+    typename: options.typename
+  };
+  if (options.kind === EntityKind.Relation) {
+    obj.relationSource = {
+      $ref: options.relationSource
+    };
+    obj.relationTarget = {
+      $ref: options.relationTarget
+    };
+  }
+  return obj;
+};
+
+export {
+  KindId,
+  SchemaKindId,
+  SnapshotKindId,
+  EntityKind,
+  EntityKindSchema,
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  createAnnotationHelper,
+  unwrapOptional,
+  makeTypeJsonSchemaAnnotation
+};
+//# sourceMappingURL=chunk-4KG6IGL4.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/types/entity.ts", "../../../src/internal/annotations/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Kinds of entities stored in ECHO: objects and relations.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'dxos.org/schema/AnyObject';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../types';\n\nexport interface AnnotationHelper<T> {\n  /**\n   * Get the annotation value from the schema.\n   */\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  /**\n   * Get the annotation value from the AST.\n   */\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  /**\n   * Set the annotation value on the schema.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\n/**\n * Note: only for system annotations.\n */\n// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S) =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj = {\n    // TODO(dmaretskyi): Should this include the version?\n    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  } as any;\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AAMvB,IAAKC,aAAAA,0BAAAA,aAAAA;;;SAAAA;;AAKL,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC/ClC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAuBb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAAM;;IAEVC,KAAKR,QAAQS,cAAcC,IAAIC,aAAaX,QAAQY,QAAQ,EAAEC,SAAQ;IACtEC,YAAYd,QAAQG;IACpBY,SAASf,QAAQe;IACjBH,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEc,MAAMhB,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAEU,MAAMhB,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "fromTypename", "typename", "toString", "entityKind", "version", "$ref"]
+}

package/dist/lib/neutral/chunk-5ELDDYWE.mjs

@@ -0,0 +1,130 @@
+import {
+  isInstanceOf
+} from "./chunk-F7KMHDPJ.mjs";
+import {
+  ObjectNotFoundError
+} from "./chunk-MXQJZCPY.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Database.ts
+var Database_exports = {};
+__export(Database_exports, {
+  Database: () => Database,
+  Service: () => Service,
+  TypeId: () => TypeId,
+  add: () => add,
+  flush: () => flush,
+  isDatabase: () => isDatabase,
+  layer: () => layer,
+  load: () => load,
+  loadOption: () => loadOption,
+  makeService: () => makeService,
+  notAvailable: () => notAvailable,
+  query: () => query,
+  remove: () => remove,
+  resolve: () => resolve,
+  runQuery: () => runQuery,
+  runSchemaQuery: () => runSchemaQuery,
+  schemaQuery: () => schemaQuery,
+  spaceId: () => spaceId
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { promiseWithCauseCapture } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
+var TypeId = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
+var isDatabase = (obj) => {
+  return obj ? typeof obj === "object" && TypeId in obj && obj[TypeId] === TypeId : false;
+};
+var Database = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));
+var Service = class extends Context.Tag("@dxos/echo/Database/Service")() {
+};
+var notAvailable = Layer.succeed(Service, {
+  get db() {
+    throw new Error("Database not available");
+  }
+});
+var makeService = (db) => {
+  return {
+    get db() {
+      return db;
+    }
+  };
+};
+var layer = (db) => {
+  return Layer.succeed(Service, makeService(db));
+};
+var spaceId = Effect.gen(function* () {
+  const { db } = yield* Service;
+  return db.spaceId;
+});
+var resolve = (ref, schema) => Effect.gen(function* () {
+  const { db } = yield* Service;
+  const dxn = ref instanceof DXN ? ref : ref.dxn;
+  const object = yield* promiseWithCauseCapture(() => db.graph.createRefResolver({
+    context: {
+      space: db.spaceId
+    }
+  }).resolve(dxn));
+  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.'"
+    ]
+  });
+  return object;
+});
+var load = Effect.fn(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) {
+  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 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 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())));
+
+export {
+  TypeId,
+  isDatabase,
+  Database,
+  Service,
+  notAvailable,
+  makeService,
+  layer,
+  spaceId,
+  resolve,
+  load,
+  loadOption,
+  add,
+  remove,
+  flush,
+  query,
+  runQuery,
+  schemaQuery,
+  runSchemaQuery,
+  Database_exports
+};
+//# sourceMappingURL=chunk-5ELDDYWE.mjs.map

package/dist/lib/neutral/chunk-5ELDDYWE.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\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/annotations';\nimport type { Ref } from './internal/ref/ref';\nimport { type AnyProperties } from './internal/types';\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 and Queue.\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 false\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  })) 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(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 * 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(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)));\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)));\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))));\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(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));\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": "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",
+  "names": ["Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "DXN", "TypeId", "Symbol", "for", "isDatabase", "obj", "Database", "Any", "pipe", "filter", "space", "Service", "Tag", "notAvailable", "succeed", "db", "Error", "makeService", "layer", "spaceId", "gen", "resolve", "ref", "schema", "dxn", "DXN", "object", "promiseWithCauseCapture", "graph", "createRefResolver", "context", "fail", "ObjectNotFoundError", "invariant", "isInstanceOf", "load", "fn", "tryLoad", "loadOption", "catchTag", "undefined", "fromNullable", "add", "map", "remove", "flush", "opts", "flatMap", "query", "queryOrFilter", "withSpan", "runQuery", "queryResult", "run", "schemaQuery", "schemaQueryOptions", "schemaRegistry", "runSchemaQuery"]
+}