@dxos/echo 0.10.0 → 0.11.1

package/dist/lib/chunk-Database.mjs

@@ -0,0 +1,918 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { g as getStaticTypeSchema, o as EntityKind, t as createAnnotationHelper } from "./chunk-util.mjs";
+import { EntityNotFoundError } from "./Err.mjs";
+import { DXN, EID, EntityId, URI } from "@dxos/keys";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { SchemaEx } from "@dxos/effect";
+import { assumeType } from "@dxos/util";
+import * as Effect from "effect/Effect";
+import { raise } from "@dxos/debug";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as Effectable from "effect/Effectable";
+//#region src/internal/common/types/model-symbols.ts
+/**
+* Internal symbol/string constants for the echo object model.
+* Defined in common/ so proxy/ can use them without importing from Entity/.
+* Entity/ re-exports these for external consumers.
+*/
+/**
+* Property name for the object's own URI when serialized to JSON.
+*/
+var ATTR_SELF_URI = "@uri";
+/**
+* @deprecated Legacy JSON property name accepted on read for backward compat.
+*/
+var ATTR_SELF_URI_LEGACY = "@dxn";
+/**
+* Symbol carrying the object's own URI on live entities.
+*/
+var SelfURIId = Symbol.for("@dxos/echo/URI");
+/**
+* Property name for deleted when object is serialized to JSON.
+*/
+var ATTR_DELETED = "@deleted";
+/**
+* Deletion marker.
+*/
+var ObjectDeletedId = Symbol.for("@dxos/echo/Deleted");
+/**
+* Object version accessor symbol.
+*/
+var ObjectVersionId = Symbol.for("@dxos/echo/Version");
+/**
+* Object database accessor symbol.
+*/
+var ObjectDatabaseId = Symbol.for("@dxos/echo/Database");
+/**
+* Branch accessor symbol. Resolves to the branch name this object instance is bound to (`'main'` for
+* the canonical object, or the branch of a `db.branch()` independent instance). Read via `Obj.getBranch`.
+*/
+var ObjectBranchId = Symbol.for("@dxos/echo/Branch");
+/**
+* Property name for relation source when object is serialized to JSON.
+*/
+var ATTR_RELATION_SOURCE = "@relationSource";
+/**
+* Used to access relation source ref on live ECHO objects.
+*/
+var RelationSourceId = Symbol.for("@dxos/echo/RelationSource");
+/**
+* Used to access relation source DXN on live ECHO objects.
+*/
+var RelationSourceDXNId = Symbol.for("@dxos/echo/RelationSourceDXN");
+/**
+* Property name for relation target when object is serialized to JSON.
+*/
+var ATTR_RELATION_TARGET = "@relationTarget";
+/**
+* Used to access relation target ref on live ECHO objects.
+*/
+var RelationTargetId = Symbol.for("@dxos/echo/RelationTarget");
+/**
+* Used to access relation target DXN on live ECHO objects.
+*/
+var RelationTargetDXNId = Symbol.for("@dxos/echo/RelationTargetDXN");
+/**
+* Symbol carrying the entity metadata (EntityMeta) on live ECHO entities.
+* Must be importable by both meta.ts (which depends on the Ref schema) and
+* Entity/api.ts (which is transitively imported by the Ref schema), so it
+* cannot live in either of those files without creating an import cycle.
+*/
+var MetaId = Symbol.for("@dxos/echo/Meta");
+//#endregion
+//#region src/internal/common/types/typename.ts
+/**
+* Property name for typename when object is serialized to JSON.
+*/
+var ATTR_TYPE = "@type";
+/**
+* DXN to the object type.
+*/
+var TypeId$1 = Symbol.for("@dxos/echo/Type");
+/**
+* Reference to the object schema.
+*/
+var SchemaId = Symbol.for("@dxos/echo/Schema");
+/**
+* Property name for parent when object is serialized to JSON.
+*/
+var ATTR_PARENT = "@parent";
+/**
+* Reference to the object parent.
+*/
+var ParentId = Symbol.for("@dxos/echo/Parent");
+/**
+* Reference to the object's type entity (`Type.Obj`, `Type.Relation`, or
+* `Type.Type`). Set at instance creation by `createObject` / `makeObject`
+* when the entity is known. Public read-back via `Obj.getType` / `Relation.getType`
+* / `Entity.getType`.
+*/
+var TypeEntityId = Symbol.for("@dxos/echo/TypeEntity");
+/**
+* Returns the Effect Schema for the given object if one is defined.
+*
+* @internal
+* Internal callers needing schema-side validation read from `SchemaId`.
+* Public callers should use `Type.getSchema(Obj.getType(obj))` instead.
+*/
+var getSchema = (obj) => {
+	if (obj) return obj[SchemaId];
+};
+/**
+* @internal
+*/
+var setSchema = (obj, schema) => {
+	Object.defineProperty(obj, SchemaId, {
+		value: schema,
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+};
+/**
+* Returns the type entity (`Type.AnyEntity`) for the given instance.
+* Set at instance creation; every entity has a type. Defensive: returns
+* undefined for null/undefined input so callers can safely probe arbitrary
+* values via this helper.
+*
+* @internal Re-exported via `Obj.getType` / `Relation.getType` / `Entity.getType`.
+*/
+var getType = (obj) => {
+	if (obj == null) return;
+	return obj[TypeEntityId];
+};
+/**
+* @internal
+*/
+var setType = (obj, type) => {
+	Object.defineProperty(obj, TypeEntityId, {
+		value: type,
+		writable: false,
+		enumerable: false,
+		configurable: true
+	});
+};
+//#endregion
+//#region src/internal/Annotation/annotations.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Annotation/annotations.ts";
+var ANNOTATION_TYPE_ID = "~@dxos/echo/Annotation";
+/**
+* @internal
+*/
+var FIELD_PATH_ANNOTATION = "path";
+/**
+* Sets the path for the field.
+* @param path Data source path in the json path format. This is the field path in the source object.
+*/
+var FieldPath = (path) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
+/**
+* ECHO identifier (for a stored schema).
+* Must be an `echo:` URI.
+*/
+var TypeIdentifierAnnotationId = Symbol.for("@dxos/schema/annotation/TypeIdentifier");
+var getTypeIdentifierAnnotation = (schema) => Function.flow(SchemaAST.getAnnotation(TypeIdentifierAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+/**
+* @returns The schema's type identifier URI — whichever URI fits.
+*
+* - Stored (dynamic) schemas: the schema-as-object's EID, so loaded objects ride
+*   along with their schema as a strong dependency.
+* - Non-stored (static) schemas: the typename DXN built from `TypeAnnotation`.
+*
+* This URI is what gets written to an object's `system.type`; queries that filter by
+* type also use it (see `Filter.type` / `getTypeURIFromSpecifier`), so both sides
+* stay symmetric without per-schema branching.
+*/
+var getSchemaURI = (schema) => {
+	assertArgument(Schema.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);
+};
+/**
+* Fully qualified globally unique typename.
+* Example: `org.dxos.type.message`
+*/
+var TypenameSchema = Schema.String.pipe(Schema.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"
+});
+/**
+* Semantic version format: `major.minor.patch`
+* Example: `1.0.0`
+*/
+var VersionSchema = Schema.String.pipe(Schema.pattern(/^\d+.\d+.\d+$/)).annotations({
+	description: "Semantic version format: `major.minor.patch`",
+	example: "1.0.0"
+});
+var TypeMeta = Schema.Struct({
+	typename: TypenameSchema,
+	version: VersionSchema
+});
+/**
+* Entity type.
+*/
+var TypeAnnotationId = Symbol.for("@dxos/schema/annotation/Type");
+/**
+* Payload stored under {@link TypeAnnotationId}.
+*/
+var TypeAnnotation = Schema.extend(TypeMeta, Schema.Struct({
+	kind: Schema.Enums(EntityKind),
+	/**
+	* If this is a relation, the schema of the source object.
+	* Must be present if entity kind is {@link EntityKind.Relation}.
+	*/
+	sourceSchema: Schema.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: Schema.optional(DXN.Schema)
+}));
+/**
+* @returns {@link TypeAnnotation} from a schema.
+* Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.
+*/
+var getTypeAnnotation = (schema) => {
+	assertArgument(schema != null && schema.ast != null, "schema", "invalid schema");
+	return Function.flow(SchemaAST.getAnnotation(TypeAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+};
+/**
+* @returns {@link EntityKind} from a schema.
+*/
+var getEntityKind = (schema) => getTypeAnnotation(schema)?.kind;
+/**
+* @internal
+* @returns Schema typename (without dxn: prefix or version number).
+*/
+var getSchemaTypename = (schema) => getTypeAnnotation(schema)?.typename;
+/**
+* @internal
+* @returns Schema version in semver format.
+*/
+var getSchemaVersion = (schema) => getTypeAnnotation(schema)?.version;
+/**
+* Gets the typename of the object without the version.
+* Returns only the name portion, not the DXN.
+* @example "org.example.type.contact"
+*
+* @internal (use Obj.getTypename)
+*/
+var getTypename = (obj) => {
+	const schema = getSchema(obj);
+	if (schema != null) return getSchemaTypename(schema);
+	else {
+		const type = obj?.[TypeId$1];
+		if (DXN.isDXN(type)) {
+			const parsed = DXN.tryMake(type);
+			return parsed && DXN.getName(parsed);
+		}
+		return;
+	}
+};
+/**
+* @internal (use Type.setTypename)
+*/
+var setTypename = (obj, typename) => {
+	assertArgument(typeof typename === "string", "typename", "Invalid type.");
+	Object.defineProperty(obj, TypeId$1, {
+		value: typename,
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+};
+/**
+* @returns Object type URI — either a typename {@link DXN} or an `echo:` reference to a stored Schema object.
+* @returns undefined if the object has no registered type URI (e.g. unresolved query result).
+* @example `dxn:com.example.type.person:1.0.0`
+* @example `echo:/01KKKG2FHWCMTR0BY00GJSVT1X` (stored schema)
+*
+* @internal (use Obj.getTypeURI)
+*/
+var getTypeURI = (obj) => {
+	if (obj == null) return;
+	const type = obj[TypeId$1];
+	if (type == null) return;
+	invariant(URI.isURI(type), "Invalid object.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 221,
+		S: void 0,
+		A: ["URI.isURI(type)", "'Invalid object.'"]
+	});
+	return type;
+};
+/**
+* PropertyMeta (metadata for dynamic schema properties).
+* For user-defined annotations.
+*/
+var PropertyMetaAnnotationId = Symbol.for("@dxos/schema/annotation/PropertyMeta");
+/**
+* Apply property-level metadata to an Effect schema. Only accepts
+* `Schema.Schema.Any` — apply BEFORE wrapping the schema with
+* `Type.makeObject` / `Type.makeRelation`. To read property meta off a
+* `Type.Type` entity, unwrap it first with `Type.getSchema(entity)`.
+*/
+var PropertyMeta = (name, value) => {
+	return (self) => {
+		const existingMeta = self.ast.annotations[PropertyMetaAnnotationId];
+		return self.annotations({ [PropertyMetaAnnotationId]: {
+			...existingMeta,
+			[name]: value
+		} });
+	};
+};
+var getPropertyMetaAnnotation = (prop, name) => Function.pipe(SchemaAST.getAnnotation(PropertyMetaAnnotationId)(prop.type), Option.map((meta) => meta[name]), Option.getOrElse(() => void 0));
+/**
+* Schema reference.
+*/
+var ReferenceAnnotationId = Symbol.for("@dxos/schema/annotation/Reference");
+var ReferenceAnnotation = createAnnotationHelper(ReferenceAnnotationId);
+/**
+* SchemaMeta.
+*/
+var SchemaMetaSymbol = Symbol.for("@dxos/schema/SchemaMeta");
+/**
+* Identifies a schema as hidden from user-facing surfaces (like dotfiles — visible only via an advanced setting).
+*/
+var HiddenAnnotationId = Symbol.for("@dxos/schema/annotation/Hidden");
+var HiddenAnnotation = createAnnotationHelper(HiddenAnnotationId);
+/**
+* Identifies label property or JSON path expression.
+* Either a string or an array of strings representing field accessors each matched in priority order.
+*/
+var LabelAnnotationId = Symbol.for("@dxos/schema/annotation/Label");
+var LabelAnnotation = createAnnotationHelper(LabelAnnotationId);
+/**
+* Returns the label for a given object based on {@link LabelAnnotationId}.
+* Lower-level version that requires explicit schema parameter.
+* Skips empty strings and whitespace-only strings, continuing to the next field.
+*/
+var getLabelWithSchema = (schema, object) => {
+	const annotation = LabelAnnotation.get(schema).pipe(Option.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":
+				if (value.trim().length > 0) return value;
+				continue;
+			case "number":
+			case "boolean":
+			case "bigint":
+			case "symbol": return value.toString();
+			case "undefined":
+			case "object":
+			case "function": continue;
+		}
+	}
+};
+/**
+* Sets the label for a given object based on {@link LabelAnnotationId}.
+* Lower-level version that requires explicit schema parameter.
+*/
+var setLabelWithSchema = (schema, object, label) => {
+	const annotation = LabelAnnotation.get(schema).pipe(Option.map((field) => field[0]), Option.getOrElse(() => "name"));
+	object[annotation] = label;
+};
+/**
+* Identifies description property or JSON path expression.
+* A string representing field accessor.
+*/
+var DescriptionAnnotationId = Symbol.for("@dxos/schema/annotation/Description");
+var DescriptionAnnotation = createAnnotationHelper(DescriptionAnnotationId);
+/**
+* Returns the description for a given object based on {@link DescriptionAnnotationId}.
+* Lower-level version that requires explicit schema parameter.
+*/
+var getDescriptionWithSchema = (schema, object) => {
+	const accessor = DescriptionAnnotation.get(schema).pipe(Option.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();
+		default: return;
+	}
+};
+/**
+* Sets the description for a given object based on {@link DescriptionAnnotationId}.
+* Lower-level version that requires explicit schema parameter.
+*/
+var setDescriptionWithSchema = (schema, object, description) => {
+	const accessorOpt = DescriptionAnnotation.get(schema);
+	if (Option.isNone(accessorOpt)) return;
+	object[accessorOpt.value] = description;
+};
+/**
+* Identifies if a property should be included in a form or not.
+* By default, all properties are included in forms, so this is opt-out.
+*/
+var FormInputAnnotationId = Symbol.for("@dxos/schema/annotation/FormInput");
+var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
+/**
+* When set on a `Ref` property, the form renders the referenced object's own
+* fields inline (a nested form bound to the target) instead of a picker.
+*/
+var FormInlineAnnotationId = Symbol.for("@dxos/schema/annotation/FormInline");
+var FormInlineAnnotation = createAnnotationHelper(FormInlineAnnotationId);
+/**
+* When set on a `Ref` (or array-of-`Ref`) property, the form OWNS the referenced target(s): "add" creates a
+* new object of the annotation's typename (instead of opening the existing-object picker) and each target is
+* rendered inline — its own fields — like {@link FormInlineAnnotation}. The target typename is carried here
+* (rather than inferred from the element type) so the field can stay `Ref.Ref(Obj.Unknown)` and avoid pulling
+* the target's type (e.g. query-AST-laden `Trigger`) into the schema's emitted declaration.
+*/
+var FormCreateAnnotationId = Symbol.for("@dxos/schema/annotation/FormCreate");
+var FormCreateAnnotation = createAnnotationHelper(FormCreateAnnotationId);
+/**
+* When set on an array property, the form renders it as an ordered,
+* drag-to-reorder list (drag handles per row). Element order is meaningful and
+* user-controllable; reordering rewrites the array.
+*/
+var FormOrderedAnnotationId = Symbol.for("@dxos/schema/annotation/FormOrdered");
+var FormOrderedAnnotation = createAnnotationHelper(FormOrderedAnnotationId);
+/**
+* Annotation carrying one or more named layout DSL templates that control how a
+* form arranges a schema's fields (consumed by `@dxos/react-ui-form`'s
+* `Form.Layout` / `Form.FieldSet`). Callers select a variant by name; the
+* implicit name is `DEFAULT_LAYOUT_NAME` (`'default'`).
+*
+* Templates use a minimal XML grammar. Example:
+*
+*   FormLayoutAnnotation.set({
+*     default: `
+*       <grid cols="2">
+*         <field name="origin"/>
+*         <field name="destination"/>
+*         <field name="provider" span="2"/>
+*       </grid>
+*     `,
+*     card: `
+*       <grid cols="1">
+*         <field name="provider"/>
+*         <field name="number"/>
+*       </grid>
+*     `,
+*   })
+*/
+var FormLayoutAnnotationId = Symbol.for("@dxos/react-ui-form/annotation/Layout");
+var FormLayoutAnnotation = createAnnotationHelper(FormLayoutAnnotationId);
+/** Name used when no explicit form-layout variant is requested. */
+var DEFAULT_LAYOUT_NAME = "default";
+/**
+* Default field to be used on referenced schema to lookup the value.
+*/
+var FieldLookupAnnotationId = Symbol.for("@dxos/schema/annotation/FieldLookup");
+/**
+* Generate test data.
+*/
+var GeneratorAnnotationId = 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, Schema.encodeSync(props.schema)(value))
+	};
+	return annotation;
+};
+/**
+* Icon to render in the UI.
+*/
+var IconAnnotation = makeUserAnnotation({
+	id: "org.dxos.annotation.icon",
+	schema: Schema.Struct({
+		/**
+		* Phosphor icon name (e.g., 'ph--user--regular', 'ph--cube--regular', 'ph--link--regular ', etc.)
+		*/
+		icon: Schema.String.pipe(Schema.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: Schema.optional(Schema.String)
+	})
+});
+/**
+* Indicates that this entity's icon should be resolved from a property whose value is a `Ref`
+* to another entity. Consumers (e.g. graph node builders) resolve the ref target and use that
+* target's schema `IconAnnotation` in place of the static one declared on this schema.
+*
+* Useful for wrapper schemas that delegate their visual identity to a referenced sub-entity
+* (e.g. a generic `Game` whose icon should come from its `variant` ref's typed state).
+*/
+var IconFromRefAnnotation = makeUserAnnotation({
+	id: "org.dxos.annotation.icon.from-ref",
+	schema: Schema.String
+});
+/**
+* Get the label of an entity.
+* Accepts both reactive entities and snapshots.
+*
+* If `options.fallback === 'typename'` and no label is set, returns the
+* entity's typename instead.
+*/
+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);
+};
+/**
+* Set the label of an entity.
+* Must be called within an Obj.update or Relation.update callback.
+*/
+var setLabel = (entity, label) => {
+	const schema = getSchema(entity);
+	if (schema != null) setLabelWithSchema(schema, entity, label);
+};
+/**
+* Returns the primary label property key for an entity.
+* Reads the first accessor from {@link LabelAnnotation}, defaulting to 'name'.
+*/
+var getLabelProperty = (entity) => {
+	const schema = getSchema(entity);
+	if (schema == null) return "name";
+	return LabelAnnotation.get(schema).pipe(Option.flatMap((fields) => Option.fromNullable(fields[0])), Option.getOrElse(() => "name"));
+};
+/**
+* Get the description of an entity.
+* Accepts both reactive entities and snapshots.
+*/
+var getDescription = (entity) => {
+	const schema = getSchema(entity);
+	if (schema != null) return getDescriptionWithSchema(schema, entity);
+};
+/**
+* Get the icon annotation for an entity, resolved via its type-level `IconAnnotation`.
+* Accepts both reactive entities and snapshots.
+*
+* Returns the full `{ icon, hue }` annotation so callers can use both the phosphor icon
+* name and the suggested colour. Callers wanting just the icon name typically write
+* `Obj.getIcon(obj)?.icon ?? 'ph--cube--regular'`.
+*
+* Note: this is the "static" icon from the object's own schema. It does not follow
+* `IconFromRefAnnotation` delegation — call sites needing that (e.g. app-graph node
+* builders) should resolve the ref themselves.
+*/
+var getIcon = (entity) => {
+	const schema = getSchema(entity);
+	if (schema == null) return;
+	return Option.getOrUndefined(IconAnnotation.get(schema));
+};
+/**
+* Set the description of an entity.
+* Must be called within an Obj.update or Relation.update callback.
+*/
+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(Option.flatMap((meta) => Option.fromNullable(meta[annotation.key])), Option.map(Schema.decodeUnknownSync(annotation.schema)));
+};
+//#endregion
+//#region src/internal/Entity/util.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/util.ts";
+/**
+* Returns the EID of an object.
+*
+* @internal
+*/
+var getObjectEchoUri = (object) => {
+	invariant(!Schema.isSchema(object), "schema not allowed in this function", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 19,
+		S: void 0,
+		A: ["!Schema.isSchema(object)", "'schema not allowed in this function'"]
+	});
+	assertArgument(typeof object === "object" && object != null, "object", "expected object");
+	assumeType(object);
+	if (object[SelfURIId]) {
+		invariant(EID.isEID(object[SelfURIId]), "Invalid object model: invalid self dxn", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$2,
+			L: 24,
+			S: void 0,
+			A: ["EID.isEID(object[SelfURIId])", "'Invalid object model: invalid self dxn'"]
+		});
+		return EID.parse(object[SelfURIId]);
+	}
+	if (!EntityId.isValid(object.id)) throw new TypeError("Object id is not valid.");
+	return EID.make({ entityId: object.id });
+};
+//#endregion
+//#region src/internal/Entity/api.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/api.ts";
+/**
+* Get the URI of an entity.
+* Accepts both reactive entities and snapshots.
+*/
+var getUri = (entity, options) => {
+	const prefer = options?.prefer;
+	if (prefer === "named") {
+		const key = entity[MetaId]?.key;
+		if (key) return DXN.tryMake(`dxn:${key}`) ?? URI.make(key);
+		const uri = getObjectEchoUri(entity);
+		invariant(uri != null, "Invalid entity.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 42,
+			S: void 0,
+			A: ["uri != null", "'Invalid entity.'"]
+		});
+		return uri;
+	}
+	if (prefer === "relative") {
+		const eid = getObjectEchoUri(entity);
+		invariant(eid != null, "Invalid entity.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 48,
+			S: void 0,
+			A: ["eid != null", "'Invalid entity.'"]
+		});
+		const entityId = EID.getEntityId(eid);
+		return entityId ? EID.make({ entityId }) : eid;
+	}
+	if (prefer === "absolute") {
+		const eid = getObjectEchoUri(entity);
+		invariant(eid != null, "Invalid entity.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 55,
+			S: void 0,
+			A: ["eid != null", "'Invalid entity.'"]
+		});
+		const entityId = EID.getEntityId(eid);
+		if (!entityId) return eid;
+		assumeType(entity);
+		const spaceId = entity[ObjectDatabaseId]?.spaceId ?? EID.getSpaceId(eid);
+		return spaceId ? EID.make({
+			spaceId,
+			entityId
+		}) : eid;
+	}
+	const uri = getObjectEchoUri(entity);
+	invariant(uri != null, "Invalid entity.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 66,
+		S: void 0,
+		A: ["uri != null", "'Invalid entity.'"]
+	});
+	return uri;
+};
+/**
+* Get the database the entity belongs to.
+* Accepts both reactive entities and snapshots.
+*/
+var getDatabase = (entity) => {
+	assumeType(entity);
+	return entity[ObjectDatabaseId];
+};
+/**
+* Get the branch this entity instance is bound to (`'main'` for the canonical object, or the branch
+* of a `db.branch()` independent instance). Reads the branch off the instance, so two instances of the
+* same object id on different branches report their own branch.
+*/
+var getBranch = (entity) => {
+	assumeType(entity);
+	return entity[ObjectBranchId] ?? "main";
+};
+//#endregion
+//#region src/internal/Entity/type-uri.ts
+/**
+* @param input schema, `Type.Type` entity, or a type URI (an `echo:` EID or a `dxn:` DXN).
+* @return type identifier URI — see {@link getSchemaURI}. A URI is returned verbatim. For a
+* `Type.Type` entity, the URI of the schema it declares, symmetric with what
+* `Obj.make(typeEntity, ...)` stamps on `system.type`: a static declaration resolves to its
+* typename DXN, a persisted entity to its local `echo:/<objectId>`.
+*/
+var getTypeURIFromSpecifier = (input) => {
+	if (Schema.isSchema(input)) return getSchemaURI(input) ?? raise(/* @__PURE__ */ new TypeError("Schema has no URI"));
+	if (input !== null && (typeof input === "object" || typeof input === "function") && "~@dxos/echo/Kind" in input) {
+		const schema = getStaticTypeSchema(input);
+		if (schema != null) {
+			const uri = getSchemaURI(schema);
+			if (uri != null) return uri;
+		}
+		return getUri(input);
+	}
+	assertArgument(EID.isEID(input) || DXN.isDXN(input), "input", "expected a type URI (EID or DXN)");
+	return input;
+};
+/**
+* Checks if the object is an instance of the schema.
+* Only typename is compared, the schema version is ignored.
+*
+* The following cases are considered to mean that the object is an instance of the schema:
+*  - Object was created with this exact schema.
+*  - Object was created with a different version of this schema.
+*  - Object was created with a different schema (maybe dynamic) that has the same typename.
+*/
+var isInstanceOf = (schemaOrType, object) => {
+	if (object == null) return false;
+	const schemaURI = getTypeURIFromSpecifier(schemaOrType);
+	const type = object[TypeId$1];
+	if (URI.isURI(type) && type === schemaURI) return true;
+	const typename = getTypename(object);
+	if (!typename) return false;
+	if (!DXN.isDXN(schemaURI)) return false;
+	const parsed = DXN.tryMake(schemaURI);
+	return parsed != null && DXN.getName(parsed) === typename;
+};
+//#endregion
+//#region src/internal/Query/query-result-effect.ts
+/**
+* Wraps an effect that produces a {@link QueryResult.QueryResult} into a
+* {@link QueryResult.QueryResultEffect}, exposing `.run` and `.first` shorthands that execute the
+* query once. Shared by `Database.query` and `Feed.query` so both surfaces chain identically.
+*/
+var makeQueryResultEffect = (eff) => {
+	return {
+		run: Effect.flatMap(eff, (result) => Effect.promise(() => result.run())),
+		first: Effect.flatMap(eff, (result) => Effect.promise(async () => Option.fromNullable(await result.firstOrUndefined()))),
+		...Effectable.CommitPrototype,
+		commit() {
+			return eff;
+		}
+	};
+};
+//#endregion
+//#region src/Database.ts
+var Database_exports = /* @__PURE__ */ __exportAll({
+	Database: () => Database,
+	Service: () => Service,
+	TypeId: () => TypeId,
+	add: () => add,
+	addType: () => addType,
+	appendToFeed: () => appendToFeed,
+	deleteFromFeed: () => deleteFromFeed,
+	flush: () => flush,
+	getSyncState: () => getSyncState,
+	isDatabase: () => isDatabase,
+	layer: () => layer,
+	load: () => load,
+	makeService: () => makeService,
+	notAvailable: () => notAvailable,
+	query: () => query,
+	remove: () => remove,
+	resolve: () => resolve,
+	spaceId: () => spaceId,
+	subscribeToSyncState: () => subscribeToSyncState
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
+/**
+* Identifier denoting an ECHO Database.
+*/
+var TypeId = 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)));
+/**
+* Effect service tag for Database dependency injection.
+*/
+var Service = class extends Context.Tag("@dxos/echo/Database/Service")() {};
+/**
+* Layer that provides a Database service that throws when accessed.
+* Useful as a default layer when no database is available.
+*/
+var notAvailable = Layer.succeed(Service, { get db() {
+	throw new Error("Database not available");
+} });
+/**
+* Creates a Database service instance from a Database.
+*/
+var makeService = (db) => {
+	return { get db() {
+		return db;
+	} };
+};
+/**
+* Creates a Layer that provides the Database service.
+*/
+var layer = (db) => {
+	return Layer.succeed(Service, makeService(db));
+};
+/**
+* Returns the space ID of the database.
+*/
+var spaceId = Effect.gen(function* () {
+	const { db } = yield* Service;
+	return db.spaceId;
+});
+/**
+* Resolves an object by its DXN.
+*/
+var resolve = ((ref, schema) => Effect.gen(function* () {
+	const { db } = yield* Service;
+	const dxn = typeof ref === "string" ? ref : ref.uri;
+	const object = yield* Effect.promise(() => db.graph.createRefResolver({ context: { space: db.spaceId } }).resolveLegacy(dxn));
+	if (!object) return yield* Effect.fail(new EntityNotFoundError(dxn));
+	invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 408,
+		S: this,
+		A: ["!schema || isInstanceOf(schema as any, object)", "'Object type mismatch.'"]
+	});
+	return object;
+}).pipe(Effect.withSpan("Database.resolve")));
+/**
+* Loads an object reference.
+*
+* Catching not found error:
+*
+* ```ts
+* yield* load(ref).pipe(Effect.catchTag('EntityNotFoundError', () => Effect.succeed(undefined)));
+* ```
+*
+*/
+var load = Effect.fn("Database.load")(function* (ref) {
+	const object = yield* Effect.promise(() => ref.tryLoad());
+	if (!object) return yield* Effect.fail(new EntityNotFoundError(ref.uri));
+	return object;
+});
+/**
+* Adds an object or relation to the database.
+* @see {@link Database.add}
+*/
+var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan("Database.add"));
+/**
+* Persists a Type definition to the database.
+* @see {@link Database.addType}
+*/
+var addType = (type) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.addType(type)))).pipe(Effect.withSpan("Database.addType"));
+/**
+* Removes an object from the database.
+* @see {@link Database.remove}
+*/
+var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan("Database.remove"));
+/**
+* Appends entities to a feed.
+* @see {@link Database.appendToFeed}
+*/
+var appendToFeed = (feed, entities) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.appendToFeed(feed, entities)))).pipe(Effect.withSpan("Database.appendToFeed"));
+/**
+* Removes entities from a feed.
+* @see {@link Database.deleteFromFeed}
+*/
+var deleteFromFeed = (feed, entities) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.deleteFromFeed(feed, entities)))).pipe(Effect.withSpan("Database.deleteFromFeed"));
+/**
+* Flushes pending changes to disk.
+* @see {@link Database.flush}
+*/
+var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.flush(opts)))).pipe(Effect.withSpan("Database.flush"));
+/**
+* Creates a `QueryResult` object that can be subscribed to.
+*/
+var query = (queryOrFilter) => Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Database.query"), makeQueryResultEffect);
+/**
+* Get the current sync state.
+*/
+var getSyncState = (options) => Service.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.getSyncState(options))));
+/**
+* Subscribe to sync state changes.
+*/
+var subscribeToSyncState = (options) => Stream.asyncScoped((emit) => Effect.gen(function* () {
+	const { db } = yield* Service;
+	const cleanup = db.subscribeToSyncState((state) => emit.single(state), options);
+	yield* Effect.addFinalizer(() => Effect.sync(cleanup));
+}));
+//#endregion
+export { ReferenceAnnotation as $, RelationTargetId as $t, FIELD_PATH_ANNOTATION as A, ATTR_PARENT as At, FormLayoutAnnotationId as B, ATTR_DELETED as Bt, getBranch as C, getTypename as Ct, DEFAULT_LAYOUT_NAME as D, setLabel as Dt, getObjectEchoUri as E, setDescriptionWithSchema as Et, FormInlineAnnotation as F, TypeId$1 as Ft, HiddenAnnotation as G, MetaId as Gt, FormOrderedAnnotationId as H, ATTR_RELATION_TARGET as Ht, FormInlineAnnotationId as I, getSchema as It, IconFromRefAnnotation as J, ObjectDeletedId as Jt, HiddenAnnotationId as K, ObjectBranchId as Kt, FormInputAnnotation as L, getType as Lt, FieldPath as M, ParentId as Mt, FormCreateAnnotation as N, SchemaId as Nt, DescriptionAnnotation as O, setLabelWithSchema as Ot, FormCreateAnnotationId as P, TypeEntityId as Pt, PropertyMetaAnnotationId as Q, RelationTargetDXNId as Qt, FormInputAnnotationId as R, setSchema as Rt, isInstanceOf as S, getTypeURI as St, getUri as T, setDescription as Tt, GeneratorAnnotation as U, ATTR_SELF_URI as Ut, FormOrderedAnnotation as V, ATTR_RELATION_SOURCE as Vt, GeneratorAnnotationId as W, ATTR_SELF_URI_LEGACY as Wt, LabelAnnotationId as X, RelationSourceDXNId as Xt, LabelAnnotation as Y, ObjectVersionId as Yt, PropertyMeta as Z, RelationSourceId as Zt, remove as _, getSchemaTypename as _t, add as a, TypeMeta as at, subscribeToSyncState as b, getTypeAnnotation as bt, deleteFromFeed as c, getDescription as ct, isDatabase as d, getFromAst as dt, SelfURIId as en, ReferenceAnnotationId as et, layer as f, getIcon as ft, query as g, getPropertyMetaAnnotation as gt, notAvailable as h, getLabelWithSchema as ht, TypeId as i, TypeIdentifierAnnotationId as it, FieldLookupAnnotationId as j, ATTR_TYPE as jt, DescriptionAnnotationId as k, setTypename as kt, flush as l, getDescriptionWithSchema as lt, makeService as m, getLabelProperty as mt, Database_exports as n, TypeAnnotation as nt, addType as o, TypenameSchema as ot, load as p, getLabel as pt, IconAnnotation as q, ObjectDatabaseId as qt, Service as r, TypeAnnotationId as rt, appendToFeed as s, VersionSchema as st, Database as t, SchemaMetaSymbol as tt, getSyncState as u, getEntityKind as ut, resolve as v, getSchemaURI as vt, getDatabase as w, makeUserAnnotation as wt, getTypeURIFromSpecifier as x, getTypeIdentifierAnnotation as xt, spaceId as y, getSchemaVersion as yt, FormLayoutAnnotation as z, setType as zt };
+
+//# sourceMappingURL=chunk-Database.mjs.map