@dxos/echo 0.10.0 → 0.11.0

package/dist/lib/Obj.mjs

@@ -0,0 +1,660 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { c as getKeys$1, l as getMetaChecked, o as addTag$1, s as deleteKeys$1, u as removeTag$1 } from "./chunk-atom-snapshot.mjs";
+import { A as isVersion$1, C as objectFromJSON, Ct as sortByLabel$1, D as compareVersions$1, M as versionValid$1, O as decodeVersion$1, St as sort$1, T as objectToJSON, Tt as VersionTypeId$1, U as makeObject, f as makeWithReactive, h as isDeleted$1, j as version$1, k as encodeVersion$1, l as makeLabelAtom, m as setValue$1, o as clone$1, p as getSnapshot$1, s as makeAtom, u as makeProperty, wt as sortByTypename$1 } from "./chunk-internal.mjs";
+import { a as ANY_OBJECT_VERSION, i as ANY_OBJECT_TYPENAME } from "./chunk-util.mjs";
+import { C as getBranch$1, Ct as getTypename$1, Dt as setLabel$1, Gt as MetaId, Lt as getType$1, Mt as ParentId, S as isInstanceOf, St as getTypeURI$1, T as getUri, Tt as setDescription$1, bt as getTypeAnnotation, ct as getDescription$1, ft as getIcon$1, mt as getLabelProperty, pt as getLabel$1, rt as TypeAnnotationId, w as getDatabase$1 } from "./chunk-Database.mjs";
+import { GetReactiveError } from "./Err.mjs";
+import { C as getProxyTarget, g as subscribe$1, h as change, w as isProxy } from "./chunk-ref.mjs";
+import { getSchema } from "./Type.mjs";
+import { Kind, KindId, SnapshotKindId } from "./Entity.mjs";
+import { isRef } from "./Ref.mjs";
+import { EntityId } from "@dxos/keys";
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { assertArgument, invariant } from "@dxos/invariant";
+import { SchemaEx } from "@dxos/effect";
+import { assumeType, deepMapValues } from "@dxos/util";
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as Exit from "effect/Exit";
+import * as Utils from "effect/Utils";
+//#region src/Obj.ts
+var Obj_exports = /* @__PURE__ */ __exportAll({
+	ID: () => ID,
+	Meta: () => Meta,
+	Parent: () => Parent,
+	Unknown: () => Unknown,
+	VersionTypeId: () => VersionTypeId,
+	addTag: () => addTag,
+	atom: () => atom,
+	atomProperty: () => atomProperty,
+	atomReactive: () => atomReactive,
+	clone: () => clone,
+	compareVersions: () => compareVersions,
+	decodeVersion: () => decodeVersion,
+	deleteKeys: () => deleteKeys,
+	encodeVersion: () => encodeVersion,
+	fromJSON: () => fromJSON,
+	getBranch: () => getBranch,
+	getDatabase: () => getDatabase,
+	getDescription: () => getDescription,
+	getIcon: () => getIcon,
+	getKeys: () => getKeys,
+	getLabel: () => getLabel,
+	getMeta: () => getMeta,
+	getParent: () => getParent,
+	getReactive: () => getReactive,
+	getReactiveOption: () => getReactiveOption,
+	getReactiveOrThrow: () => getReactiveOrThrow,
+	getReactiveOrUndefined: () => getReactiveOrUndefined,
+	getSnapshot: () => getSnapshot,
+	getType: () => getType,
+	getTypeURI: () => getTypeURI,
+	getTypename: () => getTypename,
+	getURI: () => getURI,
+	getValue: () => getValue,
+	getVersion: () => getVersion,
+	instanceOf: () => instanceOf,
+	isDeleted: () => isDeleted,
+	isObject: () => isObject,
+	isSnapshot: () => isSnapshot,
+	isVersion: () => isVersion,
+	labelAtom: () => labelAtom,
+	labelProperty: () => labelProperty,
+	make: () => make,
+	removeTag: () => removeTag,
+	setDescription: () => setDescription,
+	setLabel: () => setLabel,
+	setParent: () => setParent,
+	setValue: () => setValue,
+	snapshotOf: () => snapshotOf,
+	sort: () => sort,
+	sortByLabel: () => sortByLabel,
+	sortByTypename: () => sortByTypename,
+	subscribe: () => subscribe,
+	toJSON: () => toJSON,
+	update: () => update,
+	updateFrom: () => updateFrom,
+	version: () => version,
+	versionValid: () => versionValid
+});
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
+/**
+* Runtime Effect schema for any ECHO object.
+* Use for validation, parsing, or as a reference target for collections.
+*
+* NOTE: `Schema.is(Type.Obj)` does STRUCTURAL validation only (checks for `id` field).
+* Use `Obj.isObject()` for proper ECHO instance type guards that check the KindId brand.
+*
+* @example
+* ```ts
+* // Structural type guard (accepts any object with id field)
+* if (Schema.is(Type.Obj)(unknownValue)) { ... }
+*
+* // ECHO instance type guard (checks KindId brand)
+* if (Obj.isObject(unknownValue)) { ... }
+*
+* // Reference to any object type
+* class Collection extends Type.makeObject<Collection>(DXN.make('com.example.type.collection', '0.1.0'))(
+*   Schema.Struct({ objects: Schema.Array(Ref.Ref(Obj.Unknown)) }),
+* ) {}
+* ```
+*/
+var Unknown = Schema.Struct({ id: Schema.String }).pipe(Schema.extend(Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+})), Schema.annotations({ [TypeAnnotationId]: {
+	kind: Kind.Object,
+	typename: ANY_OBJECT_TYPENAME,
+	version: ANY_OBJECT_VERSION
+} }));
+var defaultMeta = () => ({
+	keys: [],
+	tags: [],
+	annotations: {}
+});
+function make(input, props) {
+	const schema = getSchema(input);
+	assertArgument(getTypeAnnotation(schema)?.kind === Kind.Object, "schema", "Expected an object schema");
+	let meta = void 0;
+	if (props[MetaId] != null) {
+		meta = {
+			...defaultMeta(),
+			...props[MetaId]
+		};
+		delete props[MetaId];
+	}
+	const filterUndefined = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== void 0));
+	for (const sym of Object.getOwnPropertySymbols(props)) {
+		const value = props[sym];
+		if (value !== void 0) filterUndefined[sym] = value;
+	}
+	return makeObject(schema, filterUndefined, {
+		...defaultMeta(),
+		...meta
+	}, input);
+}
+/**
+* Determine if object is an ECHO object.
+*/
+var isObject = (obj) => {
+	assumeType(obj);
+	return typeof obj === "object" && obj !== null && obj[KindId] === Kind.Object;
+};
+var isSnapshot = (obj) => {
+	assumeType(obj);
+	return typeof obj === "object" && obj !== null && obj[SnapshotKindId] === Kind.Object;
+};
+/**
+* Subscribe to object updates.
+* The callback is called synchronously when the object is modified.
+* Only accepts reactive objects (not snapshots).
+* @returns Unsubscribe function.
+*/
+var subscribe = (obj, callback) => {
+	return subscribe$1(obj, callback);
+};
+/**
+* Returns an immutable snapshot of an object.
+* The snapshot is branded with SnapshotKindId instead of KindId,
+* making it distinguishable from the reactive object at the type level.
+*/
+var getSnapshot = getSnapshot$1;
+/**
+* Returns the reactive version of an object from the database, given its snapshot.
+* Inverse of `Obj.getSnapshot`.
+*
+* Uses `Obj.getDatabase` internally to get the database from the snapshot,
+* then resolves the reactive object by ID.
+*
+* @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).
+* @returns Effect that succeeds with the reactive object, or fails with `GetReactiveError`.
+* @example
+* ```ts
+* const snapshot = Obj.getSnapshot(obj);
+* const reactive = Obj.getReactive(snapshot).pipe(
+*   Effect.runSync
+* );
+* ```
+*/
+var getReactive = (snapshot) => Effect.gen(function* () {
+	const db = getDatabase$1(snapshot);
+	if (!db) return yield* Effect.fail(new GetReactiveError({
+		reason: "no-database",
+		snapshotId: snapshot.id
+	}));
+	const obj = db.getObjectById(snapshot.id);
+	if (!obj) return yield* Effect.fail(new GetReactiveError({
+		reason: "object-not-found",
+		snapshotId: snapshot.id
+	}));
+	return obj;
+});
+/**
+* Like `Obj.getReactive` but returns `Option.none()` instead of failing when the object
+* cannot be resolved (no database, object not found).
+*
+* @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).
+* @returns Effect that succeeds with `Option.some(reactive)` or `Option.none()`.
+*/
+var getReactiveOption = (snapshot) => getReactive(snapshot).pipe(Effect.map(Option.some), Effect.catchAll(() => Effect.succeed(Option.none())));
+/**
+* Synchronous version of `Obj.getReactive`. Returns the reactive object or throws
+* `GetReactiveError` when the object cannot be resolved (no database, object not found).
+*
+* @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).
+* @returns The reactive object.
+* @throws {Err.GetReactiveError} When the object cannot be resolved.
+*/
+var getReactiveOrThrow = (snapshot) => Effect.runSync(getReactive(snapshot));
+/**
+* Synchronous version of `Obj.getReactive` that returns `undefined` instead of throwing.
+* Accepts `undefined` input so callers can pass the result of `useObject` directly.
+*
+* @param snapshot - A snapshot of the object (from `Obj.getSnapshot` or `useObject`), or `undefined`.
+* @returns The reactive object, or `undefined` if the snapshot is `undefined` or unresolvable.
+*/
+var getReactiveOrUndefined = (snapshot) => {
+	if (snapshot === void 0) return;
+	return Effect.runSyncExit(getReactive(snapshot)).pipe(Exit.match({
+		onSuccess: (value) => value,
+		onFailure: () => void 0
+	}));
+};
+/**
+* Clones an object or relation.
+* This does not clone referenced objects, only the properties in the object.
+* @returns A new object with the same schema and properties.
+*/
+var clone = clone$1;
+/**
+* Perform mutations on an echo object within a controlled context.
+*
+* All mutations within the callback are batched and trigger a single notification
+* when the callback completes. Direct mutations outside of `Obj.update` will throw
+* an error for echo objects.
+*
+* This function also works with nested objects within echo objects (e.g., Template structs)
+* that are reactive at runtime.
+*
+* @param obj - The echo object to mutate. Use `Relation.update` for relations.
+* @param callback - The callback that performs mutations on the object.
+*
+* @example
+* ```ts
+* const person = Obj.make(Person, { name: 'John', age: 25 });
+*
+* // Mutate within Obj.update
+* Obj.update(person, (obj) => {
+*   obj.name = 'Jane';
+*   obj.age = 30;
+* });
+* // ONE notification fires here
+*
+* // Direct mutation throws
+* person.name = 'Bob'; // Error: Cannot modify outside Obj.update()
+* ```
+*
+* Note: Only accepts objects. Use `Relation.update` for relations.
+*/
+var update = (obj, callback) => {
+	change(obj, callback);
+	return obj;
+};
+/**
+* Get a deeply nested property from an object.
+*
+* Similar to lodash.get and getDeep from @dxos/util.
+* This is the complementary function to setValue.
+* Accepts both reactive objects and snapshots.
+*
+* @param obj - The ECHO object to get the property from.
+* @param path - Path to the property (array of keys).
+* @returns The value at the path, or undefined if not found.
+*
+* @example
+* ```ts
+* const person = Obj.make(Person, {
+*   name: 'John',
+*   addresses: [{ street: '123 Main St' }]
+* });
+*
+* Obj.getValue(person, ['addresses', 0, 'street']); // '123 Main St'
+* Obj.getValue(person, ['addresses', 1, 'street']); // undefined
+* ```
+*/
+var getValue = (obj, path) => {
+	return SchemaEx.getValue(obj, SchemaEx.createJsonPath(path));
+};
+/**
+* Set a deeply nested property on an object, using the object's schema to determine
+* whether to initialize nested data as an empty object or array.
+*
+* Similar to lodash.set and setDeep from @dxos/util, but schema-aware.
+* Must be called within an `Obj.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*
+* @param obj - The mutable ECHO object to set the property on.
+* @param path - Path to the property (array of keys).
+* @param value - Value to set.
+* @returns The value that was set.
+*
+* @example
+* ```ts
+* const person = Obj.make(Person, { name: 'John' });
+* // Person schema has: addresses: Schema.Array(Address)
+* Obj.update(person, (obj) => {
+*   Obj.setValue(obj, ['addresses', 0, 'street'], '123 Main St');
+* });
+* // Creates: person.addresses = [{ street: '123 Main St' }]
+* ```
+*/
+var setValue = setValue$1;
+var ID = EntityId;
+/**
+* Test if an object is an instance of a given object type.
+*
+* @example
+* ```ts
+* const john = Obj.make(Person, { name: 'John' });
+* const isPerson = Obj.instanceOf(Person);
+* if (isPerson(john)) {
+*   // john is Person
+* }
+* ```
+*
+* Only accepts `Type.AnyObj` — use `Relation.instanceOf` for relations and
+* `Type.isType(value)` to test for `Type.Type` meta-schema entities.
+*/
+var instanceOf = ((...args) => {
+	if (args.length === 1) return (entity) => isInstanceOf(args[0], entity);
+	return isInstanceOf(args[0], args[1]);
+});
+/**
+* Test if a snapshot is an instance of a schema.
+* Mirrors `instanceOf` but only accepts values branded with SnapshotKindId.
+* Use when the value is known to be a snapshot (e.g. from `getSnapshot` or `useObject`).
+*
+* @example
+* ```ts
+* const snapshot = Obj.getSnapshot(person);
+* if (Obj.snapshotOf(Person, snapshot)) {
+*   // snapshot is Obj.Snapshot<Person>
+* }
+* ```
+*/
+var snapshotOf = ((...args) => {
+	const check = (entity) => entity != null && typeof entity === "object" && SnapshotKindId in entity && isInstanceOf(args[0], entity);
+	if (args.length === 1) return (entity) => check(entity);
+	return check(args[1]);
+});
+/**
+* Get the URI of the object.
+* Accepts both reactive objects and snapshots.
+*
+* @param options.prefer - Controls the URI form (see {@link GetURIOptions}).
+*/
+var getURI = (entity, options) => {
+	assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
+	return getUri(entity, options);
+};
+/**
+* @returns The DXN of the object's type.
+* @example dxn:com.example.type.person:1.0.0
+* @throws If the object is missing its type (corrupted object).
+*/
+var getTypeURI = (obj) => {
+	const type = getTypeURI$1(obj);
+	invariant(type != null, "Corrupted object: missing type.", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 542,
+		S: void 0,
+		A: ["type != null", "'Corrupted object: missing type.'"]
+	});
+	return type;
+};
+/**
+* Get the type entity (`Type.AnyObj`) the object was created from.
+*
+* Returns `undefined` when the object's type isn't registered in this runtime
+* (e.g. a freshly deserialized snapshot whose type entity hasn't been wired
+* up yet, or an object loaded from storage before its schema is known). To
+* get the Effect Schema from the returned entity, use `Type.getSchema(...)`.
+*/
+var getType = (obj) => getType$1(obj);
+/**
+* @returns The typename of the object's type.
+* Accepts both reactive objects and snapshots.
+* @example `com.example.type.person`
+*/
+var getTypename = (entity) => getTypename$1(entity);
+/**
+* Get the database the object belongs to.
+* Accepts both reactive objects and snapshots.
+*
+* @idiom org.dxos.echo.objGetDatabase
+*   applies: Reaching an object's database — to query, add, or remove — when the surrounding Space is not otherwise needed
+*   instead-of: `getSpace(obj)?.db` (resolving the whole Space just to read its `.db`)
+*   uses: {@link getDatabase}
+*/
+var getDatabase = (entity) => getDatabase$1(entity);
+/**
+* Get the branch this object instance is bound to: `'main'` for the canonical object, or the branch of
+* a `db.branch()` independent instance. The branch is a property of the instance — two instances of the
+* same object id on different branches each report their own branch.
+*/
+var getBranch = (obj) => getBranch$1(obj);
+/**
+* Get an immutable snapshot of the object at the given historical heads — a detached instance, not a
+* pin on the live object. Only the surface that asks for it sees the historical value; the live
+* object and every other surface are unaffected. The functional alternative to a read-time-travel pin.
+*/
+var getVersion = (obj, heads) => {
+	const db = getDatabase(obj);
+	invariant(db, "object is not bound to a database", {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 594,
+		S: void 0,
+		A: ["db", "'object is not bound to a database'"]
+	});
+	return db.getVersion(obj, heads);
+};
+/**
+* Property that accesses metadata for an entity.
+*
+* Alias for `Entity.Meta`.
+*/
+var Meta = MetaId;
+function getMeta(entity) {
+	return getMetaChecked(entity);
+}
+/**
+* @returns Foreign keys for the object from the specified source.
+* Accepts both reactive objects and snapshots.
+*/
+var getKeys = Function.dual(2, (entity, source) => getKeys$1(entity, source));
+/**
+* Delete all keys from the object for the specified source.
+* Must be called within an `Obj.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var deleteKeys = (entity, source) => deleteKeys$1(entity, source);
+/**
+* Add a tag to the object.
+* Must be called within an `Obj.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var addTag = (entity, tag) => addTag$1(entity, tag);
+/**
+* Remove a tag from the object.
+* Must be called within an `Obj.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var removeTag = (entity, tag) => removeTag$1(entity, tag);
+/**
+* Check if the object is deleted.
+* Accepts both reactive objects and snapshots.
+*/
+var isDeleted = (entity) => isDeleted$1(entity);
+/**
+* Get the label of the object.
+* Accepts both reactive objects and snapshots.
+*
+* @param options.fallback `'typename'` returns the object's typename when no
+*   label is set (e.g. `org.dxos.type.table`).
+*/
+var getLabel = (entity, options) => getLabel$1(entity, options);
+/**
+* Set the label of the object.
+* Must be called within an `Obj.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var setLabel = (entity, label) => setLabel$1(entity, label);
+/**
+* Get the description of the object.
+* Accepts both reactive objects and snapshots.
+*/
+var getDescription = (entity) => getDescription$1(entity);
+/**
+* Get the icon annotation for the object (or any entity), resolved via its type-level
+* `IconAnnotation`. Accepts both reactive entities and snapshots, and either Objects or
+* Relations — the underlying schema-based lookup works for both.
+*
+* Returns the full `{ icon, hue }` annotation; callers wanting just the icon name typically
+* write `Obj.getIcon(obj)?.icon ?? 'ph--cube--regular'`.
+*/
+var getIcon = (entity) => getIcon$1(entity);
+/**
+* Set the description of the object.
+* Must be called within an `Obj.update` callback.
+*
+* NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
+* parameters, so there is no compile-time error. Enforcement is runtime-only.
+*/
+var setDescription = (entity, description) => setDescription$1(entity, description);
+/**
+* Symbol to set parent when creating objects with `Obj.make`.
+* @example
+* ```ts
+* Obj.make(TestSchema.Person, {
+*   [Obj.Parent]: parentObject,
+*   name: 'John',
+* })
+* ```
+*/
+var Parent = ParentId;
+/**
+* Get the parent of an object.
+* The parent is always loaded together with the object.
+* Only objects are allowed to have a parent
+* @returns The parent object, or undefined if the object has no parent.
+*/
+var getParent = (entity) => {
+	assertArgument(isObject(entity) || isSnapshot(entity), "Expected an object");
+	assumeType(entity);
+	return entity[ParentId];
+};
+/**
+* Sets the parent of an object.
+* If a parent (or any transitive parent) is deleted, the object will be deleted.
+* Only objects are allowed to have a parent.
+*/
+var setParent = (entity, parent) => {
+	assertArgument(isObject(entity), "Expected an object");
+	assertArgument(parent === void 0 || isObject(parent), "Expected an object");
+	assumeType(entity);
+	assumeType(parent);
+	entity[ParentId] = parent;
+	return entity;
+};
+var valuesEqual = (left, right) => {
+	if (left === right) return true;
+	if (left === null || right === null) return left === right;
+	if (typeof left !== "object" || typeof right !== "object") return Utils.structuralRegion(() => Equal.equals(left, right));
+	if (isRef(left) && isRef(right)) return left.uri === right.uri;
+	if (isRef(left) || isRef(right)) return false;
+	if (Array.isArray(left) && Array.isArray(right)) {
+		if (left.length !== right.length) return false;
+		for (let index = 0; index < left.length; index++) if (!valuesEqual(left[index], right[index])) return false;
+		return true;
+	}
+	if (Array.isArray(left) || Array.isArray(right)) return false;
+	const leftRecord = left;
+	const rightRecord = right;
+	const keys = /* @__PURE__ */ new Set([...Object.keys(leftRecord).filter((key) => key !== "id"), ...Object.keys(rightRecord).filter((key) => key !== "id")]);
+	for (const key of keys) {
+		const leftHas = Object.hasOwn(leftRecord, key);
+		const rightHas = Object.hasOwn(rightRecord, key);
+		if (!valuesEqual(leftHas ? leftRecord[key] : void 0, rightHas ? rightRecord[key] : void 0)) return false;
+	}
+	return true;
+};
+/**
+* Breaks reactive proxies on assigned values so echo-db assignment accepts nested structs (same idea as link assignment).
+*/
+var prepareAssignValue = (value) => deepMapValues(value, (nested, recurse) => {
+	if (nested === null || typeof nested !== "object") return nested;
+	if (isRef(nested)) return nested;
+	if (Array.isArray(nested)) return recurse(nested);
+	if (isProxy(nested)) return recurse({ ...getProxyTarget(nested) });
+	return recurse(nested);
+});
+/**
+* For each key present on `source` (except `id`), assigns `target[key]` when the current value differs.
+* References are compared by target DXN; other values use Effect `Equal.equals` inside a structural region,
+* with recursive comparison for arrays and plain object-shaped property bags (excluding `id`).
+*
+* Must be called within an `Obj.update` callback.
+*
+* @returns Whether any property was updated.
+*/
+var updateFrom = (target, source, options) => {
+	assertArgument(isObject(target), "Expected an echo object target.");
+	assertArgument(isObject(source), "Expected an echo object source.");
+	let keys = Object.keys(source).filter((key) => key !== "id");
+	if (options?.include !== void 0) {
+		const include = new Set(options.include.map((key) => String(key)));
+		keys = keys.filter((key) => include.has(key));
+	}
+	if (options?.exclude !== void 0) {
+		const exclude = new Set(options.exclude.map((key) => String(key)));
+		keys = keys.filter((key) => !exclude.has(key));
+	}
+	let updated = false;
+	const sourceRecord = source;
+	const targetRecord = target;
+	for (const key of keys) {
+		if (!Object.hasOwn(sourceRecord, key)) continue;
+		const nextValue = sourceRecord[key];
+		if (valuesEqual(Object.hasOwn(targetRecord, key) ? targetRecord[key] : void 0, nextValue)) continue;
+		targetRecord[key] = prepareAssignValue(nextValue);
+		updated = true;
+	}
+	return updated;
+};
+/**
+* Converts object to its JSON representation.
+* Accepts both reactive objects and snapshots.
+*
+* The same algorithm is used when calling the standard `JSON.stringify(obj)` function.
+*/
+var toJSON = (entity) => objectToJSON(entity);
+/**
+* Creates an object from its json representation, performing schema validation.
+* References and schemas will be resolvable if the `refResolver` is provided.
+*
+* The function must be async to support resolving the schema as well as the relation endpoints.
+*
+* @param options.refResolver - Resolver for references. Produces hydrated references that can be resolved.
+* @param options.uri - Override object URI. Changes the result of `Obj.getURI`.
+* @param options.database - Database to associate with the object.
+* @param options.parent - Parent entity to associate with the object (used when the JSON has no `@parent`). Changes the result of `Obj.getParent`.
+*/
+var fromJSON = objectFromJSON;
+var sortByLabel = sortByLabel$1;
+var sortByTypename = sortByTypename$1;
+var sort = (...comparators) => sort$1(...comparators);
+var VersionTypeId = VersionTypeId$1;
+var isVersion = isVersion$1;
+var versionValid = versionValid$1;
+var compareVersions = compareVersions$1;
+var encodeVersion = encodeVersion$1;
+var decodeVersion = decodeVersion$1;
+/**
+* Returns the version of the object.
+* Accepts both reactive objects and snapshots.
+*/
+var version = (entity) => version$1(entity);
+/**
+* Create a reactive snapshot atom for an ECHO object or ref.
+* Use inside atom computations (e.g. `Atom.make((get) => get(Obj.atom(ref)))`) to subscribe
+* to a ref's target — the atom re-fires when the target loads or changes.
+*
+* @idiom org.dxos.echo.objAtomReactive
+*   applies: Subscribing to a ref's target inside an atom computation or a non-React reactive context
+*   instead-of: `ref.target` — synchronous and not reactive; returns `undefined` when the target isn't loaded yet and never notifies when it becomes available
+*   uses: {@link atom}
+*   related: org.dxos.echo-react.useObjectReactive
+*/
+var atom = makeAtom;
+var atomReactive = makeWithReactive;
+var atomProperty = makeProperty;
+var labelAtom = makeLabelAtom;
+var labelProperty = getLabelProperty;
+//#endregion
+export { ID, Meta, Parent, Unknown, VersionTypeId, addTag, atom, atomProperty, atomReactive, clone, compareVersions, decodeVersion, deleteKeys, encodeVersion, fromJSON, getBranch, getDatabase, getDescription, getIcon, getKeys, getLabel, getMeta, getParent, getReactive, getReactiveOption, getReactiveOrThrow, getReactiveOrUndefined, getSnapshot, getType, getTypeURI, getTypename, getURI, getValue, getVersion, instanceOf, isDeleted, isObject, isSnapshot, isVersion, labelAtom, labelProperty, make, removeTag, setDescription, setLabel, setParent, setValue, snapshotOf, sort, sortByLabel, sortByTypename, subscribe, Obj_exports as t, toJSON, update, updateFrom, version, versionValid };
+
+//# sourceMappingURL=Obj.mjs.map