@dxos/echo 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

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

@@ -0,0 +1,678 @@
+import {
+  EntityKind,
+  KindId,
+  createAnnotationHelper,
+  getStaticTypeSchema
+} from "./chunk-O6BH7EPN.mjs";
+import {
+  EntityNotFoundError
+} from "./chunk-BBFJWWAV.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Database.ts
+var Database_exports = {};
+__export(Database_exports, {
+  Database: () => Database,
+  Service: () => Service,
+  TypeId: () => TypeId2,
+  add: () => add,
+  addType: () => addType,
+  flush: () => flush,
+  isDatabase: () => isDatabase,
+  layer: () => layer,
+  load: () => load,
+  makeService: () => makeService,
+  notAvailable: () => notAvailable,
+  query: () => query,
+  remove: () => remove,
+  resolve: () => resolve,
+  spaceId: () => spaceId
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Effectable from "effect/Effectable";
+import * as Layer from "effect/Layer";
+import * as Option3 from "effect/Option";
+import * as Schema5 from "effect/Schema";
+import { EffectEx } from "@dxos/effect";
+import { invariant as invariant5 } from "@dxos/invariant";
+
+// src/internal/Entity/type-uri.ts
+import * as Schema4 from "effect/Schema";
+import { raise } from "@dxos/debug";
+import { assertArgument as assertArgument3 } from "@dxos/invariant";
+import { DXN as DXN3, EID as EID4, URI as URI3 } from "@dxos/keys";
+
+// src/internal/Annotation/annotations.ts
+import * as Function2 from "effect/Function";
+import * as Option2 from "effect/Option";
+import * as Schema2 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { SchemaEx } from "@dxos/effect";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { DXN, URI } from "@dxos/keys";
+
+// src/internal/common/types/model-symbols.ts
+var ATTR_SELF_URI = "@uri";
+var ATTR_SELF_URI_LEGACY = "@dxn";
+var SelfURIId = /* @__PURE__ */ Symbol.for("@dxos/echo/URI");
+var ATTR_DELETED = "@deleted";
+var ObjectDeletedId = /* @__PURE__ */ Symbol.for("@dxos/echo/Deleted");
+var ObjectVersionId = /* @__PURE__ */ Symbol.for("@dxos/echo/Version");
+var ObjectDatabaseId = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
+var ATTR_RELATION_SOURCE = "@relationSource";
+var RelationSourceId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationSource");
+var RelationSourceDXNId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationSourceDXN");
+var ATTR_RELATION_TARGET = "@relationTarget";
+var RelationTargetId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationTarget");
+var RelationTargetDXNId = /* @__PURE__ */ Symbol.for("@dxos/echo/RelationTargetDXN");
+var MetaId = /* @__PURE__ */ Symbol.for("@dxos/echo/Meta");
+
+// src/internal/common/types/typename.ts
+var ATTR_TYPE = "@type";
+var TypeId = /* @__PURE__ */ Symbol.for("@dxos/echo/Type");
+var SchemaId = /* @__PURE__ */ Symbol.for("@dxos/echo/Schema");
+var ATTR_PARENT = "@parent";
+var ParentId = /* @__PURE__ */ Symbol.for("@dxos/echo/Parent");
+var TypeEntityId = /* @__PURE__ */ Symbol.for("@dxos/echo/TypeEntity");
+var getSchema = (obj) => {
+  if (obj) {
+    return obj[SchemaId];
+  }
+};
+var setSchema = (obj, schema) => {
+  Object.defineProperty(obj, SchemaId, {
+    value: schema,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+var getType = (obj) => {
+  if (obj == null) {
+    return void 0;
+  }
+  return obj[TypeEntityId];
+};
+var setType = (obj, type) => {
+  Object.defineProperty(obj, TypeEntityId, {
+    value: type,
+    writable: false,
+    enumerable: false,
+    configurable: true
+  });
+};
+
+// src/internal/Annotation/dictionary.ts
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+var Key = Schema.String.pipe(Schema.brand("~@dxos/echo/AnnotationKey"));
+var Dictionary = Schema.Record({
+  key: Key,
+  value: Schema.Unknown
+});
+var getDictionary = (values, annotation) => {
+  if (!(annotation.key in values)) {
+    return Option.none();
+  }
+  return Function.pipe(values[annotation.key], Schema.decodeUnknownSync(annotation.schema), Option.some);
+};
+var setDictionary = (values, annotation, value) => {
+  values[annotation.key] = Schema.encodeSync(annotation.schema)(value);
+};
+
+// src/internal/Annotation/annotations.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Annotation/annotations.ts";
+var ANNOTATION_TYPE_ID = "~@dxos/echo/Annotation";
+var FIELD_PATH_ANNOTATION = "path";
+var FieldPath = (path) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
+var TypeIdentifierAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/TypeIdentifier");
+var getTypeIdentifierAnnotation = (schema) => Function2.flow(SchemaAST.getAnnotation(TypeIdentifierAnnotationId), Option2.getOrElse(() => void 0))(schema.ast);
+var getSchemaURI = (schema) => {
+  assertArgument(Schema2.isSchema(schema), "schema", "invalid schema");
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return URI.make(id);
+  }
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (objectAnnotation) {
+    return DXN.make(objectAnnotation.typename, objectAnnotation.version);
+  }
+  return void 0;
+};
+var TypenameSchema = Schema2.String.pipe(Schema2.pattern(/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)$/)).annotations({
+  description: "Fully qualified globally unique typename in reverse-DNS form.",
+  example: "org.dxos.type.message"
+});
+var VersionSchema = Schema2.String.pipe(Schema2.pattern(/^\d+.\d+.\d+$/)).annotations({
+  description: "Semantic version format: `major.minor.patch`",
+  example: "1.0.0"
+});
+var TypeMeta = Schema2.Struct({
+  typename: TypenameSchema,
+  version: VersionSchema
+});
+var TypeAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Type");
+var TypeAnnotation = Schema2.extend(TypeMeta, Schema2.Struct({
+  kind: Schema2.Enums(EntityKind),
+  /**
+   * If this is a relation, the schema of the source object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  sourceSchema: Schema2.optional(DXN.Schema),
+  /**
+   * If this is a relation, the schema of the target object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  targetSchema: Schema2.optional(DXN.Schema)
+}));
+var getTypeAnnotation = (schema) => {
+  assertArgument(schema != null && schema.ast != null, "schema", "invalid schema");
+  return Function2.flow(SchemaAST.getAnnotation(TypeAnnotationId), Option2.getOrElse(() => void 0))(schema.ast);
+};
+var getEntityKind = (schema) => getTypeAnnotation(schema)?.kind;
+var getSchemaTypename = (schema) => getTypeAnnotation(schema)?.typename;
+var getSchemaVersion = (schema) => getTypeAnnotation(schema)?.version;
+var getTypename = (obj) => {
+  const schema = getSchema(obj);
+  if (schema != null) {
+    return getSchemaTypename(schema);
+  } else {
+    const type = obj?.[TypeId];
+    if (DXN.isDXN(type)) {
+      const parsed = DXN.tryMake(type);
+      return parsed && DXN.getName(parsed);
+    }
+    return void 0;
+  }
+};
+var setTypename = (obj, typename) => {
+  assertArgument(typeof typename === "string", "typename", "Invalid type.");
+  Object.defineProperty(obj, TypeId, {
+    value: typename,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+var getTypeURI = (obj) => {
+  if (obj == null) {
+    return void 0;
+  }
+  const type = obj[TypeId];
+  if (type == null) {
+    return void 0;
+  }
+  invariant(URI.isURI(type), "Invalid object.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 158, S: void 0, A: ["URI.isURI(type)", "'Invalid object.'"] });
+  return type;
+};
+var PropertyMetaAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/PropertyMeta");
+var PropertyMeta = (name, value) => {
+  return (self) => {
+    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId];
+    return self.annotations({
+      [PropertyMetaAnnotationId]: {
+        ...existingMeta,
+        [name]: value
+      }
+    });
+  };
+};
+var getPropertyMetaAnnotation = (prop, name) => Function2.pipe(SchemaAST.getAnnotation(PropertyMetaAnnotationId)(prop.type), Option2.map((meta) => meta[name]), Option2.getOrElse(() => void 0));
+var ReferenceAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Reference");
+var ReferenceAnnotation = createAnnotationHelper(ReferenceAnnotationId);
+var SchemaMetaSymbol = /* @__PURE__ */ Symbol.for("@dxos/schema/SchemaMeta");
+var HiddenAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Hidden");
+var HiddenAnnotation = createAnnotationHelper(HiddenAnnotationId);
+var LabelAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Label");
+var LabelAnnotation = createAnnotationHelper(LabelAnnotationId);
+var getLabelWithSchema = (schema, object) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option2.getOrElse(() => [
+    "name"
+  ]));
+  for (const accessor of annotation) {
+    assertArgument(typeof accessor === "string", "accessor", "Label annotation must be a string or an array of strings");
+    const value = SchemaEx.getField(object, accessor);
+    switch (typeof value) {
+      case "string": {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+          return value;
+        }
+        continue;
+      }
+      case "number":
+      case "boolean":
+      case "bigint":
+      case "symbol":
+        return value.toString();
+      case "undefined":
+      case "object":
+      case "function":
+        continue;
+    }
+  }
+  return void 0;
+};
+var setLabelWithSchema = (schema, object, label) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option2.map((field) => field[0]), Option2.getOrElse(() => "name"));
+  object[annotation] = label;
+};
+var DescriptionAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Description");
+var DescriptionAnnotation = createAnnotationHelper(DescriptionAnnotationId);
+var getDescriptionWithSchema = (schema, object) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option2.getOrElse(() => "description"));
+  assertArgument(typeof accessor === "string", "accessor", "Description annotation must be a string");
+  const value = SchemaEx.getField(object, accessor);
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return value.toString();
+    case "undefined":
+    case "object":
+    case "function":
+    default:
+      return void 0;
+  }
+};
+var setDescriptionWithSchema = (schema, object, description) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option2.getOrElse(() => "description"));
+  object[accessor] = description;
+};
+var FormInputAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormInput");
+var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
+var FormInlineAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormInline");
+var FormInlineAnnotation = createAnnotationHelper(FormInlineAnnotationId);
+var FieldLookupAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FieldLookup");
+var GeneratorAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Generator");
+var GeneratorAnnotation = createAnnotationHelper(GeneratorAnnotationId);
+var makeUserAnnotation = (props) => {
+  assertArgument(/^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?){2,}(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)?$/.test(props.id), "id", "Annotation id must be in the FQN format (org.dxos.annotation.example or org.dxos.space.rootCollection).");
+  const annotation = {
+    [ANNOTATION_TYPE_ID]: {
+      _Type: {}
+    },
+    key: props.id,
+    schema: props.schema,
+    get: (schema) => getFromAst(schema.ast, annotation),
+    getFromAst: (ast) => getFromAst(ast, annotation),
+    set: (value) => PropertyMeta(props.id, Schema2.encodeSync(props.schema)(value))
+  };
+  return annotation;
+};
+var IconAnnotationSchema = Schema2.Struct({
+  /**
+  * Phosphor icon name (e.g., 'ph--user--regular', 'ph--cube--regular', 'ph--link--regular ', etc.)
+  */
+  icon: Schema2.String.pipe(Schema2.pattern(/^ph--[a-z-]+--[a-z]+$/)),
+  /**
+  * Color name.
+  *
+  * List of colors:
+  *  - 'red'
+  *  - 'orange'
+  *  - 'amber'
+  *  - 'yellow'
+  *  - 'lime'
+  *  - 'green'
+  *  - 'emerald'
+  *  - 'teal'
+  *  - 'cyan'
+  *  - 'violet'
+  *  - 'purple'
+  *  - 'fuchsia'
+  *  - 'pink'
+  *  - 'rose'
+  */
+  hue: Schema2.optional(Schema2.String)
+});
+var IconAnnotation = makeUserAnnotation({
+  id: "org.dxos.annotation.icon",
+  schema: IconAnnotationSchema
+});
+var IconFromRefAnnotation = makeUserAnnotation({
+  id: "org.dxos.annotation.icon.from-ref",
+  schema: Schema2.String
+});
+var getLabel = (entity, options) => {
+  const schema = getSchema(entity);
+  const label = schema != null ? getLabelWithSchema(schema, entity) : void 0;
+  if (label != null) {
+    return label;
+  }
+  if (options?.fallback === "typename") {
+    return getTypename(entity);
+  }
+  return void 0;
+};
+var setLabel = (entity, label) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setLabelWithSchema(schema, entity, label);
+  }
+};
+var getDescription = (entity) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getDescriptionWithSchema(schema, entity);
+  }
+};
+var getIcon = (entity) => {
+  const schema = getSchema(entity);
+  if (schema == null) {
+    return void 0;
+  }
+  return Option2.getOrUndefined(IconAnnotation.get(schema));
+};
+var setDescription = (entity, description) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setDescriptionWithSchema(schema, entity, description);
+  }
+};
+var getFromAst = (ast, annotation) => {
+  return SchemaAST.getAnnotation(PropertyMetaAnnotationId)(ast).pipe(Option2.flatMap((meta) => Option2.fromNullable(meta[annotation.key])), Option2.map(Schema2.decodeUnknownSync(annotation.schema)));
+};
+
+// src/internal/Entity/api.ts
+import { invariant as invariant4 } from "@dxos/invariant";
+import { DXN as DXN2, EID as EID3, URI as URI2 } from "@dxos/keys";
+import { assumeType as assumeType3 } from "@dxos/util";
+
+// src/internal/Entity/model.ts
+import { invariant as invariant2 } from "@dxos/invariant";
+import { EID, EntityId } from "@dxos/keys";
+import { assumeType } from "@dxos/util";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/model.ts";
+function assertObjectModel(obj) {
+  invariant2(typeof obj === "object" && obj !== null, "Invalid object model: not an object", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 12, S: this, A: ["typeof obj === 'object' && obj !== null", "'Invalid object model: not an object'"] });
+  assumeType(obj);
+  invariant2(EntityId.isValid(obj.id), "Invalid object model: invalid id", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 14, S: this, A: ["EntityId.isValid(obj.id)", "'Invalid object model: invalid id'"] });
+  invariant2(obj[TypeId] === void 0 || typeof obj[TypeId] === "string", "Invalid object model: invalid type", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 15, S: this, A: ["obj[TypeId] === undefined || typeof obj[TypeId] === 'string'", "'Invalid object model: invalid type'"] });
+  invariant2(obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type, "Invalid object model: invalid entity kind", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 16, S: this, A: ["obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type", "'Invalid object model: invalid entity kind'"] });
+  if (obj[KindId] === EntityKind.Relation) {
+    invariant2(EID.isEID(obj[RelationSourceDXNId]), "Invalid object model: invalid relation source", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 18, S: this, A: ["EID.isEID(obj[RelationSourceDXNId])", "'Invalid object model: invalid relation source'"] });
+    invariant2(EID.isEID(obj[RelationTargetDXNId]), "Invalid object model: invalid relation target", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 19, S: this, A: ["EID.isEID(obj[RelationTargetDXNId])", "'Invalid object model: invalid relation target'"] });
+    invariant2(!EID.isEID(obj[RelationSourceId]), "Invalid object model: source pointer is a DXN", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 20, S: this, A: ["!EID.isEID(obj[RelationSourceId])", "'Invalid object model: source pointer is a DXN'"] });
+    invariant2(!EID.isEID(obj[RelationTargetId]), "Invalid object model: target pointer is a DXN", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 21, S: this, A: ["!EID.isEID(obj[RelationTargetId])", "'Invalid object model: target pointer is a DXN'"] });
+  }
+}
+
+// src/internal/Entity/util.ts
+import * as Schema3 from "effect/Schema";
+import { assertArgument as assertArgument2, invariant as invariant3 } from "@dxos/invariant";
+import { EID as EID2, EntityId as EntityId2 } from "@dxos/keys";
+import { assumeType as assumeType2 } from "@dxos/util";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/util.ts";
+var getObjectEchoUri = (object) => {
+  invariant3(!Schema3.isSchema(object), "schema not allowed in this function", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 14, S: void 0, A: ["!Schema.isSchema(object)", "'schema not allowed in this function'"] });
+  assertArgument2(typeof object === "object" && object != null, "object", "expected object");
+  assumeType2(object);
+  if (object[SelfURIId]) {
+    invariant3(EID2.isEID(object[SelfURIId]), "Invalid object model: invalid self dxn", { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 18, S: void 0, A: ["EID.isEID(object[SelfURIId])", "'Invalid object model: invalid self dxn'"] });
+    return EID2.parse(object[SelfURIId]);
+  }
+  if (!EntityId2.isValid(object.id)) {
+    throw new TypeError("Object id is not valid.");
+  }
+  return EID2.make({
+    entityId: object.id
+  });
+};
+
+// src/internal/Entity/api.ts
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/api.ts";
+var getUri = (entity, options) => {
+  const prefer = options?.prefer;
+  if (prefer === "named") {
+    const key = entity[MetaId]?.key;
+    if (key) {
+      return DXN2.tryMake(`dxn:${key}`) ?? URI2.make(key);
+    }
+    const uri2 = getObjectEchoUri(entity);
+    invariant4(uri2 != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 21, S: void 0, A: ["uri != null", "'Invalid entity.'"] });
+    return uri2;
+  }
+  if (prefer === "relative") {
+    const eid = getObjectEchoUri(entity);
+    invariant4(eid != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 26, S: void 0, A: ["eid != null", "'Invalid entity.'"] });
+    const entityId = EID3.getEntityId(eid);
+    return entityId ? EID3.make({
+      entityId
+    }) : eid;
+  }
+  if (prefer === "absolute") {
+    const eid = getObjectEchoUri(entity);
+    invariant4(eid != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 34, S: void 0, A: ["eid != null", "'Invalid entity.'"] });
+    const entityId = EID3.getEntityId(eid);
+    if (!entityId) {
+      return eid;
+    }
+    assumeType3(entity);
+    const spaceId2 = entity[ObjectDatabaseId]?.spaceId ?? EID3.getSpaceId(eid);
+    return spaceId2 ? EID3.make({
+      spaceId: spaceId2,
+      entityId
+    }) : eid;
+  }
+  const uri = getObjectEchoUri(entity);
+  invariant4(uri != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 47, S: void 0, A: ["uri != null", "'Invalid entity.'"] });
+  return uri;
+};
+var getDatabase = (entity) => {
+  assumeType3(entity);
+  return entity[ObjectDatabaseId];
+};
+
+// src/internal/Entity/type-uri.ts
+var getTypeURIFromSpecifier = (input) => {
+  if (Schema4.isSchema(input)) {
+    return getSchemaURI(input) ?? raise(new TypeError("Schema has no URI"));
+  }
+  if (typeof input === "object" && input !== null && KindId in input) {
+    const schema = getStaticTypeSchema(input);
+    if (schema != null) {
+      const uri = getSchemaURI(schema);
+      if (uri != null) {
+        return uri;
+      }
+    }
+    return getUri(input);
+  }
+  assertArgument3(EID4.isEID(input) || DXN3.isDXN(input), "input", "expected a type URI (EID or DXN)");
+  return input;
+};
+var isInstanceOf = (schemaOrType, object) => {
+  if (object == null) {
+    return false;
+  }
+  const schemaURI = getTypeURIFromSpecifier(schemaOrType);
+  const type = object[TypeId];
+  if (URI3.isURI(type) && type === schemaURI) {
+    return true;
+  }
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+  if (!DXN3.isDXN(schemaURI)) {
+    return false;
+  }
+  const parsed = DXN3.tryMake(schemaURI);
+  return parsed != null && DXN3.getName(parsed) === typename;
+};
+
+// src/Database.ts
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
+var TypeId2 = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
+var isDatabase = (obj) => {
+  return obj ? typeof obj === "object" && TypeId2 in obj && obj[TypeId2] === TypeId2 : false;
+};
+var Database = Schema5.Any.pipe(Schema5.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 = typeof ref === "string" ? ref : ref.uri;
+  const object = yield* EffectEx.promiseWithCauseCapture(() => db.graph.createRefResolver({
+    context: {
+      space: db.spaceId
+    }
+  }).resolve(dxn));
+  if (!object) {
+    return yield* Effect.fail(new EntityNotFoundError(dxn));
+  }
+  invariant5(!schema || isInstanceOf(schema, object), "Object type mismatch.", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 71, S: this, A: ["!schema || isInstanceOf(schema, object)", "'Object type mismatch.'"] });
+  return object;
+}).pipe(Effect.withSpan("Database.resolve"));
+var load = Effect.fn("Database.load")(function* (ref) {
+  const object = yield* EffectEx.promiseWithCauseCapture(() => ref.tryLoad());
+  if (!object) {
+    return yield* Effect.fail(new EntityNotFoundError(ref.uri));
+  }
+  return object;
+});
+var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan("Database.add"));
+var addType = (type) => Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.addType(type)))).pipe(Effect.withSpan("Database.addType"));
+var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan("Database.remove"));
+var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.flush(opts)))).pipe(Effect.withSpan("Database.flush"));
+var query = (queryOrFilter) => Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Database.query"), makeQueryResultEffect);
+var makeQueryResultEffect = (eff) => {
+  return {
+    run: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(() => result.run())),
+    first: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(async () => Option3.fromNullable(await result.firstOrUndefined()))),
+    // Effect internals
+    ...Effectable.CommitPrototype,
+    commit() {
+      return eff;
+    }
+  };
+};
+
+export {
+  Key,
+  Dictionary,
+  getDictionary,
+  setDictionary,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
+  SelfURIId,
+  ATTR_DELETED,
+  ObjectDeletedId,
+  ObjectVersionId,
+  ObjectDatabaseId,
+  ATTR_RELATION_SOURCE,
+  RelationSourceId,
+  RelationSourceDXNId,
+  ATTR_RELATION_TARGET,
+  RelationTargetId,
+  RelationTargetDXNId,
+  MetaId,
+  ATTR_TYPE,
+  TypeId,
+  SchemaId,
+  ATTR_PARENT,
+  ParentId,
+  TypeEntityId,
+  getSchema,
+  setSchema,
+  getType,
+  setType,
+  FIELD_PATH_ANNOTATION,
+  FieldPath,
+  TypeIdentifierAnnotationId,
+  getTypeIdentifierAnnotation,
+  getSchemaURI,
+  TypenameSchema,
+  VersionSchema,
+  TypeMeta,
+  TypeAnnotationId,
+  TypeAnnotation,
+  getTypeAnnotation,
+  getEntityKind,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypename,
+  setTypename,
+  getTypeURI,
+  PropertyMetaAnnotationId,
+  PropertyMeta,
+  getPropertyMetaAnnotation,
+  ReferenceAnnotationId,
+  ReferenceAnnotation,
+  SchemaMetaSymbol,
+  HiddenAnnotationId,
+  HiddenAnnotation,
+  LabelAnnotationId,
+  LabelAnnotation,
+  getLabelWithSchema,
+  setLabelWithSchema,
+  DescriptionAnnotationId,
+  DescriptionAnnotation,
+  getDescriptionWithSchema,
+  setDescriptionWithSchema,
+  FormInputAnnotationId,
+  FormInputAnnotation,
+  FormInlineAnnotationId,
+  FormInlineAnnotation,
+  FieldLookupAnnotationId,
+  GeneratorAnnotationId,
+  GeneratorAnnotation,
+  makeUserAnnotation,
+  IconAnnotation,
+  IconFromRefAnnotation,
+  getLabel,
+  setLabel,
+  getDescription,
+  getIcon,
+  setDescription,
+  getFromAst,
+  assertObjectModel,
+  getObjectEchoUri,
+  getUri,
+  getDatabase,
+  getTypeURIFromSpecifier,
+  isInstanceOf,
+  TypeId2,
+  isDatabase,
+  Database,
+  Service,
+  notAvailable,
+  makeService,
+  layer,
+  spaceId,
+  resolve,
+  load,
+  add,
+  addType,
+  remove,
+  flush,
+  query,
+  Database_exports
+};
+//# sourceMappingURL=chunk-R5W6DXR4.mjs.map