@dxos/echo 0.10.0 → 0.11.0

package/dist/lib/chunk-internal.mjs

@@ -0,0 +1,2775 @@
+import { a as isEntity, d as ATTR_META, f as EntityMetaSchema, g as getMeta, l as getMetaChecked, t as snapshotForComparison } from "./chunk-atom-snapshot.mjs";
+import { d as SnapshotKindId, f as StaticTypeSchemaSlot, g as getStaticTypeSchema, l as KindId, n as makeTypeJsonSchemaAnnotation, o as EntityKind, u as SchemaKindId } from "./chunk-util.mjs";
+import { $t as RelationTargetId, At as ATTR_PARENT, Bt as ATTR_DELETED, Ct as getTypename, E as getObjectEchoUri, Ft as TypeId, Gt as MetaId, Ht as ATTR_RELATION_TARGET, It as getSchema, Jt as ObjectDeletedId, Lt as getType, Mt as ParentId, Nt as SchemaId, Pt as TypeEntityId, Qt as RelationTargetDXNId, Rt as setSchema, St as getTypeURI, Ut as ATTR_SELF_URI, Vt as ATTR_RELATION_SOURCE, Wt as ATTR_SELF_URI_LEGACY, Xt as RelationSourceDXNId, Y as LabelAnnotation, Yt as ObjectVersionId, Zt as RelationSourceId, _t as getSchemaTypename, bt as getTypeAnnotation, en as SelfURIId, jt as ATTR_TYPE, kt as setTypename, pt as getLabel, q as IconAnnotation, qt as ObjectDatabaseId, rt as TypeAnnotationId, ut as getEntityKind, vt as getSchemaURI, w as getDatabase, xt as getTypeIdentifierAnnotation, zt as setType } from "./chunk-Database.mjs";
+import { C as getProxyTarget, D as normalizeSpliceRange, E as isValidProxyTarget, O as symbolIsProxy, T as isReactiveRecord, _ as ChangeId, f as refFromEncodedReference, g as subscribe, i as RefTypeId, k as symbolReactivePrototype, m as loadRefTarget, n as Ref, p as setRefResolver, v as EventId, w as isProxy, y as createProxy } from "./chunk-ref.mjs";
+import { c as JsonSchemaFields, l as JsonSchemaType, n as toEffectSchema, r as toJsonSchema } from "./chunk-json-schema.mjs";
+import { EncodedReference, EntityStructure, isEncodedReference } from "@dxos/echo-protocol";
+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, failedInvariant, invariant } from "@dxos/invariant";
+import { SchemaEx } from "@dxos/effect";
+import { assumeType, decodeUint8ArrayFromJson, deepMapValues, encodeUint8ArrayToJson, getDeep, isEncodedUint8Array, setDeep, visitValues } from "@dxos/util";
+import * as Effect from "effect/Effect";
+import { Event } from "@dxos/async";
+import { inspectCustom, raise } from "@dxos/debug";
+import * as Atom from "@effect-atom/atom/Atom";
+import * as semver from "semver";
+import * as Match from "effect/Match";
+import * as Result from "@effect-atom/atom/Result";
+//#region src/internal/common/types/base.ts
+/**
+* The raw object should not include the ECHO id, but may include metadata.
+*/
+var RawObject = (schema) => {
+	return Schema.make(SchemaAST.omit(schema.ast, ["id"]));
+};
+//#endregion
+//#region src/internal/common/types/projection.ts
+/**
+* Brand for a query projected to a single scalar property (`Query.project`), consumed by
+* `Filter.in` to build a subquery-membership predicate — an uncorrelated
+* `col IN (SELECT property FROM ...)` semi-join. Defined in common/ (not in Query/) so
+* Filter.ts can recognize the brand without importing Query.ts as a value: Query.ts already
+* imports Filter.ts as a value, so a reverse value import would create a cycle. Both
+* Filter.ts and Query.ts import this shared leaf module instead.
+*
+* A string-literal id (not a `Symbol.for`), matching `FilterTypeId`/`QueryTypeId`/`OrderTypeId` —
+* this lets the sandboxed `query-lite` mirror (which cannot import `@dxos/echo`'s runtime) declare
+* its own local constant with the same literal and construct structurally-compatible objects,
+* the same way it already does for those brands.
+*/
+var ProjectionTypeId = "~@dxos/echo/Query.Projection";
+var isProjection = (value) => typeof value === "object" && value !== null && "~@dxos/echo/Query.Projection" in value;
+var variance = {};
+var makeProjection = (query, property) => ({
+	[ProjectionTypeId]: variance,
+	query,
+	property
+});
+//#endregion
+//#region src/internal/common/types/version.ts
+/**
+* Version type identifier.
+*/
+var VersionTypeId = "~@dxos/echo/VersionTypeId";
+//#endregion
+//#region src/internal/Annotation/sorting.ts
+/**
+* String comparison helper for sorting.
+*/
+var compare = (a, b) => {
+	if (a == null) return b == null ? 0 : 1;
+	if (b == null) return -1;
+	return a.localeCompare(b);
+};
+/**
+* Sort entities by label.
+*/
+var sortByLabel = (a, b) => compare(getLabel(a), getLabel(b));
+/**
+* Sort entities by typename.
+*/
+var sortByTypename = (a, b) => compare(getTypename(a), getTypename(b));
+/**
+* Compose multiple comparators into one.
+* Applies comparators in order until one returns non-zero.
+*/
+var sort = (...comparators) => {
+	return (a, b) => {
+		for (const comparator of comparators) {
+			const result = comparator(a, b);
+			if (result !== 0) return result;
+		}
+		return 0;
+	};
+};
+//#endregion
+//#region src/internal/Entity/model.ts
+var __dxlog_file$11 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/model.ts";
+/**
+* NOTE: Keep as `function` to avoid type inference issues.
+*/
+function assertObjectModel(obj) {
+	invariant(typeof obj === "object" && obj !== null, "Invalid object model: not an object", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$11,
+		L: 107,
+		S: this,
+		A: ["typeof obj === 'object' && obj !== null", "'Invalid object model: not an object'"]
+	});
+	assumeType(obj);
+	invariant(EntityId.isValid(obj.id), "Invalid object model: invalid id", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$11,
+		L: 109,
+		S: this,
+		A: ["EntityId.isValid(obj.id)", "'Invalid object model: invalid id'"]
+	});
+	invariant(obj[TypeId] === void 0 || typeof obj[TypeId] === "string", "Invalid object model: invalid type", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$11,
+		L: 110,
+		S: this,
+		A: ["obj[TypeId] === undefined || typeof obj[TypeId] === 'string'", "'Invalid object model: invalid type'"]
+	});
+	invariant(obj["~@dxos/echo/Kind"] === EntityKind.Object || obj["~@dxos/echo/Kind"] === EntityKind.Relation || obj["~@dxos/echo/Kind"] === EntityKind.Type, "Invalid object model: invalid entity kind", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$11,
+		L: 111,
+		S: this,
+		A: ["obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type", "'Invalid object model: invalid entity kind'"]
+	});
+	if (obj["~@dxos/echo/Kind"] === EntityKind.Relation) {
+		invariant(EID.isEID(obj[RelationSourceDXNId]), "Invalid object model: invalid relation source", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 117,
+			S: this,
+			A: ["EID.isEID(obj[RelationSourceDXNId])", "'Invalid object model: invalid relation source'"]
+		});
+		invariant(EID.isEID(obj[RelationTargetDXNId]), "Invalid object model: invalid relation target", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 118,
+			S: this,
+			A: ["EID.isEID(obj[RelationTargetDXNId])", "'Invalid object model: invalid relation target'"]
+		});
+		invariant(!EID.isEID(obj[RelationSourceId]), "Invalid object model: source pointer is a DXN", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 119,
+			S: this,
+			A: ["!EID.isEID(obj[RelationSourceId])", "'Invalid object model: source pointer is a DXN'"]
+		});
+		invariant(!EID.isEID(obj[RelationTargetId]), "Invalid object model: target pointer is a DXN", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$11,
+			L: 120,
+			S: this,
+			A: ["!EID.isEID(obj[RelationTargetId])", "'Invalid object model: target pointer is a DXN'"]
+		});
+	}
+}
+//#endregion
+//#region src/internal/Query/pretty.ts
+/**
+* Returns a human-readable string representation of a Filter AST.
+*/
+var prettyFilter = (filter) => {
+	switch (filter.type) {
+		case "object": {
+			if (filter.typename === null && (filter.id === void 0 || filter.id.length === 0) && Object.keys(filter.props).length === 0 && (filter.foreignKeys === void 0 || filter.foreignKeys.length === 0) && filter.metaKey !== void 0) return filter.metaVersion !== void 0 ? `Filter.key(${JSON.stringify(filter.metaKey)}, { version: ${JSON.stringify(filter.metaVersion)} })` : `Filter.key(${JSON.stringify(filter.metaKey)})`;
+			const parts = [];
+			if (filter.typename !== null) parts.push(String(filter.typename));
+			if (filter.id !== void 0 && filter.id.length > 0) parts.push(`id: [${filter.id.join(", ")}]`);
+			const propEntries = Object.entries(filter.props);
+			if (propEntries.length > 0) {
+				const propsStr = propEntries.map(([k, v]) => `${k}: ${prettyFilter(v)}`).join(", ");
+				parts.push(`{ ${propsStr} }`);
+			}
+			if (filter.foreignKeys !== void 0 && filter.foreignKeys.length > 0) parts.push(`foreignKeys: [${filter.foreignKeys.map((fk) => JSON.stringify(fk)).join(", ")}]`);
+			if (filter.metaKey !== void 0) parts.push(filter.metaVersion !== void 0 ? `metaKey: ${JSON.stringify(filter.metaKey)} (${filter.metaVersion})` : `metaKey: ${JSON.stringify(filter.metaKey)}`);
+			return parts.length > 0 ? `Filter.type(${parts.join(", ")})` : "Filter.everything()";
+		}
+		case "compare": return `Filter.${filter.operator}(${JSON.stringify(filter.value)})`;
+		case "in": return `Filter.in([${filter.values.map((v) => JSON.stringify(v)).join(", ")}])`;
+		case "in-query": return `Filter.in(${prettyQuery(filter.subquery)}.project(${JSON.stringify(filter.property)}))`;
+		case "contains": return `Filter.contains(${JSON.stringify(filter.value)})`;
+		case "tag": return `Filter.tag(${JSON.stringify(filter.tag)})`;
+		case "range": return `Filter.range(${JSON.stringify(filter.from)}, ${JSON.stringify(filter.to)})`;
+		case "text-search": return filter.searchKind ? `Filter.textSearch(${JSON.stringify(filter.text)}, ${JSON.stringify(filter.searchKind)})` : `Filter.textSearch(${JSON.stringify(filter.text)})`;
+		case "timestamp": return `Filter.${filter.field}.${filter.operator}(${filter.value})`;
+		case "child-of": return `Filter.childOf([${filter.parents.map((p) => JSON.stringify(p)).join(", ")}], { transitive: ${filter.transitive} })`;
+		case "not": return `Filter.not(${prettyFilter(filter.filter)})`;
+		case "and": return `Filter.and(${filter.filters.map(prettyFilter).join(", ")})`;
+		case "or": return `Filter.or(${filter.filters.map(prettyFilter).join(", ")})`;
+	}
+};
+/**
+* Returns a human-readable string representation of a Query AST.
+*/
+var prettyQuery = (query) => {
+	switch (query.type) {
+		case "select": return `Query.select(${prettyFilter(query.filter)})`;
+		case "filter": return `${prettyQuery(query.selection)}.select(${prettyFilter(query.filter)})`;
+		case "reference-traversal": return `${prettyQuery(query.anchor)}.reference(${JSON.stringify(query.property)})`;
+		case "incoming-references": {
+			const args = [];
+			if (query.typename !== null) args.push(String(query.typename));
+			if (query.property !== null) args.push(JSON.stringify(query.property));
+			return `${prettyQuery(query.anchor)}.referencedBy(${args.join(", ")})`;
+		}
+		case "relation": {
+			const method = query.direction === "outgoing" ? "sourceOf" : query.direction === "incoming" ? "targetOf" : "relationOf";
+			const filterStr = query.filter !== void 0 ? prettyFilter(query.filter) : "";
+			return `${prettyQuery(query.anchor)}.${method}(${filterStr})`;
+		}
+		case "relation-traversal": return `${prettyQuery(query.anchor)}.${query.direction}()`;
+		case "hierarchy-traversal": return query.direction === "to-parent" ? `${prettyQuery(query.anchor)}.parent()` : `${prettyQuery(query.anchor)}.children()`;
+		case "union": return `Query.all(${query.queries.map(prettyQuery).join(", ")})`;
+		case "set-difference": return `Query.without(${prettyQuery(query.source)}, ${prettyQuery(query.exclude)})`;
+		case "order": {
+			const orders = query.order.map((o) => {
+				if (o.kind === "natural") return `Order.natural(${JSON.stringify(o.direction)})`;
+				else if (o.kind === "rank") return `Order.rank(${JSON.stringify(o.direction)})`;
+				else if (o.kind === "timestamp") return `Order.${o.field === "updatedAt" ? "updated" : "created"}(${JSON.stringify(o.direction)})`;
+				else return `Order.property(${JSON.stringify(o.property)}, ${JSON.stringify(o.direction)})`;
+			});
+			return `${prettyQuery(query.query)}.orderBy(${orders.join(", ")})`;
+		}
+		case "options": {
+			const opts = query.options;
+			const parts = [];
+			if (opts.deleted !== void 0) parts.push(`deleted: ${JSON.stringify(opts.deleted)}`);
+			if (opts.debugLabel !== void 0) parts.push(`debugLabel: ${JSON.stringify(opts.debugLabel)}`);
+			return `${prettyQuery(query.query)}.options({ ${parts.join(", ")} })`;
+		}
+		case "from":
+			if (query.from._tag === "scope") {
+				if (query.from.scopes.length === 0) return `${prettyQuery(query.query)}.from('all-accessible-spaces')`;
+				const scopeStrs = query.from.scopes.map((scope) => {
+					if (scope._tag === "space") return scope.includeAllFeeds ? `{ space: ${JSON.stringify(scope.spaceId)}, includeAllFeeds: true }` : `{ space: ${JSON.stringify(scope.spaceId)} }`;
+					if (scope._tag === "feed") return `{ feed: ${JSON.stringify(String(scope.feedUri))} }`;
+					return `{ registry: ${JSON.stringify(scope.location)} }`;
+				});
+				return `${prettyQuery(query.query)}.from([${scopeStrs.join(", ")}])`;
+			}
+			return `${prettyQuery(query.query)}.from(${prettyQuery(query.from.query)})`;
+		case "limit": return `${prettyQuery(query.query)}.limit(${query.limit})`;
+		case "skip": return `${prettyQuery(query.query)}.skip(${query.skip})`;
+		case "aggregate": {
+			const aggregates = query.aggregates.map((aggregate) => {
+				const arg = aggregate.kind === "items" ? aggregate.limit !== void 0 ? `{ limit: ${aggregate.limit} }` : "" : aggregate.kind === "count" ? "" : JSON.stringify(aggregate.property);
+				return `${JSON.stringify(aggregate.name)}: Aggregate.${aggregate.kind}(${arg})`;
+			});
+			return `${prettyQuery(query.query)}.aggregate({ ${aggregates.join(", ")} })`;
+		}
+	}
+};
+//#endregion
+//#region src/internal/common/proxy/define-hidden-property.ts
+/**
+* Define a non-enumerable property on an object.
+*/
+var defineHiddenProperty = (object, key, value) => {
+	Object.defineProperty(object, key, {
+		enumerable: false,
+		configurable: true,
+		value
+	});
+};
+//#endregion
+//#region src/internal/Ref/strong-deps.ts
+/**
+* Direct strong-dependency URIs of an entity: the schema (only when stored as an object), the
+* relation source/target, and the parent. Returns URIs (cross-space `echo:` EIDs and queue-item
+* EIDs included); a persisted schema is an `echo:` URI, a static/registry type is a `dxn:` URI.
+*
+* A static/registry type (`dxn:`) is intentionally NOT a strong dep: it is always synchronously
+* available through the registry, so gating on it would needlessly delay surfacing. Only a
+* persisted (db-backed) schema, addressed by an `echo:` URI, must load before its instances.
+*/
+var getStrongDependencyUris = (refs, owningSpaceId) => {
+	const res = [];
+	if (refs.type != null && EID.tryParse(refs.type) != null) res.push(qualifyToSpace(refs.type, owningSpaceId));
+	if (refs.kind === EntityKind.Relation) {
+		if (refs.source != null) res.push(qualifyToSpace(refs.source, owningSpaceId));
+		if (refs.target != null) res.push(qualifyToSpace(refs.target, owningSpaceId));
+	}
+	if (refs.parent != null) res.push(qualifyToSpace(refs.parent, owningSpaceId));
+	return res;
+};
+/**
+* Qualifies a space-less (relative) `echo:` dependency URI with the space of the entity that owns it.
+* Same-space references are persisted relative; resolution needs them absolute to route to a single
+* space. Already-qualified URIs (cross-space) and non-`echo:` URIs (registry `dxn:`) pass through.
+*/
+var qualifyToSpace = (uri, owningSpaceId) => {
+	if (owningSpaceId == null) return uri;
+	const eid = EID.tryParse(uri);
+	if (eid == null || !EID.isLocal(eid)) return uri;
+	const entityId = EID.getEntityId(eid);
+	return entityId != null ? EID.make({
+		spaceId: owningSpaceId,
+		entityId
+	}) : uri;
+};
+/**
+* Direct strong-dependency URIs of a live (decoded) entity — a queue item, cross-space proxy, or
+* snapshot. Reads the reference URIs off the entity's hidden model symbols. ECHO db cores compute
+* the same set from their raw encoded references via {@link getStrongDependencyUris}.
+*/
+var getStrongDependencies = (entity) => {
+	if (entity == null || typeof entity !== "object") return [];
+	const props = entity;
+	const kind = props[RelationSourceDXNId] != null || props[RelationTargetDXNId] != null ? EntityKind.Relation : EntityKind.Object;
+	const parent = props[ParentId];
+	const selfUri = getObjectEchoUri(entity);
+	const owningSpaceId = selfUri != null ? EID.getSpaceId(selfUri) : void 0;
+	return getStrongDependencyUris({
+		kind,
+		type: typeof props[TypeId] === "string" ? props[TypeId] : void 0,
+		source: props[RelationSourceDXNId],
+		target: props[RelationTargetDXNId],
+		parent: parent != null ? getObjectEchoUri(parent) : void 0
+	}, owningSpaceId);
+};
+//#endregion
+//#region src/internal/common/proxy/json-serializer.ts
+var __dxlog_file$10 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/json-serializer.ts";
+/**
+* Attaches a toJSON method to the object for typed serialization.
+*/
+var attachTypedJsonSerializer = (obj) => {
+	if (Object.getOwnPropertyDescriptor(obj, "toJSON")) return;
+	Object.defineProperty(obj, "toJSON", {
+		value: typedJsonSerializer,
+		writable: false,
+		enumerable: false,
+		configurable: true
+	});
+};
+var typedJsonSerializer = function() {
+	const { id, ...rest } = this;
+	const result = { id };
+	if (this[TypeId]) result[ATTR_TYPE] = this[TypeId];
+	if (this[MetaId]) result[ATTR_META] = serializeMeta(this[MetaId]);
+	if (this[SelfURIId]) result[ATTR_SELF_URI] = this[SelfURIId];
+	if (this[RelationSourceDXNId]) {
+		const sourceDXN = this[RelationSourceDXNId];
+		invariant(EID.isEID(sourceDXN), void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 63,
+			S: this,
+			A: ["EID.isEID(sourceDXN)", ""]
+		});
+		result[ATTR_RELATION_SOURCE] = sourceDXN;
+	}
+	if (this[RelationTargetDXNId]) {
+		const targetDXN = this[RelationTargetDXNId];
+		invariant(EID.isEID(targetDXN), void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$10,
+			L: 68,
+			S: this,
+			A: ["EID.isEID(targetDXN)", ""]
+		});
+		result[ATTR_RELATION_TARGET] = targetDXN;
+	}
+	Object.assign(result, serializeData(rest));
+	return result;
+};
+var serializeData = (data) => {
+	return deepMapValues(data, (value, recurse) => {
+		if (Ref.isRef(value)) return value.noInline().encode();
+		if (value instanceof Uint8Array) return encodeUint8ArrayToJson(value);
+		return recurse(value);
+	});
+};
+var serializeMeta = (meta) => {
+	const { tags, annotations, ...rest } = meta;
+	return serializeData({
+		...rest,
+		...tags != null && tags.length > 0 ? { tags } : {},
+		...annotations != null && Object.keys(annotations).length > 0 ? { annotations } : {}
+	});
+};
+//#endregion
+//#region src/internal/common/proxy/event-batch.ts
+/**
+* Simple batching mechanism for EventId emissions.
+* When batch depth > 0, events are collected instead of emitted immediately.
+* When batch depth returns to 0, pending events are emitted.
+*/
+var eventBatchDepth = 0;
+var pendingEventTargets = /* @__PURE__ */ new Set();
+/**
+* Run a callback in a batched context for EventId emissions.
+* Multiple mutations within the batch will only emit one event per target.
+*/
+var batchEvents = (callback) => {
+	eventBatchDepth++;
+	try {
+		callback();
+	} finally {
+		eventBatchDepth--;
+		if (eventBatchDepth === 0) {
+			for (const target of pendingEventTargets) target[EventId]?.emit();
+			pendingEventTargets.clear();
+		}
+	}
+};
+/**
+* Emit an event on a target, respecting batching.
+*/
+var emitEvent = (target) => {
+	if (eventBatchDepth > 0) pendingEventTargets.add(target);
+	else target[EventId]?.emit();
+};
+//#endregion
+//#region src/internal/common/proxy/change-context.ts
+/**
+* Generic change context tracking.
+* Only one object can be in a change context at a time (synchronous changes).
+*
+* This module provides a unified change context mechanism used by both:
+* - TypedReactiveHandler (for non-database objects, using target as key)
+* - EchoReactiveHandler (for database objects, using ObjectCore as key)
+*/
+/**
+* The object currently in a change context.
+* Can be a target object (for typed reactive) or ObjectCore (for database objects).
+*/
+var currentChangeContext = null;
+/**
+* The primary object that has pending notifications, if any.
+* This uses the contextKey (target or ObjectCore).
+*/
+var pendingNotificationKey = null;
+/**
+* Additional objects (owner chain) that need notifications.
+* These are separate from the primary notification because they use EventId directly.
+*/
+var pendingOwnerNotifications = /* @__PURE__ */ new Set();
+/**
+* Enter a change context for the given key.
+* While in a change context, mutations are allowed on the associated object.
+* Nested Obj.update calls are not supported.
+*
+* @param key - The key to enter the change context for (target object or ObjectCore).
+* @returns A cleanup function that exits the change context.
+*/
+var enterChangeContext = (key) => {
+	currentChangeContext = key;
+	return () => {
+		currentChangeContext = null;
+	};
+};
+/**
+* Check if the given key is currently in a change context.
+*
+* @param key - The key to check (target object or ObjectCore).
+* @returns True if the key is in a change context, false otherwise.
+*/
+var isInChangeContext = (key) => {
+	return currentChangeContext === key;
+};
+/**
+* Queue a notification for the given key to be fired when the change context exits.
+*
+* @param key - The key to queue a notification for.
+*/
+var queueNotification = (key) => {
+	if (currentChangeContext === key) pendingNotificationKey = key;
+};
+/**
+* Queue an owner notification. Owner notifications are for objects in the ownership
+* chain that should be notified when a nested object changes.
+* These objects have EventId and emit directly.
+* Skip if the target is already the current change context (to avoid duplicate notifications).
+*
+* @param target - The owner target that has EventId.
+*/
+var queueOwnerNotification = (target) => {
+	if (currentChangeContext !== null && target !== currentChangeContext) pendingOwnerNotifications.add(target);
+};
+/**
+* Check if there are any pending notifications for the given key.
+*
+* @param key - The key to check.
+* @returns True if there are pending notifications, false otherwise.
+*/
+var hasPendingNotifications = (key) => {
+	return pendingNotificationKey === key;
+};
+/**
+* Clear any pending notifications for the given key.
+*
+* @param key - The key to clear notifications for.
+*/
+var clearPendingNotifications = (key) => {
+	if (pendingNotificationKey === key) pendingNotificationKey = null;
+};
+/**
+* Execute a callback within a change context.
+* This is the shared implementation used by both TypedReactiveHandler and EchoReactiveHandler.
+*
+* @param contextKey - The key for the change context (target for typed, ObjectCore for db).
+* @param eventTarget - The object that has the EventId for notifications.
+* @param proxy - The proxy object to pass to the callback.
+* @param callback - The callback to execute with mutations allowed.
+*/
+var executeChange = (contextKey, eventTarget, proxy, callback) => {
+	const exitContext = enterChangeContext(contextKey);
+	try {
+		batchEvents(() => callback(proxy));
+	} finally {
+		exitContext();
+		if (hasPendingNotifications(contextKey)) {
+			clearPendingNotifications(contextKey);
+			eventTarget[EventId]?.emit();
+		}
+		for (const ownerTarget of pendingOwnerNotifications) ownerTarget[EventId]?.emit();
+		pendingOwnerNotifications.clear();
+	}
+};
+//#endregion
+//#region src/internal/common/proxy/errors.ts
+/**
+* Error thrown when attempting to mutate an object outside of an Obj.update() context.
+*/
+var MutationOutsideChangeContextError = class extends Error {
+	constructor(operation, suggestion) {
+		super(`Cannot ${operation} outside of Obj.update(). Use Obj.update(obj, (mutableObj) => { ${suggestion} }) instead.`);
+		this.name = "MutationOutsideChangeContextError";
+	}
+};
+/**
+* Create an error for attempting to set a property outside of a change context.
+*/
+var createPropertySetError = (prop) => {
+	return new MutationOutsideChangeContextError(`modify object property "${String(prop)}"`, `mutableObj.${String(prop)} = value;`);
+};
+/**
+* Create an error for attempting to delete a property outside of a change context.
+*/
+var createPropertyDeleteError = (prop) => {
+	return new MutationOutsideChangeContextError(`delete object property "${String(prop)}"`, `delete mutableObj.${String(prop)};`);
+};
+/**
+* Create an error for attempting to call an array method outside of a change context.
+*/
+var createArrayMethodError = (method) => {
+	return new MutationOutsideChangeContextError(`call array.${method}()`, `mutableObj.array.${method}(...);`);
+};
+//#endregion
+//#region src/internal/common/proxy/ownership.ts
+var __dxlog_file$9 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/ownership.ts";
+/**
+* Symbol to store the owning ECHO object reference on nested JS objects (records).
+* Every nested record is attributed to exactly one ECHO object.
+* This achieves:
+* - No cycles in the object graph (cyclical Refs are still allowed).
+* - No multiple inbound pointers to one record.
+* - Centralized reactivity for entire ECHO object.
+*/
+var EchoOwner = Symbol.for("@dxos/echo/Owner");
+/**
+* Get the raw target from a value, unwrapping proxy if needed.
+*/
+var getRawTarget = (value) => {
+	return isProxy(value) ? getProxyTarget(value) : value;
+};
+/**
+* Get the ECHO object that owns this nested record.
+*
+* The owner is always the raw target object (not a proxy) of the root ECHO object.
+* For example, if you have `echoObject.nested.deep`, both `nested` and `deep`
+* will have their owner set to the raw target of `echoObject`.
+*
+* @param value - The nested record to check (can be a proxy or raw target).
+* @returns The raw target of the owning root ECHO object, or undefined if not owned.
+*/
+var getOwner = (value) => {
+	return value?.[EchoOwner];
+};
+/**
+* Set the owner of a meta object to its parent.
+* This allows meta mutations to respect the parent's change context.
+* @internal
+*/
+var setMetaOwner = (metaTarget, parent) => {
+	defineHiddenProperty(metaTarget, EchoOwner, parent);
+};
+/**
+* Set the ECHO object owner on a value and all its nested records.
+* All nested JS objects point directly to the root ECHO object.
+*
+* @param value - The value to set ownership on (can be a proxy or raw target).
+* @param owner - The raw target of the root ECHO object that will own this value.
+* @param options.visited - Set of already-visited objects to avoid infinite loops.
+* @param options.depth - Current recursion depth (unused, kept for debugging).
+* @param options.allowedPreviousOwner - When reassigning a root ECHO object, its nested structures
+*   are allowed to have this as their previous owner without triggering the invariant.
+*/
+var setOwnerRecursive = (value, owner, options = {}) => {
+	const { visited = /* @__PURE__ */ new Set(), depth = 0, allowedPreviousOwner } = options;
+	if (value == null || typeof value !== "object") return;
+	const actualValue = getRawTarget(value);
+	if (visited.has(actualValue)) return;
+	visited.add(actualValue);
+	const existingOwner = getOwner(actualValue);
+	const isRootEchoObject = EventId in actualValue;
+	let newAllowedPreviousOwner = allowedPreviousOwner;
+	if (isRootEchoObject && depth === 0) newAllowedPreviousOwner = actualValue;
+	if (!isRootEchoObject) invariant(existingOwner == null || existingOwner === owner || existingOwner === newAllowedPreviousOwner, "Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$9,
+		L: 101,
+		S: void 0,
+		A: ["ownershipAllowed", "'Cannot reassign ownership of a nested record to a different ECHO object. Use deep copy first.'"]
+	});
+	defineHiddenProperty(actualValue, EchoOwner, owner);
+	const recursiveOptions = {
+		visited,
+		depth: depth + 1,
+		allowedPreviousOwner: newAllowedPreviousOwner
+	};
+	if (Array.isArray(actualValue)) {
+		for (const item of actualValue) if (isValidProxyTarget(item) || isProxy(item)) setOwnerRecursive(item, owner, recursiveOptions);
+	} else for (const key in actualValue) if (Object.prototype.hasOwnProperty.call(actualValue, key)) {
+		const nested = actualValue[key];
+		if (isValidProxyTarget(nested) || isProxy(nested)) setOwnerRecursive(nested, owner, recursiveOptions);
+	}
+};
+/**
+* Traverse an object graph, calling the visitor on each object.
+* Handles proxy unwrapping and cycle detection.
+*
+* @param value - The value to traverse (can be a proxy or raw target).
+* @param visitor - Called for each object. Return true to stop traversal (early exit).
+* @returns true if the visitor returns true for any object.
+*/
+var traverseObjectGraph = (value, visitor, visited = /* @__PURE__ */ new Set()) => {
+	if (value == null || typeof value !== "object") return false;
+	const actualValue = getRawTarget(value);
+	if (visited.has(actualValue)) return false;
+	visited.add(actualValue);
+	if (visitor(actualValue)) return true;
+	if (Array.isArray(actualValue)) {
+		for (const item of actualValue) if (traverseObjectGraph(item, visitor, visited)) return true;
+	} else for (const key in actualValue) if (Object.prototype.hasOwnProperty.call(actualValue, key)) {
+		if (traverseObjectGraph(actualValue[key], visitor, visited)) return true;
+	}
+	return false;
+};
+/**
+* Check if a value would create a cycle when assigned to a target ECHO object.
+* Returns true if the value (or any nested object) IS the target root.
+*/
+var wouldCreateCycle = (targetRoot, value) => traverseObjectGraph(value, (v) => v === targetRoot);
+/**
+* Check if a value or any of its nested objects has an owner different from the target.
+* Used to determine if deep copy is needed during init.
+*/
+var hasForeignOwner = (value, target) => traverseObjectGraph(value, (v) => {
+	const owner = getOwner(v);
+	if (owner != null && owner !== target) return true;
+	if (EventId in v && v !== target) return true;
+	return false;
+});
+/**
+* Maximum depth for owner chain traversal.
+* This is a defensive measure against malformed circular ownership.
+* Primary cycle detection is handled by wouldCreateCycle() before assignment.
+*/
+var MAX_OWNER_DEPTH = 100;
+/**
+* Get the root ECHO object for a target.
+* Follows the owner chain to find the ultimate root.
+* An object may have EventId (from being created standalone) but if it now
+* has an owner, it's nested and we should use its owner's root instead.
+* @internal
+*/
+var getEchoRoot = (target, depth = 0) => {
+	invariant(depth < MAX_OWNER_DEPTH, "Owner chain too deep - possible circular ownership", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$9,
+		L: 220,
+		S: void 0,
+		A: ["depth < MAX_OWNER_DEPTH", "'Owner chain too deep - possible circular ownership'"]
+	});
+	if ("~@dxos/echo/Kind" in target) return target;
+	const owner = getOwner(target);
+	if (owner) return getEchoRoot(owner, depth + 1);
+	return target;
+};
+/**
+* Notify all owners in the ownership chain.
+* When a nested object changes, its parent should also be notified.
+* This handles the case where a root ECHO object is nested inside another object.
+*/
+var notifyOwnerChain = (target) => {
+	const owner = getOwner(target);
+	if (owner) {
+		queueOwnerNotification(getEchoRoot(owner));
+		notifyOwnerChain(owner);
+	}
+};
+//#endregion
+//#region src/internal/common/proxy/proxy-types.ts
+/**
+* For debug-dumping the data of the object.
+*/
+var objectData = Symbol.for("@dxos/live-object/objectData");
+//#endregion
+//#region src/internal/common/proxy/reactive-array.ts
+/**
+* Check if array mutation is allowed (inside a change context).
+* Throws a descriptive error if not.
+*/
+var checkArrayMutationAllowed = (arr, method) => {
+	const echoRoot = getEchoRoot(isProxy(arr) ? getProxyTarget(arr) : arr);
+	if (!(EventId in echoRoot)) return;
+	if (!isInChangeContext(echoRoot)) throw createArrayMethodError(method);
+};
+/**
+* Extends the native array to make sure that arrays methods are correctly reactive.
+* Enforces that mutations only happen within Obj.update() context.
+*/
+var ReactiveArray = class extends Array {
+	static get [Symbol.species]() {
+		return Array;
+	}
+	static {
+		for (const method of [
+			"push",
+			"pop",
+			"shift",
+			"unshift",
+			"splice",
+			"sort",
+			"reverse"
+		]) Object.defineProperty(this.prototype, method, {
+			enumerable: false,
+			value: function(...args) {
+				checkArrayMutationAllowed(this, method);
+				let result;
+				batchEvents(() => {
+					result = Array.prototype[method].apply(this, args);
+				});
+				return result;
+			}
+		});
+	}
+};
+//#endregion
+//#region src/internal/common/proxy/schema-validator.ts
+var __dxlog_file$8 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/schema-validator.ts";
+var SchemaValidator = class {
+	/**
+	* Recursively check that schema specifies constructions we can handle.
+	* Validates there are no ambiguous discriminated union types.
+	*/
+	static validateSchema(schema) {
+		const visitAll = (nodes) => nodes.forEach((node) => this.validateSchema(Schema.make(node)));
+		if (SchemaAST.isUnion(schema.ast)) {
+			const typeAstList = schema.ast.types.filter((type) => SchemaAST.isTypeLiteral(type));
+			if (typeAstList.length > 1) getTypeDiscriminators(typeAstList);
+			visitAll(typeAstList);
+		} else if (SchemaAST.isTupleType(schema.ast)) visitAll(schema.ast.elements.map((t) => t.type).concat(schema.ast.rest.map((t) => t.type)));
+		else if (SchemaAST.isTypeLiteral(schema.ast)) visitAll(SchemaAST.getPropertySignatures(schema.ast).map((p) => p.type));
+	}
+	static hasTypeAnnotation(rootObjectSchema, property, annotation) {
+		try {
+			let type = this.getPropertySchema(rootObjectSchema, [property]);
+			if (SchemaAST.isTupleType(type.ast)) type = this.getPropertySchema(rootObjectSchema, [property, "0"]);
+			return type.ast.annotations[annotation] != null;
+		} catch {
+			return false;
+		}
+	}
+	static getPropertySchema(rootObjectSchema, propertyPath, getProperty = () => null) {
+		let schema = rootObjectSchema;
+		for (let i = 0; i < propertyPath.length; i++) {
+			const propertyName = propertyPath[i];
+			const tupleAst = unwrapArray(schema.ast);
+			if (tupleAst != null) schema = getArrayElementSchema(tupleAst, propertyName);
+			else {
+				const propertyType = getPropertyType(schema.ast, propertyName.toString(), (propertyName) => getProperty([...propertyPath.slice(0, i), propertyName]));
+				if (propertyType == null) {
+					const indexSignatureType = getIndexSignatureValueType(schema.ast);
+					if (indexSignatureType != null) {
+						schema = Schema.make(indexSignatureType).annotations(indexSignatureType.annotations);
+						continue;
+					}
+					throw new TypeError(`Unknown property: ${formatPropertyPath([...propertyPath.slice(0, i), propertyName])}`);
+				}
+				schema = Schema.make(propertyType).annotations(propertyType.annotations);
+			}
+		}
+		return schema;
+	}
+	/**
+	* Rejects properties not declared on the schema. Types with index signatures allow extra keys.
+	*/
+	static assertExactProperties(schema, value, getProperty = () => void 0, path = []) {
+		if (!isPlainRecord(value)) return;
+		const typeLiteral = resolveTypeLiteral(schema.ast, (propertyName) => getProperty([...path, propertyName]));
+		if (typeLiteral == null) return;
+		const propertySignatures = SchemaAST.getPropertySignatures(typeLiteral);
+		const allowedKeys = new Set(propertySignatures.map((property) => String(property.name)));
+		const indexSignatureType = typeLiteral.indexSignatures[0]?.type;
+		for (const key of Object.keys(value)) {
+			const propertyPath = [...path, key];
+			if (!allowedKeys.has(key)) {
+				if (indexSignatureType == null) throw new TypeError(`Unknown property: ${formatPropertyPath(propertyPath)}`);
+				const indexSchema = Schema.make(indexSignatureType).annotations(indexSignatureType.annotations);
+				this.assertExactProperties(indexSchema, value[key], getProperty, propertyPath);
+				continue;
+			}
+			const propertySignature = propertySignatures.find((property) => String(property.name) === key);
+			invariant(propertySignature, "Property signature must exist.", {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$8,
+				L: 121,
+				S: this,
+				A: ["propertySignature", "'Property signature must exist.'"]
+			});
+			const propertySchema = Schema.make(propertySignature.type).annotations(propertySignature.type.annotations);
+			this.assertExactProperties(propertySchema, value[key], getProperty, propertyPath);
+		}
+	}
+	static getIndexedElementSchema(schema, index) {
+		const arrayAst = unwrapArray(schema.ast);
+		if (arrayAst != null) return getArrayElementSchema(arrayAst, index);
+		const unionAst = unwrapAst(schema.ast, (candidate) => SchemaAST.isUnion(candidate) && candidate.types.some((member) => unwrapArray(member) != null));
+		if (unionAst != null && SchemaAST.isUnion(unionAst)) for (const member of unionAst.types) {
+			const memberArrayAst = unwrapArray(member);
+			if (memberArrayAst != null) return getArrayElementSchema(memberArrayAst, index);
+		}
+		return null;
+	}
+	static getTargetPropertySchema(target, prop) {
+		const schema = target[SchemaId];
+		invariant(schema, "target has no schema", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$8,
+			L: 154,
+			S: this,
+			A: ["schema", "'target has no schema'"]
+		});
+		if (Array.isArray(target)) {
+			if (prop === "length") return Schema.Number;
+			if (typeof prop !== "symbol") {
+				const indexedSchema = this.getIndexedElementSchema(schema, prop);
+				if (indexedSchema != null) return indexedSchema;
+			}
+			if (SchemaAST.isTypeLiteral(schema.ast)) return schema;
+		}
+		if (typeof prop === "number" || typeof prop === "string" && /^\d+$/.test(prop)) {
+			const indexedSchema = this.getIndexedElementSchema(schema, prop);
+			if (indexedSchema != null) return indexedSchema;
+		}
+		const arrayAst = unwrapArray(schema.ast);
+		if (arrayAst != null) return getArrayElementSchema(arrayAst, prop);
+		const propertyType = getPropertyType(schema.ast, prop.toString(), (prop) => target[prop]);
+		if (propertyType == null) {
+			const indexSignatureType = getIndexSignatureValueType(schema.ast);
+			if (indexSignatureType != null) return Schema.make(indexSignatureType).annotations(indexSignatureType.annotations);
+			throw new TypeError(`Unknown property: ${String(prop)}`);
+		}
+		return Schema.make(propertyType).annotations(propertyType.annotations);
+	}
+};
+/**
+* Tuple AST is used both for:
+* fixed-length tuples ([string, number]) in which case AST will be { elements: [Schema.String, Schema.Number] }
+* variable-length arrays (Array<string | number>) in which case AST will be { rest: [Schema.Union(Schema.String, Schema.Number)] }
+*/
+var getArrayElementSchema = (tupleAst, property) => {
+	const elementIndex = typeof property === "number" ? property : typeof property === "string" ? parseInt(property, 10) : NaN;
+	if (Number.isNaN(elementIndex)) {
+		invariant(property === "length", `invalid array property: ${String(property)}`, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$8,
+			L: 212,
+			S: void 0,
+			A: ["property === 'length'", "`invalid array property: ${String(property)}`"]
+		});
+		return Schema.Number;
+	}
+	if (elementIndex < tupleAst.elements.length) {
+		const elementType = tupleAst.elements[elementIndex].type;
+		return Schema.make(elementType).annotations(elementType.annotations);
+	}
+	const restType = tupleAst.rest;
+	return Schema.make(restType[0].type).annotations(restType[0].annotations);
+};
+var flattenUnion = (typeAst) => SchemaAST.isUnion(typeAst) ? typeAst.types.flatMap(flattenUnion) : [typeAst];
+var getProperties = (typeAst, getTargetPropertyFn) => {
+	const typeAstList = flattenUnion(typeAst).filter((type) => SchemaAST.isTypeLiteral(type));
+	if (typeAstList.length === 0) return [];
+	if (typeAstList.length === 1) return SchemaAST.getPropertySignatures(typeAstList[0]);
+	const typeDiscriminators = getTypeDiscriminators(typeAstList);
+	const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
+	const typeIndex = typeDiscriminators.findIndex((p) => targetPropertyValue === p.type.literal);
+	invariant(typeIndex !== -1, "discriminator field not set on target", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$8,
+		L: 243,
+		S: void 0,
+		A: ["typeIndex !== -1", "'discriminator field not set on target'"]
+	});
+	return SchemaAST.getPropertySignatures(typeAstList[typeIndex]);
+};
+var getPropertyType = (ast, propertyName, getTargetPropertyFn) => {
+	if (unwrapAst(ast, (candidate) => SchemaAST.isAnyKeyword(candidate) || SchemaAST.isUnknownKeyword(candidate) || SchemaAST.isObjectKeyword(candidate)) != null) return ast;
+	const typeOrDiscriminatedUnion = unwrapAst(ast, (t) => {
+		return SchemaAST.isTypeLiteral(t) || SchemaAST.isUnion(t) && t.types.some((t) => SchemaAST.isTypeLiteral(t));
+	});
+	if (typeOrDiscriminatedUnion == null) return null;
+	const targetProperty = getProperties(typeOrDiscriminatedUnion, getTargetPropertyFn).find((p) => p.name === propertyName);
+	if (targetProperty != null) return unwrapAst(targetProperty.type);
+	const indexSignatureType = unwrapAst(ast, SchemaAST.isTypeLiteral);
+	if (indexSignatureType && SchemaAST.isTypeLiteral(indexSignatureType) && indexSignatureType.indexSignatures.length > 0) return unwrapAst(indexSignatureType.indexSignatures[0].type);
+	return null;
+};
+var getTypeDiscriminators = (typeAstList) => {
+	const discriminatorPropCandidates = typeAstList.flatMap(SchemaAST.getPropertySignatures).filter((p) => SchemaAST.isLiteral(p.type));
+	const propertyName = discriminatorPropCandidates[0].name;
+	const isValidDiscriminator = discriminatorPropCandidates.every((p) => p.name === propertyName && !p.isOptional);
+	const everyTypeHasDiscriminator = discriminatorPropCandidates.length === typeAstList.length;
+	invariant(isValidDiscriminator && everyTypeHasDiscriminator, "type ambiguity: every type in a union must have a single unique-literal field", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$8,
+		L: 297,
+		S: void 0,
+		A: ["isDiscriminatedUnion", "'type ambiguity: every type in a union must have a single unique-literal field'"]
+	});
+	return discriminatorPropCandidates;
+};
+/**
+* Used to check that rootAst is for a type matching the provided predicate.
+* That's not always straightforward because types of optionality and recursive types.
+* const Task = Schema.Struct({
+*   ...,
+*   previous?: Schema.optional(Schema.suspend(() => Task)),
+* });
+* Here the AST for `previous` field is going to be Union(Suspend(Type), Undefined).
+* SchemaAST.isTypeLiteral(field) will return false, but unwrapAst(field, (ast) => SchemaAST.isTypeLiteral(ast))
+* will return true.
+*/
+var unwrapAst = (rootAst, predicate) => {
+	let ast = rootAst;
+	while (ast != null) {
+		if (predicate?.(ast)) return ast;
+		if (SchemaAST.isUnion(ast)) {
+			const next = ast.types.find((t) => predicate != null && predicate(t) || SchemaAST.isSuspend(t));
+			if (next != null) {
+				ast = next;
+				continue;
+			}
+		}
+		if (SchemaAST.isSuspend(ast)) ast = ast.f();
+		else return predicate == null ? ast : null;
+	}
+	return null;
+};
+var unwrapArray = (ast) => unwrapAst(ast, SchemaAST.isTupleType);
+var getIndexSignatureValueType = (ast) => {
+	const typeLiteral = unwrapAst(ast, SchemaAST.isTypeLiteral);
+	if (typeLiteral == null || !SchemaAST.isTypeLiteral(typeLiteral) || typeLiteral.indexSignatures.length === 0) return null;
+	return unwrapAst(typeLiteral.indexSignatures[0].type);
+};
+var resolveTypeLiteral = (ast, getTargetPropertyFn) => {
+	if (unwrapAst(ast, (candidate) => SchemaAST.isAnyKeyword(candidate) || SchemaAST.isUnknownKeyword(candidate) || SchemaAST.isObjectKeyword(candidate)) != null) return null;
+	const typeOrDiscriminatedUnion = unwrapAst(ast, (type) => {
+		return SchemaAST.isTypeLiteral(type) || SchemaAST.isUnion(type) && type.types.some((member) => SchemaAST.isTypeLiteral(member));
+	});
+	if (typeOrDiscriminatedUnion == null) return null;
+	if (SchemaAST.isTypeLiteral(typeOrDiscriminatedUnion)) return typeOrDiscriminatedUnion;
+	if (!SchemaAST.isUnion(typeOrDiscriminatedUnion)) return null;
+	const typeAstList = typeOrDiscriminatedUnion.types.filter((type) => SchemaAST.isTypeLiteral(type));
+	if (typeAstList.length === 1) return typeAstList[0];
+	const typeDiscriminators = getTypeDiscriminators(typeAstList);
+	const targetPropertyValue = getTargetPropertyFn(String(typeDiscriminators[0].name));
+	const typeIndex = typeDiscriminators.findIndex((property) => targetPropertyValue === property.type.literal);
+	invariant(typeIndex !== -1, "discriminator field not set on target", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$8,
+		L: 393,
+		S: void 0,
+		A: ["typeIndex !== -1", "'discriminator field not set on target'"]
+	});
+	return typeAstList[typeIndex];
+};
+var isPlainRecord = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Uint8Array) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+var formatPropertyPath = (path) => path.map(String).join(".");
+var checkIdNotPresentOnSchema = (schema) => {
+	invariant(SchemaAST.isTypeLiteral(schema.ast), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$8,
+		L: 409,
+		S: void 0,
+		A: ["SchemaAST.isTypeLiteral(schema.ast)", ""]
+	});
+	if (SchemaAST.getPropertySignatures(schema.ast).find((prop) => prop.name === "id") != null) throw new Error("\"id\" property name is reserved");
+};
+//#endregion
+//#region src/internal/common/proxy/typed-handler.ts
+var __dxlog_file$7 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/proxy/typed-handler.ts";
+/**
+* Deep copy a value, handling arrays and nested objects.
+* Preserves ReactiveArray type and hidden properties (SchemaId, TypeId).
+* Does not copy class instances or functions (except ReactiveArray).
+*
+* Note: Cannot use structuredClone because we need to:
+* - Unwrap proxies
+* - Preserve ReactiveArray instances
+* - Copy Symbol-keyed hidden properties (SchemaId, TypeId)
+* - Convert plain arrays to ReactiveArray
+*
+* Performance: O(n) where n is the total number of nested objects/arrays.
+* For large structures, consider using Refs for frequently reassigned subtrees.
+*/
+var deepCopy = (value, visited = /* @__PURE__ */ new Map()) => {
+	if (value == null || typeof value !== "object") return value;
+	const actualValue = getRawTarget(value);
+	if (visited.has(actualValue)) return visited.get(actualValue);
+	if (actualValue instanceof ReactiveArray) {
+		const copy = new ReactiveArray();
+		visited.set(actualValue, copy);
+		for (const item of actualValue) copy.push(deepCopy(item, visited));
+		copyHiddenProperties(actualValue, copy);
+		return copy;
+	}
+	const proto = Object.getPrototypeOf(actualValue);
+	if (proto !== Array.prototype && proto !== null && !isReactiveRecord(actualValue)) return value;
+	if (Array.isArray(actualValue)) {
+		const copy = new ReactiveArray();
+		visited.set(actualValue, copy);
+		for (const item of actualValue) copy.push(deepCopy(item, visited));
+		return copy;
+	}
+	const copy = {};
+	visited.set(actualValue, copy);
+	for (const key of Object.keys(actualValue)) copy[key] = deepCopy(actualValue[key], visited);
+	copyHiddenProperties(actualValue, copy);
+	return copy;
+};
+/**
+* Copy hidden properties (SchemaId, TypeId) from source to target.
+*/
+var copyHiddenProperties = (source, target) => {
+	if (SchemaId in source) defineHiddenProperty(target, SchemaId, source[SchemaId]);
+	if (TypeId in source) defineHiddenProperty(target, TypeId, source[TypeId]);
+};
+/**
+* Behaviour prototype for typed reactive records. A record's per-object metadata is moved onto an
+* intermediate instance-state object whose prototype is this, so that swapping the handler that
+* backs an object (e.g. an in-memory object becoming database-backed) is a prototype re-point that
+* doesn't perturb the target's own-property shape. Marked as a reactive prototype so the "plain
+* object" gates (`isValidProxyTarget` / `deepCopy`) still treat such targets as data records.
+*/
+var TypedObjectPrototype = Object.create(Object.prototype);
+defineHiddenProperty(TypedObjectPrototype, symbolReactivePrototype, true);
+Object.defineProperties(TypedObjectPrototype, {
+	[objectData]: { get() {
+		return toJSON(getRawTarget(this));
+	} },
+	[ChangeId]: { get() {
+		const target = getRawTarget(this);
+		if (!(EventId in target)) return;
+		return (callback) => executeChange(target, target, this, callback);
+	} },
+	[StaticTypeSchemaSlot]: { get() {
+		const target = getRawTarget(this);
+		const jsonSchema = target.jsonSchema;
+		if (jsonSchema == null) return;
+		const rebuilt = toEffectSchema(jsonSchema);
+		defineHiddenProperty(target, StaticTypeSchemaSlot, rebuilt);
+		return rebuilt;
+	} }
+});
+/** True if `prop` resolves to an accessor on the behaviour-prototype chain (not an own property). */
+var isBehaviourAccessor = (target, prop) => {
+	let proto = Object.getPrototypeOf(target);
+	while (proto != null && proto !== Object.prototype) {
+		const descriptor = Object.getOwnPropertyDescriptor(proto, prop);
+		if (descriptor != null) return descriptor.get != null;
+		proto = Object.getPrototypeOf(proto);
+	}
+	return false;
+};
+/**
+* Enforce that user-data mutations only happen inside `Obj.update()`. A root object owns an
+* `EventId` once initialized; before that (and for non-root records or symbol-keyed system
+* properties) mutations pass through. Returns whether the root is initialized so callers can gate
+* change notifications.
+*/
+var assertMutableWithinChange = (echoRoot, prop) => {
+	const isInitialized = EventId in echoRoot;
+	if (isInitialized && typeof prop !== "symbol" && !isInChangeContext(echoRoot)) throw new Error(`Cannot modify object property "${String(prop)}" outside of Obj.update(). Use Obj.update(obj, (mutableObj) => { mutableObj.property = value; }) instead.`);
+	return isInitialized;
+};
+/**
+* Move a record's per-object metadata (symbol-keyed hidden properties) onto a fresh instance-state
+* object inserted between the target and {@link TypedObjectPrototype}. The target keeps only its
+* user data as own properties. Arrays are exempt — they keep their own (ReactiveArray) prototype chain.
+*/
+var compactMetadataToInstanceState = (target) => {
+	if (Array.isArray(target) || Object.getPrototypeOf(target) !== Object.prototype) return;
+	const state = Object.create(TypedObjectPrototype);
+	for (const symbol of Object.getOwnPropertySymbols(target)) {
+		const descriptor = Object.getOwnPropertyDescriptor(target, symbol);
+		Object.defineProperty(state, symbol, descriptor);
+		if (descriptor.configurable) delete target[symbol];
+	}
+	Object.setPrototypeOf(target, state);
+};
+/**
+* Typed in-memory reactive store (with Schema).
+* Reactivity is based on Event subscriptions, not signals.
+*/
+var TypedReactiveHandler = class TypedReactiveHandler {
+	static instance = new TypedReactiveHandler();
+	_proxyMap = /* @__PURE__ */ new WeakMap();
+	_inSet = false;
+	constructor() {}
+	init(target) {
+		assertArgument(typeof target === "object" && target !== null, "target");
+		invariant(SchemaId in target, "Schema is not defined for the target", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$7,
+			L: 296,
+			S: this,
+			A: ["SchemaId in target", "'Schema is not defined for the target'"]
+		});
+		const hasOwner = !!getOwner(target);
+		if (!(EventId in target) && !hasOwner) defineHiddenProperty(target, EventId, new Event());
+		if (!(ObjectDeletedId in target)) defineHiddenProperty(target, ObjectDeletedId, false);
+		if (!hasOwner) for (const key in target) {
+			if (target[symbolIsProxy]) continue;
+			let value = target[key];
+			if (isValidProxyTarget(value) || isProxy(value)) {
+				if (hasForeignOwner(value, target)) {
+					value = deepCopy(value);
+					target[key] = value;
+				}
+				setOwnerRecursive(value, target);
+			}
+		}
+		Object.defineProperty(target, inspectCustom, {
+			enumerable: false,
+			configurable: true,
+			value: this._inspect.bind(target)
+		});
+		compactMetadataToInstanceState(target);
+	}
+	/**
+	* Hide the internal instance-state prototype so consumers see a plain object; arrays keep their
+	* real (ReactiveArray) prototype.
+	*/
+	getPrototypeOf(target) {
+		return Array.isArray(target) ? Reflect.getPrototypeOf(target) : Object.prototype;
+	}
+	get(target, prop, receiver) {
+		if (typeof prop === "symbol" && isBehaviourAccessor(target, prop)) return Reflect.get(target, prop, receiver);
+		if (prop === TypeEntityId) return Reflect.get(target, prop, receiver);
+		if (Object.getOwnPropertyDescriptor(target, prop)?.get) return Reflect.get(target, prop, receiver);
+		const value = Reflect.get(target, prop, receiver);
+		if (isValidProxyTarget(value)) return createProxy(value, this);
+		return value;
+	}
+	set(target, prop, value, receiver) {
+		const echoRoot = getEchoRoot(target);
+		const isInitialized = assertMutableWithinChange(echoRoot, prop);
+		let result = false;
+		this._inSet = true;
+		try {
+			batchEvents(() => {
+				const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, prop, value);
+				result = Reflect.set(target, prop, preparedValue, receiver);
+				if (prop === "jsonSchema") Reflect.deleteProperty(target, StaticTypeSchemaSlot);
+				if (isInitialized) {
+					queueNotification(echoRoot);
+					notifyOwnerChain(target);
+				}
+			});
+		} finally {
+			this._inSet = false;
+		}
+		return result;
+	}
+	ownKeys(target) {
+		return Reflect.ownKeys(target);
+	}
+	deleteProperty(target, property) {
+		const echoRoot = getEchoRoot(target);
+		const isInitialized = EventId in echoRoot;
+		if (isInitialized && !(typeof property === "symbol") && !isInChangeContext(echoRoot)) throw createPropertyDeleteError(property);
+		const result = Reflect.deleteProperty(target, property);
+		if (isInitialized) queueNotification(echoRoot);
+		return result;
+	}
+	defineProperty(target, property, attributes) {
+		const echoRoot = getEchoRoot(target);
+		const isInitialized = assertMutableWithinChange(echoRoot, property);
+		const { echoRoot: _, preparedValue } = this._prepareValueForAssignment(target, property, attributes.value);
+		const result = Reflect.defineProperty(target, property, {
+			...attributes,
+			value: preparedValue
+		});
+		if (!this._inSet && isInitialized) queueNotification(echoRoot);
+		return result;
+	}
+	textUpdate(target, path, newText) {
+		this._applyTextMutation(target, path, () => newText);
+	}
+	textSplice(target, path, start, deleteCount, insert) {
+		let removed = "";
+		this._applyTextMutation(target, path, (current) => {
+			const range = normalizeSpliceRange(current.length, start, deleteCount);
+			removed = current.slice(range.start, range.start + range.deleteCount);
+			return current.slice(0, range.start) + insert + current.slice(range.start + range.deleteCount);
+		});
+		return removed;
+	}
+	/**
+	* Shared read-modify-write for the in-memory string CRDT path. Mirrors the `set` trap: enforce the
+	* change context, then mutate and notify through the same batched notification path so reactivity fires.
+	*
+	* Writes via `setDeep` on the raw target, intentionally bypassing `_prepareValueForAssignment` /
+	* `_validateValue`: a string CRDT delta produces a string, and per-delta schema checks (pattern,
+	* maxLength) would reject valid intermediate states during incremental edits. Such constraints are
+	* enforced at the initial assignment or as application-level invariants, mirroring the Automerge path.
+	*/
+	_applyTextMutation(target, path, compute) {
+		const echoRoot = getEchoRoot(target);
+		if (!isInChangeContext(echoRoot)) throw new Error(`Cannot modify text at "${path.join(".")}" outside of Obj.update(). Use Obj.update(obj, () => { Text.splice(obj, path, ...); }) instead.`);
+		const keyPath = [...path];
+		invariant(keyPath.length > 0, "Text path must be non-empty", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$7,
+			L: 493,
+			S: this,
+			A: ["keyPath.length > 0", "'Text path must be non-empty'"]
+		});
+		const current = getDeep(target, keyPath);
+		if (typeof current !== "string") throw new TypeError(`Text mutation target at "${keyPath.join(".")}" is not a string.`);
+		const next = compute(current);
+		batchEvents(() => {
+			setDeep(target, keyPath, next);
+			queueNotification(echoRoot);
+			notifyOwnerChain(target);
+		});
+	}
+	/**
+	* Prepare a value for assignment to a typed object property.
+	* Handles cycle detection, copy-on-assign, array conversion, validation, and ownership.
+	*/
+	_prepareValueForAssignment(target, prop, value) {
+		const echoRoot = getEchoRoot(target);
+		if (typeof prop === "symbol") return {
+			echoRoot,
+			preparedValue: value
+		};
+		if (isValidProxyTarget(value) || isProxy(value)) {
+			if (wouldCreateCycle(echoRoot, value)) throw new Error("Cannot create cycles in typed object graph. Consider using Ref for circular references.");
+		}
+		if (isValidProxyTarget(value) || isProxy(value)) {
+			if (EventId in getRawTarget(value)) throw new Error("Object references must be wrapped with `Ref.make`");
+		}
+		if (isValidProxyTarget(value) || isProxy(value)) {
+			const existingOwner = getOwner(getRawTarget(value));
+			if (existingOwner != null && existingOwner !== echoRoot) value = deepCopy(value);
+		}
+		if (Array.isArray(value) && !(value instanceof ReactiveArray)) value = ReactiveArray.from(value);
+		const validatedValue = this._validateValue(target, prop, value);
+		if (isValidProxyTarget(validatedValue) || isProxy(validatedValue)) setOwnerRecursive(validatedValue, echoRoot);
+		return {
+			echoRoot,
+			preparedValue: validatedValue
+		};
+	}
+	_validateValue(target, prop, value) {
+		if (prop === ParentId) return value;
+		const schema = SchemaValidator.getTargetPropertySchema(target, prop);
+		Schema.asserts(schema)(value);
+		SchemaValidator.assertExactProperties(schema, value, (path) => getDeep(value, path));
+		if (isValidProxyTarget(value)) setSchemaProperties(value, schema);
+		return value;
+	}
+	_inspect(_, options, inspectFn) {
+		return `Typed ${inspectFn(this, {
+			...options,
+			showHidden: false,
+			customInspect: false
+		})}`;
+	}
+};
+/**
+* @deprecated Use `Obj.toJSON` instead.
+*/
+var toJSON = (target) => {
+	return {
+		"@type": "TypedReactiveObject",
+		...target
+	};
+};
+/**
+* Recursively set AST on all potential proxy targets.
+*
+* @param skipOwnStamp Skip stamping `TypeId`/`SchemaId` on `obj` itself (still recurses into
+*   children, which always get stamped). Used for objects decoded from JSON, whose own `TypeId`/
+*   `SchemaId` are already set by `setTypename`/`setSchema` as `configurable: false` — redefining
+*   them here (with `configurable: true`) would throw.
+*/
+var setSchemaProperties = (obj, schema, typeSource, skipOwnStamp = false) => {
+	if (!skipOwnStamp) {
+		const schemaType = getSchemaURI(schema);
+		if (schemaType != null) defineHiddenProperty(obj, TypeId, schemaType);
+		if (typeSource != null) {
+			defineHiddenProperty(obj, TypeEntityId, typeSource);
+			Object.defineProperty(obj, SchemaId, {
+				get: () => typeSource["~@dxos/echo/Type.StaticSchema"] ?? schema,
+				enumerable: false,
+				configurable: true
+			});
+		} else defineHiddenProperty(obj, SchemaId, schema);
+	}
+	if (Array.isArray(obj)) {
+		for (let index = 0; index < obj.length; index++) if (isValidProxyTarget(obj[index])) {
+			const elementSchema = SchemaValidator.getIndexedElementSchema(schema, index) ?? Schema.Any;
+			setSchemaProperties(obj[index], elementSchema);
+		}
+		return;
+	}
+	for (const key in obj) if (isValidProxyTarget(obj[key])) {
+		let elementSchema;
+		try {
+			elementSchema = SchemaValidator.getTargetPropertySchema(obj, key);
+		} catch {
+			elementSchema = Schema.Any;
+		}
+		setSchemaProperties(obj[key], elementSchema);
+	}
+};
+var prepareTypedTarget = (target, schema, typeSource) => {
+	validateAndReactifyTarget(target, schema);
+	setSchemaProperties(target, schema, typeSource);
+};
+/**
+* Validate a target against its schema and convert nested arrays to `ReactiveArray`. Shared by
+* {@link prepareTypedTarget} and {@link prepareDecodedTypedTarget}.
+*/
+var validateAndReactifyTarget = (target, schema) => {
+	if (!SchemaAST.isTypeLiteral(schema.ast)) throw new Error("schema has to describe an object type");
+	SchemaValidator.validateSchema(schema);
+	Schema.asserts(schema)(target);
+	SchemaValidator.assertExactProperties(schema, target, (path) => getDeep(target, path));
+	makeArraysReactive(target);
+};
+/**
+* Like {@link prepareTypedTarget}, for a target whose own `SchemaId`/`TypeId` are already stamped
+* and locked `configurable: false` — e.g. an object decoded from JSON via `setSchema`/`setTypename`
+* (see `objectFromJSON`). Validates and reactifies as usual, then stamps `SchemaId`/`TypeId` on
+* nested records/arrays only, leaving the target's own (locked) stamps untouched.
+*/
+var prepareDecodedTypedTarget = (target, schema) => {
+	validateAndReactifyTarget(target, schema);
+	setSchemaProperties(target, schema, void 0, true);
+};
+var makeArraysReactive = (target) => {
+	for (const key in target) {
+		if (target[symbolIsProxy]) continue;
+		if (Array.isArray(target[key])) target[key] = ReactiveArray.from(target[key]);
+		if (typeof target[key] === "object") makeArraysReactive(target[key]);
+	}
+};
+//#endregion
+//#region src/internal/common/proxy/make-object.ts
+/**
+* Creates a reactive object from a plain Javascript object.
+* Requires a TS-effect schema.
+*
+* Callers that have a `Type.Type` entity (not a raw schema) must unwrap it
+* themselves — `Obj.make` / `Relation.make` do this via `Type.getSchema(...)`
+* and pass the entity through as `typeSource` so the instance carries a
+* back-reference for `Obj.getType` and resolves the live source schema
+* uniformly via the entity's `[StaticTypeSchemaSlot]`.
+*/
+var makeObject = (schema, obj, meta, typeSource) => {
+	return createReactiveObject(Object.assign({}, obj), meta, schema, typeSource);
+};
+var createReactiveObject = (obj, meta, schema, typeSource) => {
+	if (!isValidProxyTarget(obj)) throw new Error("Value cannot be made into a reactive object.");
+	if (!schema) throw new Error("Schema is required for reactive objects. Use Atom for untyped reactive state.");
+	const parent = obj[ParentId];
+	if (parent !== void 0) delete obj[ParentId];
+	const annotation = getTypeAnnotation(schema);
+	if (annotation) {
+		setIdOnTarget(obj);
+		defineHiddenProperty(obj, KindId, annotation.kind);
+	}
+	initMeta(obj, meta);
+	if (parent !== void 0) defineHiddenProperty(obj, ParentId, parent);
+	prepareTypedTarget(obj, schema, typeSource);
+	attachTypedJsonSerializer(obj);
+	const proxy = createProxy(obj, TypedReactiveHandler.instance);
+	const metaProxy = obj[MetaId];
+	if (metaProxy) {
+		const metaTarget = getProxyTarget(metaProxy);
+		if (metaTarget) setMetaOwner(metaTarget, obj);
+	}
+	return proxy;
+};
+/**
+* Rewrap an object decoded from JSON (via `objectFromJSON`) into a live reactive proxy, so that
+* `Obj.update` synchronously mutates it and `Obj.subscribe`/atoms fire — the same contract as
+* automerge-backed objects. Unlike {@link makeObject}, the target already carries `SchemaId`/
+* `TypeId` stamped by `setSchema`/`setTypename` (both `configurable: false`), so this does not
+* re-derive or re-stamp them — it only validates against the schema, reactifies nested arrays,
+* rewraps `[MetaId]` as a live nested proxy, and wraps the whole object in a proxy.
+*
+* Objects whose type could not be resolved at decode time (no `SchemaId`) are returned unchanged —
+* they remain plain snapshots and `Obj.update` on them stays a no-op, since there is no schema to
+* validate mutations against.
+*/
+var makeDecodedEntityLive = (obj) => {
+	const schema = obj[SchemaId];
+	if (!schema) return obj;
+	prepareDecodedTypedTarget(obj, schema);
+	const meta = obj[MetaId];
+	if (meta != null && typeof meta === "object" && !isProxy(meta)) {
+		prepareTypedTarget(meta, EntityMetaSchema);
+		const metaProxy = createProxy(meta, TypedReactiveHandler.instance);
+		defineHiddenProperty(obj, MetaId, metaProxy);
+		setMetaOwner(getProxyTarget(metaProxy), obj);
+	}
+	attachTypedJsonSerializer(obj);
+	return createProxy(obj, TypedReactiveHandler.instance);
+};
+/**
+* Set ID on ECHO object targets during creation.
+* Used for objects with schema and the ones explicitly marked as Expando.
+*/
+var setIdOnTarget = (target) => {
+	if ("id" in target && target.id !== void 0 && target.id !== null) {
+		if (!EntityId.isValid(target.id)) throw new Error("Invalid object id format.");
+	} else target.id = EntityId.random();
+};
+/**
+* Set metadata on object.
+*/
+var initMeta = (obj, meta) => {
+	const fullMeta = {
+		...meta,
+		keys: meta?.keys ?? [],
+		tags: meta?.tags ?? [],
+		annotations: meta?.annotations ?? {}
+	};
+	prepareTypedTarget(fullMeta, EntityMetaSchema);
+	defineHiddenProperty(obj, MetaId, createProxy(fullMeta, TypedReactiveHandler.instance));
+};
+//#endregion
+//#region src/internal/Entity/entity.ts
+/**
+* Identity (typename + version) of the type meta-schema — the `Type.Type` that
+* every ECHO type entity is itself an instance of. Shared by the materialisation
+* vehicle ({@link persistentEntitySchema}) and `TypeSchema` so the two cannot
+* drift on identity.
+*/
+var TypeMetaSchemaDXN = DXN.make("org.dxos.type.schema", "0.1.0");
+/**
+* Effect Schema that every `Type.Type` entity is an instance of: the meta-schema
+* struct `{ name?, jsonSchema, id }` branded as a type-kind ECHO entity. This is
+* the materialisation vehicle for `makeObject` below — the canonical user-facing
+* entity is `Type/type-schema.ts`'s `TypeSchema`, which carries the same shape
+* plus UI annotations.
+*
+* Kept self-contained (no import of `TypeSchema`) to avoid a bootstrap cycle:
+* `TypeSchema` is itself produced via `makeEchoTypeSchema`, so this builder must
+* not depend on it. `jsonSchema` is declared optional here (only on the
+* materialisation vehicle — the canonical `TypeSchema` keeps it required) so the
+* construction-time `Schema.asserts` does not force the field before it is
+* attached; it is populated immediately after via a lazy accessor (see
+* `makeEchoTypeSchema`).
+*/
+var persistentEntitySchema = (() => {
+	const typename = DXN.getName(TypeMetaSchemaDXN);
+	const version = DXN.getVersion(TypeMetaSchemaDXN);
+	const struct = Schema.Struct({
+		name: Schema.optional(Schema.String),
+		jsonSchema: JsonSchemaType.pipe(Schema.optional),
+		id: EntityId
+	});
+	const ast = SchemaAST.annotations(struct.ast, {
+		[TypeAnnotationId]: {
+			kind: EntityKind.Type,
+			typename,
+			version
+		},
+		[SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+			kind: EntityKind.Type,
+			typename,
+			version
+		})
+	});
+	return Schema.make(ast);
+})();
+/**
+* @internal
+*
+* Build an in-memory `Type.Type` entity (the value returned by `Type.makeObject`
+* / `Type.makeRelation`). The result is a LIVE reactive `TypeSchema`
+* instance — identical in every respect to a persisted `Type.Type` except that
+* it is not yet attached to a database. It is mutable via `Type.update`, can be
+* passed to `db.add(...)` (which keeps the same proxy and swaps the handler),
+* and round-trips through `jsonSchema`.
+*
+* The source Effect Schema describing the user's type is cached on
+* `[StaticTypeSchemaSlot]` so `Type.getSchema(...)` returns it without a
+* jsonSchema round-trip; the cache is invalidated by the proxy set-trap when
+* `jsonSchema` is mutated (see `typed-handler.ts`).
+*/
+var makeEchoTypeSchema = (fields, ast, typename, version, kind, computeJsonSchema, explicitId) => {
+	const sourceSchema = Schema.make(ast);
+	const meta = {
+		keys: [],
+		key: typename,
+		version
+	};
+	const entity = makeObject(persistentEntitySchema, { id: explicitId ?? EntityId.deterministic(typename, version) }, meta);
+	const target = getProxyTarget(entity);
+	let memoizedJsonSchema;
+	Object.defineProperty(target, "jsonSchema", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return memoizedJsonSchema ??= computeJsonSchema();
+		},
+		set(value) {
+			memoizedJsonSchema = value;
+		}
+	});
+	defineHiddenProperty(target, StaticTypeSchemaSlot, sourceSchema);
+	defineHiddenProperty(target, SchemaKindId, kind);
+	Object.defineProperty(target, "fields", {
+		configurable: true,
+		enumerable: false,
+		get: () => fields
+	});
+	return entity;
+};
+//#endregion
+//#region src/internal/JsonSchema/json-schema-normalize.ts
+/**
+* Normalize schema to to draft-07 format.
+* Note: the input type does not necessarily match the {@link JsonSchemaType} type.
+*/
+var normalizeSchema = (schema) => {
+	const copy = structuredClone(schema);
+	go(copy);
+	return copy;
+};
+var go = (schema) => {
+	if (typeof schema !== "object" || schema === null) return;
+	if (schema.exclusiveMaximum === true) {
+		schema.exclusiveMaximum = schema.maximum;
+		delete schema.exclusiveMaximum;
+	} else if (schema.exclusiveMaximum === false) delete schema.exclusiveMaximum;
+	if (schema.exclusiveMinimum === true) {
+		schema.exclusiveMinimum = schema.minimum;
+		delete schema.exclusiveMinimum;
+	} else if (schema.exclusiveMinimum === false) delete schema.exclusiveMinimum;
+	for (const key of Object.keys(schema)) if (!JsonSchemaFields.includes(key)) delete schema[key];
+	if (schema.properties) goOnRecord(schema.properties);
+	if (schema.patternProperties) goOnRecord(schema.patternProperties);
+	if (schema.propertyNames) go(schema.propertyNames);
+	if (schema.definitions) goOnRecord(schema.definitions);
+	if (schema.items) maybeGoOnArray(schema.items);
+	if (schema.additionalItems) maybeGoOnArray(schema.additionalItems);
+	if (schema.contains) go(schema.contains);
+	if (schema.if) go(schema.if);
+	if (schema.then) go(schema.then);
+	if (schema.else) go(schema.else);
+	if (schema.allOf) maybeGoOnArray(schema.allOf);
+	if (schema.anyOf) maybeGoOnArray(schema.anyOf);
+	if (schema.oneOf) maybeGoOnArray(schema.oneOf);
+	if (schema.not) go(schema.not);
+	if (schema.$defs) goOnRecord(schema.$defs);
+	if (schema.reference) go(schema.reference.schema);
+};
+var maybeGoOnArray = (value) => {
+	if (Array.isArray(value)) for (const item of value) go(item);
+	else if (typeof value === "object" && value !== null) go(value);
+};
+var goOnRecord = (record) => {
+	for (const key of Object.keys(record)) go(record[key]);
+};
+//#endregion
+//#region src/internal/Entity/object.ts
+var __dxlog_file$6 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/object.ts";
+/**
+* Schema for Obj entity types.
+* Pipeable function to add ECHO object annotations to a schema.
+*/
+var EchoObjectSchema = (dxn, options) => {
+	const typename = DXN.getName(dxn);
+	const version = DXN.getVersion(dxn);
+	invariant(version, `Type.makeObject requires a versioned DXN: ${dxn}`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$6,
+		L: 40,
+		S: void 0,
+		A: ["version", "`Type.makeObject requires a versioned DXN: ${dxn}`"]
+	});
+	return (self) => {
+		invariant(typeof TypeAnnotationId === "symbol", "Sanity.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 45,
+			S: void 0,
+			A: ["typeof TypeAnnotationId === 'symbol'", "'Sanity.'"]
+		});
+		invariant(SchemaAST.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$6,
+			L: 46,
+			S: void 0,
+			A: ["SchemaAST.isTypeLiteral(self.ast)", "'Schema must be a TypeLiteral.'"]
+		});
+		const fields = self.fields ?? {};
+		const schemaWithId = Schema.extend(self, Schema.Struct({ id: Schema.String }));
+		const ast = SchemaAST.annotations(schemaWithId.ast, {
+			...self.ast.annotations,
+			[TypeAnnotationId]: {
+				kind: EntityKind.Object,
+				typename,
+				version
+			},
+			[SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+				kind: EntityKind.Object,
+				typename,
+				version
+			})
+		});
+		return makeEchoTypeSchema(fields, ast, typename, version, EntityKind.Object, () => toJsonSchema(Schema.make(ast)), options?.id);
+	};
+};
+var makeObjectType = (dxn, schema, options) => {
+	const type = EchoObjectSchema(dxn, options)(schema);
+	const constructor = function ObjectType() {};
+	Object.setPrototypeOf(constructor, type);
+	return constructor;
+};
+//#endregion
+//#region src/internal/Entity/relation.ts
+var __dxlog_file$5 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/relation.ts";
+/**
+* Schema for Relation entity types.
+*/
+var EchoRelationSchema = ({ dxn, source, target, id: explicitId }) => {
+	const sourceSchema = source != null ? getStaticTypeSchema(source) ?? source : source;
+	const targetSchema = target != null ? getStaticTypeSchema(target) ?? target : target;
+	assertArgument(Schema.isSchema(sourceSchema), "source");
+	assertArgument(Schema.isSchema(targetSchema), "target");
+	const typename = DXN.getName(dxn);
+	const version = DXN.getVersion(dxn);
+	invariant(version, `Type.makeRelation requires a versioned DXN: ${dxn}`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$5,
+		L: 123,
+		S: void 0,
+		A: ["version", "`Type.makeRelation requires a versioned DXN: ${dxn}`"]
+	});
+	const sourceDXN = getDXNForRelationSchemaRef(sourceSchema);
+	const targetDXN = getDXNForRelationSchemaRef(targetSchema);
+	if (getEntityKind(sourceSchema) !== EntityKind.Object) raise(/* @__PURE__ */ new Error("Source schema must be an echo object schema."));
+	if (getEntityKind(targetSchema) !== EntityKind.Object) raise(/* @__PURE__ */ new Error("Target schema must be an echo object schema."));
+	return (self) => {
+		invariant(SchemaAST.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$5,
+			L: 136,
+			S: void 0,
+			A: ["SchemaAST.isTypeLiteral(self.ast)", "'Schema must be a TypeLiteral.'"]
+		});
+		const fields = self.fields ?? {};
+		const schemaWithId = Schema.extend(self, Schema.Struct({ id: Schema.String }));
+		const ast = SchemaAST.annotations(schemaWithId.ast, {
+			...self.ast.annotations,
+			[TypeAnnotationId]: {
+				kind: EntityKind.Relation,
+				typename,
+				version,
+				sourceSchema: sourceDXN,
+				targetSchema: targetDXN
+			},
+			[SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+				kind: EntityKind.Relation,
+				typename,
+				version,
+				relationSource: sourceDXN,
+				relationTarget: targetDXN
+			})
+		});
+		return makeEchoTypeSchema(fields, ast, typename, version, EntityKind.Relation, () => toJsonSchema(Schema.make(ast)), explicitId);
+	};
+};
+var getDXNForRelationSchemaRef = (schema) => {
+	assertArgument(Schema.isSchema(schema), "schema");
+	const identifier = getTypeIdentifierAnnotation(schema);
+	if (identifier) return DXN.tryMake(identifier) ?? raise(/* @__PURE__ */ new Error(`Invalid schema identifier: ${identifier}`));
+	const typename = getSchemaTypename(schema);
+	if (!typename) throw new Error("Schema must have a typename");
+	return DXN.make(typename);
+};
+var makeRelationType = (options) => {
+	const type = EchoRelationSchema({
+		dxn: options.dxn,
+		source: options.source,
+		target: options.target,
+		id: options.id
+	})(options.schema);
+	const constructor = function RelationType() {};
+	Object.setPrototypeOf(constructor, type);
+	return constructor;
+};
+//#endregion
+//#region src/internal/Entity/type-kind.ts
+var __dxlog_file$4 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Entity/type-kind.ts";
+/**
+* Pipeable that brands a schema as a type-kind ECHO entity. Mirrors
+* {@link EchoObjectSchema} / {@link EchoRelationSchema}, but stamps the
+* resulting entity with `[SchemaKindId]: EntityKind.Type` and a matching
+* `TypeAnnotation.kind = 'type'` so meta-schemas surface uniformly through
+* `Type.isTypeKind`, `Filter.type`, etc.
+*/
+var EchoTypeKindSchema = (dxn, options) => {
+	const typename = DXN.getName(dxn);
+	const version = DXN.getVersion(dxn);
+	invariant(version, `Type-kind schemas require a versioned DXN: ${dxn}`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$4,
+		L: 45,
+		S: void 0,
+		A: ["version", "`Type-kind schemas require a versioned DXN: ${dxn}`"]
+	});
+	return (self) => {
+		invariant(SchemaAST.isTypeLiteral(self.ast), "Schema must be a TypeLiteral.", {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$4,
+			L: 50,
+			S: void 0,
+			A: ["SchemaAST.isTypeLiteral(self.ast)", "'Schema must be a TypeLiteral.'"]
+		});
+		const fields = self.fields ?? {};
+		const schemaWithId = Schema.extend(self, Schema.Struct({ id: Schema.String }));
+		const ast = SchemaAST.annotations(schemaWithId.ast, {
+			...self.ast.annotations,
+			[TypeAnnotationId]: {
+				kind: EntityKind.Type,
+				typename,
+				version
+			},
+			[SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+				kind: EntityKind.Type,
+				typename,
+				version
+			})
+		});
+		return makeEchoTypeSchema(fields, ast, typename, version, EntityKind.Type, () => toJsonSchema(Schema.make(ast)), options?.id);
+	};
+};
+//#endregion
+//#region src/internal/Entity/version.ts
+var unversioned = {
+	[VersionTypeId]: {},
+	versioned: false
+};
+/**
+* Checks that `obj` is a version object.
+*/
+var isVersion = (entity) => {
+	return entity != null && typeof entity === "object" && "~@dxos/echo/VersionTypeId" in entity;
+};
+/**
+* Returns the version of an entity.
+* Accepts both reactive entities and snapshots.
+*/
+var version = (entity) => {
+	const ver = entity[ObjectVersionId];
+	if (ver === void 0) return unversioned;
+	return ver;
+};
+/**
+* Checks that `version` is a valid version object.
+*/
+var versionValid = (ver) => {
+	assertArgument(isVersion(ver), "version", "Invalid version object");
+	return !!ver.versioned;
+};
+/**
+* Compares two versions.
+* @param version1
+* @param version2
+* @returns 'unversioned' if either entity is unversioned, 'equal' if the versions are equal, 'different' if the versions are different.
+*/
+var compareVersions = (version1, version2) => {
+	assertArgument(isVersion(version1), "version1", "Invalid version object");
+	assertArgument(isVersion(version2), "version2", "Invalid version object");
+	if (!versionValid(version1) || !versionValid(version2)) return "unversioned";
+	if (version1.automergeHeads?.length !== version2.automergeHeads?.length) return "different";
+	if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) return "different";
+	return "equal";
+};
+var encodeVersion = (ver) => {
+	return JSON.stringify(ver);
+};
+var decodeVersion = (ver) => {
+	const parsed = JSON.parse(ver);
+	parsed[VersionTypeId] = {};
+	return parsed;
+};
+//#endregion
+//#region src/internal/Obj/json-serializer.ts
+var __dxlog_file$3 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/json-serializer.ts";
+/**
+* Converts object to it's JSON representation.
+*/
+var objectToJSON = (obj) => {
+	const typename = getTypeURI(obj);
+	invariant(typename && typeof typename === "string", void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 68,
+		S: void 0,
+		A: ["typename && typeof typename === 'string'", ""]
+	});
+	return typedJsonSerializer.call(obj);
+};
+/**
+* Creates an object from it's json representation.
+* Performs schema validation.
+* References and schema will be resolvable if the `refResolver` is provided.
+* The function need to be async to support resolving the schema as well as the relation endpoints.
+*
+* @param jsonData - JSON representation of the object.
+* @param options.refResolver - Resolver for references.
+* @param options.uri - Override object URI.
+* @param options.database - Database to associate with the object.
+*/
+var objectFromJSON = async (jsonData, { refResolver, uri, database, parent } = {}) => {
+	assumeType(jsonData);
+	assertArgument(typeof jsonData === "object" && jsonData !== null, "jsonData", "expect object");
+	assertArgument(typeof jsonData[ATTR_TYPE] === "string", "jsonData[ATTR_TYPE]", "expected object to have a type");
+	assertArgument(typeof jsonData.id === "string", "jsonData.id", "expected object to have an id");
+	const type = URI.make(jsonData[ATTR_TYPE]);
+	const schema = await refResolver?.resolveSchema(type);
+	invariant(schema === void 0 || Schema.isSchema(schema), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 99,
+		S: void 0,
+		A: ["schema === undefined || Schema.isSchema(schema)", ""]
+	});
+	const decodedInput = restoreUint8Arrays(stripInternalJsonKeys(jsonData));
+	let obj;
+	if (schema != null) {
+		obj = await schema.pipe(Schema.decodeUnknownPromise)(decodedInput);
+		if (refResolver) setRefResolverOnData(obj, refResolver);
+	} else obj = decodeGeneric(decodedInput, { refResolver });
+	invariant(EntityId.isValid(obj.id), "Invalid object id", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 112,
+		S: void 0,
+		A: ["EntityId.isValid(obj.id)", "'Invalid object id'"]
+	});
+	setTypename(obj, type);
+	if (schema) setSchema(obj, schema);
+	if (refResolver?.resolveType) {
+		const typeEntity = await refResolver.resolveType(type);
+		if (typeEntity != null) setType(obj, typeEntity);
+	}
+	if (typeof jsonData["@relationSource"] === "string" || typeof jsonData["@relationTarget"] === "string") {
+		const sourceDxn = jsonData["@relationSource"] ?? raise(/* @__PURE__ */ new TypeError("Missing relation source"));
+		const targetDxn = jsonData["@relationTarget"] ?? raise(/* @__PURE__ */ new TypeError("Missing relation target"));
+		const source = await refResolver?.resolveLegacy(sourceDxn);
+		const target = await refResolver?.resolveLegacy(targetDxn);
+		defineHiddenProperty(obj, KindId, EntityKind.Relation);
+		defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
+		defineHiddenProperty(obj, RelationTargetDXNId, targetDxn);
+		defineHiddenProperty(obj, RelationSourceId, source);
+		defineHiddenProperty(obj, RelationTargetId, target);
+	} else {
+		const annotationKind = schema != null ? getTypeAnnotation(schema)?.kind : void 0;
+		defineHiddenProperty(obj, KindId, annotationKind === EntityKind.Type ? EntityKind.Type : EntityKind.Object);
+	}
+	if (typeof jsonData["@meta"] === "object") {
+		const meta = await EntityMetaSchema.pipe(Schema.decodeUnknownPromise)(normalizeMeta(jsonData[ATTR_META]));
+		invariant(Array.isArray(meta.keys), void 0, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$3,
+			L: 153,
+			S: void 0,
+			A: ["Array.isArray(meta.keys)", ""]
+		});
+		defineHiddenProperty(obj, MetaId, meta);
+	} else defineHiddenProperty(obj, MetaId, {
+		keys: [],
+		tags: [],
+		annotations: {}
+	});
+	if (jsonData["@parent"]) {
+		const parentDxn = jsonData[ATTR_PARENT];
+		const resolvedParent = await refResolver?.resolveLegacy(parentDxn);
+		defineHiddenProperty(obj, ParentId, resolvedParent);
+	} else if (parent) defineHiddenProperty(obj, ParentId, parent);
+	if (uri) defineHiddenProperty(obj, SelfURIId, uri);
+	if (database) defineHiddenProperty(obj, ObjectDatabaseId, database);
+	defineHiddenProperty(obj, ObjectDeletedId, jsonData[ATTR_DELETED] === true);
+	assertObjectModel(obj);
+	invariant(obj[ATTR_TYPE] === void 0, "Invalid object model", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 184,
+		S: void 0,
+		A: ["(obj as any)[ATTR_TYPE] === undefined", "'Invalid object model'"]
+	});
+	invariant(obj[ATTR_META] === void 0, "Invalid object model", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 185,
+		S: void 0,
+		A: ["(obj as any)[ATTR_META] === undefined", "'Invalid object model'"]
+	});
+	invariant(obj[ATTR_DELETED] === void 0, "Invalid object model", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 186,
+		S: void 0,
+		A: ["(obj as any)[ATTR_DELETED] === undefined", "'Invalid object model'"]
+	});
+	invariant(obj[ATTR_SELF_URI] === void 0, "Invalid object model", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 187,
+		S: void 0,
+		A: ["(obj as any)[ATTR_SELF_URI] === undefined", "'Invalid object model'"]
+	});
+	invariant(obj[ATTR_SELF_URI_LEGACY] === void 0, "Invalid object model", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 188,
+		S: void 0,
+		A: ["(obj as any)[ATTR_SELF_URI_LEGACY] === undefined", "'Invalid object model'"]
+	});
+	invariant(obj[ATTR_RELATION_SOURCE] === void 0, "Invalid object model", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 189,
+		S: void 0,
+		A: ["(obj as any)[ATTR_RELATION_SOURCE] === undefined", "'Invalid object model'"]
+	});
+	invariant(obj[ATTR_RELATION_TARGET] === void 0, "Invalid object model", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$3,
+		L: 190,
+		S: void 0,
+		A: ["(obj as any)[ATTR_RELATION_TARGET] === undefined", "'Invalid object model'"]
+	});
+	return obj;
+};
+/**
+* Backfills required meta fields and upgrades legacy `tags` (bare URI strings) to encoded references
+* so serialized data produced before the tags-as-refs migration still decodes.
+*/
+var normalizeMeta = (meta) => {
+	const tags = Array.isArray(meta?.tags) ? meta.tags.map((tag) => typeof tag === "string" ? { "/": URI.make(tag) } : tag) : [];
+	return {
+		...meta,
+		keys: Array.isArray(meta?.keys) ? meta.keys : [],
+		tags,
+		annotations: meta?.annotations ?? {}
+	};
+};
+var decodeGeneric = (jsonData, options) => {
+	return deepMapValues(stripInternalJsonKeys(jsonData), (value, visitor) => {
+		if (isEncodedReference(value)) return refFromEncodedReference(value, options.refResolver);
+		if (isEncodedUint8Array(value)) return decodeUint8ArrayFromJson(value);
+		return visitor(value);
+	});
+};
+/**
+* Recursively replaces encoded `Uint8Array` JSON markers with actual `Uint8Array` instances.
+* Runs before schema decoding so `Schema.Uint8ArrayFromSelf` sees real bytes.
+*/
+var restoreUint8Arrays = (data) => deepMapValues(data, (value, recurse) => {
+	if (isEncodedUint8Array(value)) return decodeUint8ArrayFromJson(value);
+	return recurse(value);
+});
+var stripInternalJsonKeys = (jsonData) => {
+	const { [ATTR_TYPE]: _type, [ATTR_META]: _meta, [ATTR_DELETED]: _deleted, [ATTR_SELF_URI]: _selfUri, [ATTR_SELF_URI_LEGACY]: _legacySelfUri, [ATTR_RELATION_SOURCE]: _relationSource, [ATTR_RELATION_TARGET]: _relationTarget, ...props } = jsonData;
+	return props;
+};
+var setRefResolverOnData = (obj, refResolver) => {
+	const visitor = (value) => {
+		if (Ref.isRef(value)) setRefResolver(value, refResolver);
+		else visitValues(value, visitor);
+	};
+	visitor(obj);
+};
+/**
+* Convert EntityStructure to JSON data for indexing.
+* Different from {@link objectToJSON} as it takes the internal {@link EntityStructure} representation directly
+*/
+var objectStructureToJson = (objectId, structure) => {
+	const typeRef = EntityStructure.getTypeReference(structure)?.["/"];
+	const parent = EntityStructure.getParent(structure)?.["/"];
+	const source = EntityStructure.getRelationSource(structure)?.["/"];
+	const target = EntityStructure.getRelationTarget(structure)?.["/"];
+	return {
+		...structure.data,
+		id: objectId,
+		[ATTR_TYPE]: typeRef ? URI.make(typeRef) : void 0,
+		[ATTR_DELETED]: EntityStructure.isDeleted(structure),
+		[ATTR_PARENT]: parent !== void 0 ? EID.tryParse(parent) : void 0,
+		[ATTR_RELATION_SOURCE]: source !== void 0 ? EID.tryParse(source) : void 0,
+		[ATTR_RELATION_TARGET]: target !== void 0 ? EID.tryParse(target) : void 0
+	};
+};
+//#endregion
+//#region src/internal/Filter/match.ts
+/**
+* Matches a tag filter against an object's stored tags. Tags may be stored as encoded references or
+* (in legacy data) bare URI strings, and those URIs may be in legacy DXN form. Both sides are
+* normalized to the canonical EID before comparing.
+*/
+var matchesTag = (tags, filterTag) => {
+	const canonical = (uri) => {
+		const eid = EID.tryParse(uri);
+		return eid && EID.getEntityId(eid) || uri;
+	};
+	const normalize = (tag) => canonical(isEncodedReference(tag) ? EncodedReference.toURI(tag) : tag);
+	const target = canonical(filterTag);
+	return tags.some((tag) => normalize(tag) === target);
+};
+/**
+* Matches a meta `key` / `version` constraint against an object's meta `key` and `version`.
+*/
+var matchMetaKey = (key, versionRange, objKey, objVersion) => {
+	if (objKey !== key) return false;
+	if (versionRange === void 0) return true;
+	if (objVersion === void 0 || semver.valid(objVersion) === null) return false;
+	if (semver.validRange(versionRange) === null) return false;
+	return semver.satisfies(objVersion, versionRange, { includePrerelease: true });
+};
+/**
+* Compares a filter's type discriminator against the value stored on an object's `system.type`.
+*/
+var compareTypenameStrings = (expectedStr, actualStr) => {
+	const expectedEid = EID.tryParse(expectedStr);
+	if (expectedEid) {
+		const actualEid = EID.tryParse(actualStr);
+		if (!actualEid) return false;
+		if (EID.getEntityId(expectedEid) !== EID.getEntityId(actualEid)) return false;
+		const expectedSpaceId = EID.getSpaceId(expectedEid);
+		const actualSpaceId = EID.getSpaceId(actualEid);
+		return expectedSpaceId === void 0 || actualSpaceId === void 0 || expectedSpaceId === actualSpaceId;
+	}
+	const expectedDxn = DXN.tryMake(expectedStr);
+	if (expectedDxn) {
+		const actualDxn = DXN.tryMake(actualStr);
+		if (!actualDxn) return false;
+		if (DXN.getName(expectedDxn) !== DXN.getName(actualDxn)) return false;
+		const expectedVersion = DXN.getVersion(expectedDxn);
+		const actualVersion = DXN.getVersion(actualDxn);
+		return expectedVersion === void 0 || actualVersion === void 0 || expectedVersion === actualVersion;
+	}
+	return expectedStr === actualStr;
+};
+var structuralMatch = (filterObj, targetObj, strict = true) => {
+	if (typeof filterObj !== "object" || filterObj === null) return filterObj === targetObj;
+	if (typeof targetObj !== "object" || targetObj === null) return false;
+	const filterKeys = Object.keys(filterObj);
+	const targetKeys = Object.keys(targetObj);
+	if (strict && filterKeys.length !== targetKeys.length) return false;
+	return filterKeys.every((key) => {
+		if (!(key in targetObj)) return false;
+		const filterValue = filterObj[key];
+		const targetValue = targetObj[key];
+		if (typeof filterValue === "object" && filterValue !== null) return structuralMatch(filterValue, targetValue);
+		return filterValue === targetValue;
+	});
+};
+/** Normalizes an encoded reference to its URI string so ref-valued properties compare by identity. */
+var _normalizeInValue = (value) => isEncodedReference(value) ? EncodedReference.toURI(value) : value;
+/**
+* Memoizes a `Set` per `values` array so `Filter.in` membership is O(1) rather than
+* `Array.includes`'s O(n) — this matters most for large sets projected from a subquery
+* (`Filter.in(query.project(...))`, resolved to a literal `in` by the query executor), but
+* also speeds up ordinary literal-list `Filter.in`. Keyed by array identity: the planner and
+* executor never mutate a filter's `values` array in place, so the cache stays valid for the
+* array's lifetime.
+*/
+var _inSetCache = /* @__PURE__ */ new WeakMap();
+var _getInSet = (values) => {
+	let set = _inSetCache.get(values);
+	if (!set) {
+		set = new Set(values.map(_normalizeInValue));
+		_inSetCache.set(values, set);
+	}
+	return set;
+};
+var filterMatchValue = (filter, value) => {
+	switch (filter.type) {
+		case "compare": {
+			const compareValue = filter.value;
+			switch (filter.operator) {
+				case "eq":
+					if (isEncodedReference(compareValue)) {
+						if (!isEncodedReference(value)) return false;
+						return EncodedReference.toURI(value) === EncodedReference.toURI(compareValue);
+					}
+					return value === compareValue;
+				case "neq": return value !== compareValue;
+				case "gt": return value > compareValue;
+				case "gte": return value >= compareValue;
+				case "lt": return value < compareValue;
+				case "lte": return value <= compareValue;
+				default: return false;
+			}
+		}
+		case "object":
+			if (typeof value !== "object" || value === null) return false;
+			if (filter.props) for (const [key, valueFilter] of Object.entries(filter.props)) {
+				const nestedValue = value[key];
+				if (!filterMatchValue(valueFilter, nestedValue)) return false;
+			}
+			return true;
+		case "in": return _getInSet(filter.values).has(_normalizeInValue(value));
+		case "in-query": throw new Error("in-query filters must be resolved to a literal `in` by the query executor before matching.");
+		case "contains":
+			if (!Array.isArray(value)) return false;
+			return value.some((element) => {
+				if (typeof filter.value === "object" && filter.value !== null && !Array.isArray(filter.value)) return structuralMatch(filter.value, element);
+				return element === filter.value;
+			});
+		case "range": return value >= filter.from && value <= filter.to;
+		case "not": return !filterMatchValue(filter.filter, value);
+		case "and": return filter.filters.every((f) => filterMatchValue(f, value));
+		case "or": return filter.filters.some((f) => filterMatchValue(f, value));
+		default: return false;
+	}
+};
+/**
+* Matches a filter against an entity proxy without full JSON serialization when possible.
+*/
+var filterMatchEntity = (filter, entity) => {
+	switch (filter.type) {
+		case "object": {
+			if (filter.typename !== null) {
+				const typeURI = getTypeURI(entity);
+				if (!typeURI || !compareTypenameStrings(filter.typename, typeURI)) return false;
+			}
+			if (filter.id && filter.id.length > 0 && !filter.id.includes(entity.id)) return false;
+			if (filter.props) {
+				let json = null;
+				try {
+					json = objectToJSON(entity);
+				} catch {}
+				if (json === null) return false;
+				for (const [key, valueFilter] of Object.entries(filter.props)) {
+					if (key.startsWith("@")) continue;
+					if (!filterMatchValue(valueFilter, json[key])) return false;
+				}
+			}
+			const meta = getMetaChecked(entity);
+			if (filter.foreignKeys && filter.foreignKeys.length > 0) {
+				if (!filter.foreignKeys.some((fk) => meta.keys.some((k) => k.source === fk.source && k.id === fk.id))) return false;
+			}
+			if (filter.metaKey !== void 0) {
+				if (!matchMetaKey(filter.metaKey, filter.metaVersion, meta.key, meta.version)) return false;
+			}
+			return true;
+		}
+		case "tag": return matchesTag(getMetaChecked(entity).tags.map((tag) => typeof tag?.encode === "function" ? tag.encode() : tag), filter.tag);
+		case "text-search": return false;
+		case "timestamp": throw new Error("Timestamp filters must be handled at the index level, not in-memory matching.");
+		case "child-of": throw new Error("child-of filters must be handled at the executor level, not in-memory matching.");
+		case "in-query": throw new Error("in-query filters must be resolved to a literal `in` by the query executor before matching.");
+		case "not": return !filterMatchEntity(filter.filter, entity);
+		case "and": return filter.filters.every((f) => filterMatchEntity(f, entity));
+		case "or": return filter.filters.some((f) => filterMatchEntity(f, entity));
+		default: return false;
+	}
+};
+//#endregion
+//#region src/internal/Obj/common.ts
+var makeTypedEntityClass = (typename, version, baseSchema) => {
+	return class {
+		static typename = typename;
+		static version = version;
+		static [Schema.TypeId] = schemaVariance;
+		static ast = baseSchema.ast;
+		static annotations = baseSchema.annotations.bind(baseSchema);
+		static pipe = baseSchema.pipe.bind(baseSchema);
+		static [Symbol.hasInstance](obj) {
+			return obj != null && getTypename(obj) === typename;
+		}
+		constructor() {
+			throw new Error("Use live(Typename, { ...fields }) to instantiate an object.");
+		}
+	};
+};
+var schemaVariance = {
+	_A: (_) => _,
+	_I: (_) => _,
+	_R: (_) => _
+};
+//#endregion
+//#region src/internal/Obj/inspect.ts
+var attachedTypedObjectInspector = (obj) => {
+	if (Object.getOwnPropertyDescriptor(obj, inspectCustom)) return;
+	Object.defineProperty(obj, inspectCustom, {
+		value: typedObjectInspectFunction,
+		writable: false,
+		enumerable: false,
+		configurable: true
+	});
+};
+var typedObjectInspectFunction = function(depth, options, inspect) {
+	const { id, ...props } = this;
+	return inspect({
+		id,
+		[ATTR_TYPE]: getTypeURI(this),
+		...props,
+		[ATTR_META]: this[MetaId]
+	}, options);
+};
+//#endregion
+//#region src/internal/Obj/create-object.ts
+/**
+* Creates a new object instance from a schema and data, without signal reactivity.
+* This static version creates plain JavaScript objects that are not reactive/observable.
+* For reactive objects that automatically update UI when changed, use the regular live() function.
+*
+* @param schema - The Effect schema that defines the object's structure and type, piped into EchoObjectSchema
+* @param data - The data to initialize the object with. The id and @type fields are handled automatically.
+* @returns A new non-reactive object instance conforming to the schema
+* @throws {Error} If the schema is not an object schema
+* @throws {TypeError} If data contains an @type field
+*
+* @example
+* ```ts
+* class Contact extends Type.makeObject<Contact>(DXN.make('com.example.type.person', '0.1.0'))(
+*   Schema.Struct({ name: Schema.String, email: Schema.String }),
+* ) {}
+*
+* const contact = createObject(Contact, {
+*   name: "John",
+*   email: "john@example.com",
+* })
+* ```
+*/
+var createObject = (input, props) => {
+	const schema = getStaticTypeSchema(input) ?? failedInvariant("Type entity is missing its source schema");
+	const annotation = getTypeAnnotation(schema);
+	if (!annotation) throw new Error("Schema is not an ECHO schema");
+	assertArgument(!("@type" in props), "data", "@type is not allowed");
+	assertArgument(!(RelationSourceDXNId in props), "data", "Relation source DXN is not allowed in the constructor");
+	assertArgument(!(RelationTargetDXNId in props), "data", "Relation target DXN is not allowed in the constructor");
+	assertArgument(RelationSourceId in props === RelationTargetId in props, "data", "Relation source and target must be provided together");
+	const metaOverride = props[MetaId];
+	if (metaOverride !== void 0) delete props[MetaId];
+	const obj = {
+		...props,
+		id: props.id ?? EntityId.random()
+	};
+	const kind = annotation.kind === EntityKind.Type ? EntityKind.Type : annotation.kind === EntityKind.Relation || RelationSourceId in props ? EntityKind.Relation : EntityKind.Object;
+	defineHiddenProperty(obj, KindId, kind);
+	defineHiddenProperty(obj, MetaId, {
+		...metaOverride,
+		keys: metaOverride?.keys ?? [],
+		tags: metaOverride?.tags ?? [],
+		annotations: metaOverride?.annotations ?? {}
+	});
+	setSchema(obj, schema);
+	if (input !== schema) setType(obj, input);
+	setTypename(obj, getSchemaURI(schema) ?? failedInvariant("Missing schema URI"));
+	attachTypedJsonSerializer(obj);
+	attachedTypedObjectInspector(obj);
+	if (kind === EntityKind.Relation) {
+		const sourceDXN = getObjectEchoUri(props[RelationSourceId]) ?? raise(/* @__PURE__ */ new Error("Unresolved relation source"));
+		const targetDXN = getObjectEchoUri(props[RelationTargetId]) ?? raise(/* @__PURE__ */ new Error("Unresolved relation target"));
+		defineHiddenProperty(obj, RelationSourceDXNId, sourceDXN);
+		defineHiddenProperty(obj, RelationTargetDXNId, targetDXN);
+	}
+	assertObjectModel(obj);
+	return obj;
+};
+//#endregion
+//#region src/internal/Obj/deleted.ts
+/**
+* @returns `true` if the object has been marked as deleted.
+*/
+var isDeleted = (obj) => {
+	if (obj[ObjectDeletedId] === void 0) return false;
+	return obj[ObjectDeletedId] ?? false;
+};
+//#endregion
+//#region src/internal/Obj/set-value.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/set-value.ts";
+/**
+* Set a deeply nested property on an object.
+* Must be called within an Obj.update or Relation.update callback.
+*/
+var setValue = (obj, path, value) => {
+	invariant(path.length > 0, "Path must not be empty", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 20,
+		S: void 0,
+		A: ["path.length > 0", "'Path must not be empty'"]
+	});
+	const schema = getSchema(obj);
+	invariant(schema != null, "Object must have a schema", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$2,
+		L: 23,
+		S: void 0,
+		A: ["schema != null", "'Object must have a schema'"]
+	});
+	let parent = obj;
+	let currentAST = schema.ast;
+	for (let i = 0; i < path.length - 1; i++) {
+		const part = path[i];
+		const key = typeof part === "number" ? part : String(part);
+		if (parent[key] === void 0) {
+			const propertyAST = getPropertyAST(currentAST, String(part));
+			if (propertyAST ? SchemaEx.isArrayType(propertyAST) : false) parent[key] = [];
+			else {
+				const objWithDefaults = createObjectWithDefaults(propertyAST);
+				parent[key] = objWithDefaults;
+			}
+		}
+		parent = parent[key];
+		currentAST = getPropertyAST(currentAST, String(part));
+	}
+	const finalKey = path[path.length - 1];
+	parent[finalKey] = value;
+	return value;
+};
+/**
+* Helper to get the AST of a nested property.
+* @param ast - Current schema AST.
+* @param propertyName - Name of the property to get.
+* @returns The AST of the nested property, or undefined if not found.
+*/
+var getPropertyAST = (ast, propertyName) => {
+	if (!ast) return;
+	if (SchemaEx.isNestedType(ast)) {
+		const property = SchemaEx.getProperties(ast).find((p) => p.name.toString() === propertyName);
+		if (property) return SchemaEx.getBaseType(property).type;
+	}
+	if (SchemaEx.isArrayType(ast)) return SchemaEx.getArrayElementType(ast);
+};
+/**
+* Get all required properties from a schema AST.
+* A property is required if it's not optional.
+*
+* @param ast - Schema AST to inspect.
+* @returns Array of required properties with their types.
+*/
+var getRequiredProperties = (ast) => {
+	if (!ast) return [];
+	if (!SchemaEx.isNestedType(ast)) return [];
+	return SchemaEx.getProperties(ast).filter((p) => !p.isOptional);
+};
+/**
+* Get the default value for a primitive type.
+* Returns undefined for non-primitive or unsupported types.
+*
+* @param ast - Type AST.
+* @returns Default value for the type, or undefined.
+*/
+var getDefaultValueForType = (ast) => {
+	if (!ast) return;
+	const defaultValue = SchemaAST.getDefaultAnnotation(ast);
+	if (Option.isSome(defaultValue)) return defaultValue.value;
+	return Match.value(ast).pipe(Match.when({ _tag: "StringKeyword" }, () => ""), Match.when({ _tag: "NumberKeyword" }, () => 0), Match.when({ _tag: "BooleanKeyword" }, () => false), Match.orElse(() => void 0));
+};
+/**
+* Create an object with default values for all required properties.
+* Handles primitive types (String, Number, Boolean) and recursively initializes required nested objects.
+*
+* @param ast - Schema AST describing the object structure.
+* @returns Object with required fields populated with defaults.
+*/
+var createObjectWithDefaults = (ast) => {
+	if (!ast) return {};
+	const requiredProps = getRequiredProperties(ast);
+	const obj = {};
+	for (const prop of requiredProps) {
+		const defaultValue = getDefaultValueForType(prop.type);
+		if (defaultValue !== void 0) obj[prop.name] = defaultValue;
+		else if (SchemaEx.isNestedType(prop.type)) obj[prop.name] = createObjectWithDefaults(prop.type);
+	}
+	return obj;
+};
+//#endregion
+//#region src/internal/Obj/snapshot.ts
+/**
+* Copy a Symbol-keyed property from source to target if it has a defined value.
+* Handles both plain objects (symbol in source) and proxies where get returns a value
+* but has/in returns false (e.g. ObjectDatabaseId on echo-db proxies).
+* Optional transform clones or mutates the value before assignment (e.g. for MetaId).
+*/
+var copySymbolProperty = (source, target, symbol, transform) => {
+	let value;
+	try {
+		value = source[symbol];
+	} catch {
+		return;
+	}
+	if (value !== void 0) {
+		const finalValue = transform ? transform(value) : value;
+		Object.defineProperty(target, symbol, {
+			value: finalValue,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+};
+/**
+* Returns an immutable snapshot of the reactive object.
+* The snapshot is branded with SnapshotKindId (not KindId).
+*/
+var getSnapshot = (obj) => {
+	assertArgument(typeof obj === "object" && obj !== null && "~@dxos/echo/Kind" in obj, "obj", "must be an entity");
+	const snapshot = deepMapValues(obj, (value, recurse) => {
+		if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) !== Object.prototype && !Array.isArray(value)) return value;
+		return recurse(value);
+	});
+	if (obj != null && typeof obj === "object" && "~@dxos/echo/Kind" in obj) snapshot[SnapshotKindId] = obj[KindId];
+	const source = obj;
+	copySymbolProperty(source, snapshot, TypeId);
+	copySymbolProperty(source, snapshot, SchemaId);
+	copySymbolProperty(source, snapshot, TypeEntityId);
+	copySymbolProperty(source, snapshot, SelfURIId);
+	copySymbolProperty(source, snapshot, ObjectDatabaseId);
+	copySymbolProperty(source, snapshot, ObjectDeletedId);
+	copySymbolProperty(source, snapshot, ParentId);
+	copySymbolProperty(source, snapshot, MetaId, (meta) => ({
+		keys: [...meta?.keys ?? []],
+		tags: [...meta?.tags ?? []],
+		...meta?.key != null ? { key: meta.key } : {},
+		...meta?.version != null ? { version: meta.version } : {},
+		...meta?.annotations ? { annotations: { ...meta.annotations } } : {}
+	}));
+	copySymbolProperty(source, snapshot, RelationSourceDXNId);
+	copySymbolProperty(source, snapshot, RelationTargetDXNId);
+	copySymbolProperty(source, snapshot, RelationSourceId);
+	copySymbolProperty(source, snapshot, RelationTargetId);
+	return Object.freeze(snapshot);
+};
+//#endregion
+//#region src/internal/Obj/atoms.ts
+var isRef = (obj) => obj != null && typeof obj === "object" && RefTypeId in obj;
+var getReactiveOption = (snapshot) => Effect.gen(function* () {
+	const db = getDatabase(snapshot);
+	if (!db) return Option.none();
+	const obj = db.getObjectById(snapshot.id);
+	return obj ? Option.some(obj) : Option.none();
+});
+/**
+* Atom family for ECHO objects.
+* Uses object reference as key — same object returns same atom.
+*/
+var objectFamily = Atom.family((obj) => {
+	return Atom.make((get) => {
+		const unsubscribe = subscribe(obj, () => {
+			get.setSelf(getSnapshot(obj));
+		});
+		get.addFinalizer(() => unsubscribe());
+		return getSnapshot(obj);
+	}).pipe(Atom.keepAlive);
+});
+/**
+* Atom family for ECHO refs (snapshot version).
+* Uses ref as key — same ref returns same atom.
+* Subscribes to target object changes after loading.
+*/
+var refFamily = Atom.family((ref) => {
+	return Atom.make((get) => {
+		let unsubscribeTarget;
+		const setupTargetSubscription = (target) => {
+			unsubscribeTarget?.();
+			unsubscribeTarget = subscribe(target, () => {
+				get.setSelf(isDeleted(target) ? void 0 : getSnapshot(target));
+			});
+			return isDeleted(target) ? void 0 : getSnapshot(target);
+		};
+		get.addFinalizer(() => {
+			unsubscribeTarget?.();
+		});
+		return loadRefTarget(ref, get, setupTargetSubscription);
+	}).pipe(Atom.keepAlive);
+});
+/**
+* Atom family for ECHO object properties.
+* Uses nested families: outer keyed by object, inner keyed by property key.
+*/
+var propertyFamily = Atom.family((obj) => Atom.family((key) => {
+	return Atom.make((get) => {
+		let previousSnapshot = snapshotForComparison(obj[key]);
+		const unsubscribe2 = subscribe(obj, () => {
+			const newValue = obj[key];
+			const newSnapshot = snapshotForComparison(newValue);
+			if (newSnapshot !== previousSnapshot) {
+				previousSnapshot = newSnapshot;
+				get.setSelf(newSnapshot);
+			}
+		});
+		get.addFinalizer(() => unsubscribe2());
+		return snapshotForComparison(obj[key]);
+	}).pipe(Atom.keepAlive);
+}));
+/**
+* Atom family for ECHO objects — returns the live object, not a snapshot.
+*/
+var objectWithReactiveFamily = Atom.family((obj) => {
+	return Atom.make((get) => {
+		const unsubscribe = subscribe(obj, () => {
+			get.setSelf(obj);
+		});
+		get.addFinalizer(() => unsubscribe());
+		return obj;
+	}).pipe(Atom.keepAlive);
+});
+/**
+* Atom family for ECHO refs — returns the live reactive object, not a snapshot.
+*/
+var refWithReactiveFamily = Atom.family((ref) => {
+	const effect = (get) => Effect.gen(function* () {
+		const snapshot = get(makeAtom(ref));
+		if (snapshot == null) return;
+		const option = yield* getReactiveOption(snapshot);
+		return Option.getOrElse(option, () => void 0);
+	});
+	return Function.pipe(Atom.make(effect), Atom.map((result) => Result.getOrElse(result, () => void 0)));
+});
+/**
+* Atom family for a property of a ref's target object.
+* Resolves the ref (reactively) then projects the property atom, so it fires when the ref resolves or when
+* that property changes. Yields `undefined` while the target is unresolved.
+*/
+var refPropertyFamily = Atom.family((ref) => Atom.family((key) => {
+	return Atom.make((get) => {
+		const target = get(refWithReactiveFamily(ref));
+		return target ? get(propertyFamily(target)(key)) : void 0;
+	}).pipe(Atom.keepAlive);
+}));
+/**
+* Atom family for any ECHO entity (obj or relation) — returns a snapshot.
+*/
+var entityFamily = Atom.family((entity) => {
+	return Atom.make((get) => {
+		const unsubscribe = subscribe(entity, () => {
+			get.setSelf(getSnapshot(entity));
+		});
+		get.addFinalizer(() => unsubscribe());
+		return getSnapshot(entity);
+	}).pipe(Atom.keepAlive);
+});
+/**
+* Atom family for ECHO relations — returns a typed relation snapshot.
+*/
+var relationFamily = Atom.family((relation) => {
+	return Atom.make((get) => {
+		const unsubscribe = subscribe(relation, () => {
+			get.setSelf(getSnapshot(relation));
+		});
+		get.addFinalizer(() => unsubscribe());
+		return getSnapshot(relation);
+	}).pipe(Atom.keepAlive);
+});
+/**
+* Create a read-only snapshot atom for a reactive object or ref.
+* Updates automatically when the object is mutated.
+* For refs, subscribes to target object changes after loading.
+*/
+var makeAtom = (objOrRef) => {
+	if (isRef(objOrRef)) return refFamily(objOrRef);
+	const obj = objOrRef;
+	assertArgument(isEntity(obj), "obj", "Object must be a reactive object");
+	return objectFamily(obj);
+};
+/**
+* Create a read-only atom for a specific property of a reactive object, or of a ref's target.
+* Only fires updates when the property value actually changes. Given a ref, the atom resolves the target
+* first and yields `undefined` until it loads.
+*/
+var makeProperty = (objOrRef, key) => {
+	if (isRef(objOrRef)) return refPropertyFamily(objOrRef)(key);
+	const obj = objOrRef;
+	assertArgument(isEntity(obj), "obj", "Object must be a reactive object");
+	return propertyFamily(obj)(key);
+};
+/**
+* Like `makeAtom` but returns the live reactive object instead of a snapshot.
+* Prefer `makeAtom` (snapshot) unless you need the live Obj for generic mutations.
+*/
+var makeWithReactive = (objOrRef) => {
+	if (isRef(objOrRef)) return refWithReactiveFamily(objOrRef);
+	const obj = objOrRef;
+	assertArgument(isEntity(obj), "obj", "Object must be a reactive object");
+	return objectWithReactiveFamily(obj);
+};
+/**
+* Create a read-only snapshot atom for any ECHO entity (obj or relation).
+* Updates automatically when the entity is mutated.
+*/
+var makeEntity = (entity) => {
+	assertArgument(isEntity(entity), "entity", "Must be a reactive ECHO entity");
+	return entityFamily(entity);
+};
+/**
+* Create a read-only snapshot atom for a reactive relation.
+* Updates automatically when the relation is mutated.
+*/
+var makeRelation = (relation) => {
+	assertArgument(isEntity(relation), "relation", "Must be a reactive ECHO relation");
+	return relationFamily(relation);
+};
+/**
+* Atom family for an entity's label string.
+* Fires only when the computed label actually changes, not on every entity mutation.
+*/
+var labelAtomFamily = Atom.family((entity) => {
+	return Atom.make((get) => {
+		let previous = getLabel(entity);
+		const unsubscribe = subscribe(entity, () => {
+			const next = getLabel(entity);
+			if (next !== previous) {
+				previous = next;
+				get.setSelf(next);
+			}
+		});
+		get.addFinalizer(() => unsubscribe());
+		return previous;
+	}).pipe(Atom.keepAlive);
+});
+/**
+* Create a read-only atom for the label of a reactive ECHO entity.
+* Re-evaluates on entity mutation; only propagates when the label string changes.
+*/
+var makeLabelAtom = (entity) => {
+	assertArgument(isEntity(entity), "entity", "Must be a reactive ECHO entity");
+	return labelAtomFamily(entity);
+};
+//#endregion
+//#region src/internal/Obj/clone.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Obj/clone.ts";
+/**
+* Clones an object or relation.
+* By default this does not clone referenced objects, only the properties in the object; pass `opts.deep`
+* to recurse into refs (see {@link Obj.CloneOptions}).
+* @returns A new object with the same schema and properties.
+*/
+var clone = (obj, opts) => cloneInner(obj, opts, obj, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+/**
+* Recursive clone worker threaded with two cycle-guard structures:
+* - `cache`: id → already-finished clone; reused when the same object appears more than once in a DAG.
+* - `inProgress`: ids of objects whose clone is currently being computed; a ref back into this set means
+*   a true cycle — the original ref is kept rather than recursing forever.
+*/
+var cloneInner = (obj, opts, root, cache, inProgress) => {
+	if (cache.has(obj.id)) return cache.get(obj.id);
+	inProgress.add(obj.id);
+	const { id, ...data } = obj;
+	const typeEntity = getType(obj);
+	const schema = typeEntity != null ? getStaticTypeSchema(typeEntity) : getSchema(obj);
+	invariant(schema != null, "Object should have a type or schema", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 48,
+		S: void 0,
+		A: ["schema != null", "'Object should have a type or schema'"]
+	});
+	const mapRef = (value, recurse) => {
+		if (Ref.isRef(value)) {
+			const target = value.target;
+			if (target != null && !inProgress.has(target.id) && (opts?.deep === "all" || opts?.deep === "parent" && isChildOf(target, root))) return Ref.make(cloneInner(target, opts, root, cache, inProgress));
+			return value;
+		}
+		return recurse(value);
+	};
+	const props = deepMapValues(data, mapRef);
+	if (opts?.retainId) props.id = id;
+	const result = makeObject(schema, props, deepMapValues(getMeta(obj), mapRef), typeEntity);
+	inProgress.delete(obj.id);
+	cache.set(obj.id, result);
+	return result;
+};
+/**
+* Whether `entity`'s parent chain reaches `root` — i.e. it is an owned descendant that cascade-deletes with
+* the root. Walks the `ParentId` back-links (a finite tree); guarded against cycles defensively.
+*/
+var isChildOf = (entity, root) => {
+	const seen = /* @__PURE__ */ new Set();
+	assumeType(entity);
+	let parent = entity[ParentId];
+	while (parent != null && !seen.has(parent)) {
+		if (parent.id === root.id) return true;
+		seen.add(parent);
+		parent = parent[ParentId];
+	}
+	return false;
+};
+//#endregion
+//#region src/internal/Type/manipulation.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Type/manipulation.ts";
+var addFieldsToSchema = (schema, fields) => {
+	const schemaExtension = Schema.partial(Schema.Struct(fields));
+	return Schema.extend(schema, schemaExtension).annotations(schema.ast.annotations);
+};
+var updateFieldsInSchema = (schema, fields) => {
+	const ast = schema.ast;
+	invariant(SchemaAST.isTypeLiteral(ast), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 26,
+		S: void 0,
+		A: ["SchemaAST.isTypeLiteral(ast)", ""]
+	});
+	const updatedProperties = [...ast.propertySignatures];
+	const propertiesToUpdate = Schema.partial(Schema.Struct(fields)).ast.propertySignatures;
+	for (const property of propertiesToUpdate) {
+		const index = updatedProperties.findIndex((p) => p.name === property.name);
+		if (index !== -1) updatedProperties[index] = property;
+		else updatedProperties.push(property);
+	}
+	return Schema.make(new SchemaAST.TypeLiteral(updatedProperties, ast.indexSignatures, ast.annotations));
+};
+var removeFieldsFromSchema = (schema, fieldNames) => {
+	return Schema.make(SchemaAST.omit(schema.ast, fieldNames)).annotations(schema.ast.annotations);
+};
+var updateFieldNameInSchema = (schema, { before, after }) => {
+	const ast = schema.ast;
+	invariant(SchemaAST.isTypeLiteral(ast), void 0, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 54,
+		S: void 0,
+		A: ["SchemaAST.isTypeLiteral(ast)", ""]
+	});
+	return Schema.make(new SchemaAST.TypeLiteral(ast.propertySignatures.map((p) => p.name === before ? new SchemaAST.PropertySignature(after, p.type, p.isOptional, p.isReadonly, p.annotations) : p), ast.indexSignatures, ast.annotations));
+};
+/**
+* Persistent representation of a schema.
+*/
+var TypeSchema = Schema.Struct({
+	name: Schema.optional(Schema.String),
+	jsonSchema: JsonSchemaType
+}).pipe(LabelAnnotation.set(["name"]), IconAnnotation.set({
+	icon: "ph--database--regular",
+	hue: "green"
+}), EchoTypeKindSchema(TypeMetaSchemaDXN));
+//#endregion
+export { setMetaOwner as $, isVersion as A, TypeMetaSchemaDXN as B, objectFromJSON as C, sortByLabel as Ct, compareVersions as D, isProjection as Dt, setRefResolverOnData as E, ProjectionTypeId as Et, getDXNForRelationSchemaRef as F, prepareDecodedTypedTarget as G, makeDecodedEntityLive as H, makeRelationType as I, SchemaValidator as J, prepareTypedTarget as K, EchoObjectSchema as L, versionValid as M, EchoTypeKindSchema as N, decodeVersion as O, makeProjection as Ot, EchoRelationSchema as P, getEchoRoot as Q, makeObjectType as R, matchesTag as S, sort as St, objectToJSON as T, VersionTypeId as Tt, makeObject as U, makeEchoTypeSchema as V, TypedReactiveHandler as W, ReactiveArray as X, checkIdNotPresentOnSchema as Y, objectData as Z, makeTypedEntityClass as _, defineHiddenProperty as _t, updateFieldsInSchema as a, enterChangeContext as at, filterMatchValue as b, assertObjectModel as bt, makeEntity as c, isInChangeContext as ct, makeRelation as d, batchEvents as dt, MutationOutsideChangeContextError as et, makeWithReactive as f, emitEvent as ft, createObject as g, getStrongDependencyUris as gt, isDeleted as h, getStrongDependencies as ht, updateFieldNameInSchema as i, clearPendingNotifications as it, version as j, encodeVersion as k, RawObject as kt, makeLabelAtom as l, queueNotification as lt, setValue as m, typedJsonSerializer as mt, addFieldsToSchema as n, createPropertyDeleteError as nt, clone as o, executeChange as ot, getSnapshot as p, attachTypedJsonSerializer as pt, validateAndReactifyTarget as q, removeFieldsFromSchema as r, createPropertySetError as rt, makeAtom as s, hasPendingNotifications as st, TypeSchema as t, createArrayMethodError as tt, makeProperty as u, queueOwnerNotification as ut, compareTypenameStrings as v, prettyFilter as vt, objectStructureToJson as w, sortByTypename as wt, matchMetaKey as x, compare as xt, filterMatchEntity as y, prettyQuery as yt, normalizeSchema as z };
+
+//# sourceMappingURL=chunk-internal.mjs.map