@mengine/medeo-client 1.3.1-alpha.9 → 1.4.1-alpha.0

package/dist/{document-BLYcbv8E.js → document-CF-q_mRy.js}

@@ -1,7 +1,9 @@
 import { u as volumeSchema } from "./shared-iWnU2osE.js";
 import { Mirror, schema } from "loro-mirror";
 import { z } from "zod";
-import { LoroDoc } from "loro-crdt";
+import { LoroDoc, LoroMap, LoroMovableList, LoroText, UndoManager } from "loro-crdt";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
 import { produce } from "immer";
 //#region src/client/base64.ts
 function bytesToBase64(bytes) {
@@ -1181,7 +1183,7 @@ function toVideoDocument(draft) {
 			owner_id: draft.owner_id,
 			thumbnail_storage_key: draft.thumbnail_storage_key,
 			chat_session_id: draft.chat_session_id,
-			video_creation_settings: clone(draft.video_creation_settings),
+			video_creation_settings: clone$1(draft.video_creation_settings),
 			version: draft.version
 		},
 		timeline: draft.timeline == null ? void 0 : { unit_time_ms: draft.timeline.unit_time_ms },
@@ -1327,7 +1329,7 @@ function fromVideoDocument(document) {
 			duration_ms: view.durationMs,
 			unit_time_ms: document.timeline?.unit_time_ms ?? 33.333
 		},
-		video_creation_settings: clone(document.meta.video_creation_settings),
+		video_creation_settings: clone$1(document.meta.video_creation_settings),
 		chat_session_id: document.meta.chat_session_id,
 		main_track: draftTrack(mainTrack, view.absByPartId),
 		above_main_tracks: aboveTracks.map((t) => draftTrack(t, view.absByPartId)),
@@ -1359,25 +1361,25 @@ function toReadViewPartLibrary(partLibrary, durationMs, derivedFillerPartIds) {
 	for (const [partId, part] of Object.entries(partLibrary)) {
 		if (derivedFillerPartIds.has(partId)) continue;
 		if (part.video_clip != null) {
-			const clip = clone(part.video_clip);
+			const clip = clone$1(part.video_clip);
 			out[partId] = { video_clip: {
 				...clip,
 				duration_ms: effectiveVideoClipDurationMs(clip)
 			} };
 		} else if (part.speech != null) {
-			const speech = clone(part.speech);
+			const speech = clone$1(part.speech);
 			out[partId] = { speech: {
 				...speech,
 				duration_ms: speech.media_duration_ms
 			} };
 		} else if (part.caption != null) {
-			const caption = clone(part.caption);
+			const caption = clone$1(part.caption);
 			out[partId] = { caption: {
 				...caption,
 				duration_ms: caption.initial_duration_ms
 			} };
 		} else if (part.bgm != null) out[partId] = { bgm: {
-			...clone(part.bgm),
+			...clone$1(part.bgm),
 			duration_ms: durationMs
 		} };
 	}
@@ -1385,7 +1387,7 @@ function toReadViewPartLibrary(partLibrary, durationMs, derivedFillerPartIds) {
 }
 /** Deep-clone a part payload, dropping the derived read-view `duration_ms`. */
 function omitDurationMs(part) {
-	const { duration_ms: _drop, ...rest } = clone(part);
+	const { duration_ms: _drop, ...rest } = clone$1(part);
 	return rest;
 }
 /**
@@ -1410,7 +1412,7 @@ function withTrimWindowFromDuration(clip) {
 }
 /** Deep-clone a part payload, returning its `duration_ms` separately from the rest. */
 function splitDurationMs(part) {
-	const { duration_ms, ...rest } = clone(part);
+	const { duration_ms, ...rest } = clone$1(part);
 	return {
 		duration_ms,
 		rest
@@ -1428,11 +1430,11 @@ function draftTrack(track, absByPartId) {
 		}))
 	};
 }
-function clone(value) {
-	if (Array.isArray(value)) return value.map((item) => clone(item));
+function clone$1(value) {
+	if (Array.isArray(value)) return value.map((item) => clone$1(item));
 	if (value != null && typeof value === "object") {
 		const result = {};
-		for (const [key, child] of Object.entries(value)) result[key] = clone(child);
+		for (const [key, child] of Object.entries(value)) result[key] = clone$1(child);
 		return result;
 	}
 	return value;
@@ -1539,7 +1541,7 @@ function createId(value, label) {
 //#region ../medeo-dsl/src/json-values.ts
 const nativeObjectConstructorSource = Function.prototype.toString.call(Object);
 function isJsonObject(value) {
-	return isJsonValue(value, /* @__PURE__ */ new Set()) && !Array.isArray(value) && value !== null;
+	return typeof value === "object" && value !== null && !Array.isArray(value) && isJsonValue(value, /* @__PURE__ */ new Set());
 }
 function isJsonValue(value, ancestors) {
 	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
@@ -1782,9 +1784,8 @@ function entityToRow(entity) {
 //#region ../medeo-dsl/src/invariants.ts
 /**
 * Media variants own their Asset identity directly: a `physical-asset`
-* Relation may not bind them. Caption text is composed domain content, so
-* Captions do not bind Physical Assets either; the Relation vocabulary stays
-* open for future physical pipeline semantics.
+* Relation may not bind them. Caption may associate with a physical text Asset
+* independently of its AudioScript composition.
 */
 function validateMediaAssetIdentity(entity, index) {
 	return [...index.relationsOf(entity)].filter((relation) => relation.kind === "physical-asset").map(() => ({
@@ -1943,11 +1944,6 @@ function validatePhoneticComposition(phonetic, index, entities = []) {
 }
 function validateVariantComposition(variant, index, entities, kind) {
 	const issues = [];
-	if (kind === "caption" && ofKind([...index.relationsOf(variant)], "physical-asset").length > 0) issues.push({
-		code: "caption_physical_asset_forbidden",
-		entityId: variant.entityId,
-		message: "Caption text is composed from its AudioScript; Caption must not bind a Physical Asset"
-	});
 	const rows = {
 		entities: collectRelatedEntities([...entities, variant], index).entities.map((ref) => entityToRow(ref.current())),
 		relations: []
@@ -3307,6 +3303,670 @@ function videoSpeed(content, marker, placement) {
 	};
 }
 //#endregion
+//#region src/entity-crdt/json-containers.ts
+const atomicFields = new Set([
+	"sequence",
+	"sourceRange",
+	"targetRange",
+	"duration",
+	"extent",
+	"timeRemapping",
+	"textRange",
+	"external"
+]);
+const textFields = new Set(["text", "phonemeScript"]);
+const orderedFields = new Set([
+	"segments",
+	"selections",
+	"baseEntityIds"
+]);
+function equalJson(a, b) {
+	return canonicalJson(a) === canonicalJson(b);
+}
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+/** Compile only the changed fields; untouched containers retain their operation identity. */
+function writeObject(map, before, after) {
+	for (const key of Object.keys(before)) if (!Object.hasOwn(after, key)) map.delete(key);
+	for (const [key, value] of Object.entries(after)) {
+		if (equalJson(before[key], value)) continue;
+		if (atomicFields.has(key)) map.set(key, value);
+		else if (typeof value === "string" && textFields.has(key)) map.ensureMergeableText(key).update(value);
+		else if (Array.isArray(value) && orderedFields.has(key)) writeList(map.ensureMergeableMovableList(key), value);
+		else if (isJsonObject(value)) writeObject(map.ensureMergeableMap(key), isJsonObject(before[key]) ? before[key] : {}, value);
+		else map.set(key, value);
+	}
+}
+function itemKey(value) {
+	if (typeof value === "string") return value;
+	if (isJsonObject(value) && typeof value.segmentId === "string") return value.segmentId;
+	throw new Error("Collaborative lists require stable segmentId or unique string identities");
+}
+function readItem(list, index) {
+	const value = list.get(index);
+	return value instanceof LoroMap ? value.toJSON() : value;
+}
+function writeList(list, values) {
+	const wanted = values.map(itemKey);
+	if (new Set(wanted).size !== wanted.length) throw new Error("Duplicate collaborative list identity");
+	for (let index = list.length - 1; index >= 0; index--) if (!wanted.includes(itemKey(readItem(list, index)))) list.delete(index, 1);
+	for (let index = 0; index < values.length; index++) {
+		const value = values[index];
+		const key = wanted[index];
+		let found = -1;
+		for (let cursor = index; cursor < list.length; cursor++) if (itemKey(readItem(list, cursor)) === key) {
+			found = cursor;
+			break;
+		}
+		if (found === -1) if (isJsonObject(value)) writeObject(list.insertContainer(index, new LoroMap()), {}, value);
+		else list.insert(index, value);
+		else {
+			if (found !== index) list.move(found, index);
+			const current = list.get(index);
+			if (isJsonObject(value)) {
+				if (!(current instanceof LoroMap)) throw new Error("Collaborative list item changed type");
+				writeObject(current, current.toJSON(), value);
+			}
+		}
+	}
+}
+function requireText(map, path) {
+	let value = map;
+	for (const part of path) if (value instanceof LoroMap && typeof part === "string") value = value.get(part);
+	else if (value instanceof LoroMovableList && typeof part === "number") value = value.get(part);
+	else throw new Error("Invalid collaborative text path");
+	if (!(value instanceof LoroText)) throw new Error("Field is not collaborative text");
+	return value;
+}
+//#endregion
+//#region src/entity-crdt/ordering.ts
+/** Domain order is scoped by membership; relation storage has no global order. */
+function entityOrderGroups(rows) {
+	const entities = new Map(rows.entities.map((row) => [String(row.entityId), row]));
+	const groups = /* @__PURE__ */ new Map();
+	for (const relation of rows.relations) {
+		const childKind = relation.relationKind === "timeline-track" ? "track" : relation.relationKind === "track-clip" ? "clip" : null;
+		if (!childKind) continue;
+		const endpoints = [relation.endpoint0EntityId, relation.endpoint1EntityId];
+		const childId = endpoints.find((id) => entities.get(id)?.entityKind === childKind);
+		if (!childId) continue;
+		const child = entities.get(childId);
+		if (typeof child.payload.order !== "number") continue;
+		const parent = endpoints.find((id) => id !== childId);
+		const values = groups.get(parent) ?? [];
+		values.push({
+			id: childId,
+			order: child.payload.order
+		});
+		groups.set(parent, values);
+	}
+	return new Map([...groups].map(([parent, values]) => [parent, values.sort((a, b) => a.order - b.order || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).map((item) => item.id)]));
+}
+function ordering(doc) {
+	const map = doc.getMap("medeo").get("ordering");
+	if (!(map instanceof LoroMap)) throw new Error("Missing native entity ordering");
+	return map;
+}
+/** Returns a derived ordinal while the stable element retains its native move identity. */
+function entityOrdinal(doc, root) {
+	let found;
+	for (const key of ordering(doc).keys()) {
+		const list = ordering(doc).get(key);
+		if (!(list instanceof LoroMovableList)) throw new Error("Invalid entity order container");
+		const index = list.toArray().indexOf(root);
+		if (index < 0) continue;
+		if (found !== void 0) throw new Error("Entity belongs to multiple ordered groups");
+		found = index;
+	}
+	return found;
+}
+/** Move existing elements, insert new identities and delete removed members on the causal list. */
+function writeEntityOrder(doc, group, roots, token) {
+	if (new Set(roots).size !== roots.length) throw new Error("Duplicate ordered entity identity");
+	const list = ordering(doc).ensureMergeableMovableList(group);
+	const before = list.toArray();
+	for (let index = list.length - 1; index >= 0; index--) if (!roots.includes(String(list.get(index)))) list.delete(index, 1);
+	roots.forEach((root, index) => {
+		const current = list.toArray().indexOf(root);
+		if (current < 0) list.insert(index, root);
+		else if (current !== index) list.move(current, index);
+	});
+	if (token) {
+		const editing = doc.getMap("medeo").get("editing");
+		for (const root of new Set([...before, ...roots])) {
+			if (before.indexOf(root) < 0 || before.indexOf(root) === roots.indexOf(root)) continue;
+			editing.get(root).get("changes").set(token, true);
+		}
+	}
+}
+//#endregion
+//#region src/entity-crdt/entity-document.ts
+const LORO_ENTITY_SCHEMA = "medeo.entities.loro.v1";
+const MATERIALIZE_ORIGIN = "medeo.materialize";
+function hash(value) {
+	return bytesToHex(sha256(new TextEncoder().encode(canonicalJson(value))));
+}
+function clone(value) {
+	return structuredClone(value);
+}
+function root(doc) {
+	return doc.getMap("medeo");
+}
+function requireMap(parent, key) {
+	const value = parent.get(key);
+	if (!(value instanceof LoroMap)) throw new Error(`Missing Loro map ${key}`);
+	return value;
+}
+function section(doc, key) {
+	return requireMap(root(doc), key);
+}
+function workspace(doc, id) {
+	const value = section(doc, "editing").get(id);
+	if (!(value instanceof LoroMap)) throw new Error(`Unknown entity editing identity ${id}`);
+	return value;
+}
+function content(map) {
+	return requireMap(map, "content").toJSON();
+}
+function entityContent(doc, key) {
+	const payload = content(workspace(doc, key));
+	const order = entityOrdinal(doc, key);
+	return order === void 0 ? payload : {
+		...payload,
+		order
+	};
+}
+function bases(map) {
+	const links = requireMap(map, "bases");
+	return links.keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0).map((key) => String(links.get(key)));
+}
+function owned(payload) {
+	const { baseEntityIds: _bases, ...fields } = payload;
+	return fields;
+}
+function baseIds(payload) {
+	const ids = payload.baseEntityIds ?? [];
+	if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string") || new Set(ids).size !== ids.length) throw new Error("baseEntityIds must contain unique entity IDs");
+	return ids;
+}
+function family(doc, id) {
+	const value = section(doc, "origins").get(id);
+	if (typeof value === "string") return value;
+	for (const [key, value] of currentIds(doc)) if (value === id) return key;
+	throw new Error(`Unknown entity ${id}`);
+}
+function currentIds(doc) {
+	const result = /* @__PURE__ */ new Map();
+	for (const key of section(doc, "editing").keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0)) {
+		const map = workspace(doc, key);
+		if (map.get("deleted") === true) continue;
+		const tokens = requireMap(map, "changes").keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+		const initial = section(doc, "entities").get(key);
+		const { id: _id, kind: _kind, ...initialPayload } = isJsonObject(initial) ? initial : {};
+		const payload = entityContent(doc, key);
+		const changed = tokens.length > 0 || initial !== void 0 && !equalJson(owned(initialPayload), payload);
+		result.set(key, changed ? `entity_${hash([
+			key,
+			tokens,
+			payload
+		])}` : key);
+	}
+	return result;
+}
+function currentId(doc, id, ids = currentIds(doc)) {
+	const resolved = ids.get(family(doc, id));
+	if (resolved === void 0) throw new Error(`Referenced entity ${id} was deleted`);
+	return resolved;
+}
+/** Plain domain objects assembled from native Loro state, never a second writable authority. */
+function readEntityDocument(doc, allowSelectionConflicts = false) {
+	if (root(doc).get("schema") !== "medeo.entities.loro.v1") throw new Error("Document has no Loro entity state");
+	const ids = currentIds(doc);
+	const entities = [...ids].map(([key, entityId]) => {
+		const map = workspace(doc, key);
+		const baseEntityIds = bases(map).map((id) => currentId(doc, id, ids));
+		return {
+			entityId: createEntityId(entityId),
+			entityKind: map.get("kind"),
+			payload: {
+				...entityContent(doc, key),
+				...baseEntityIds.length ? { baseEntityIds } : {}
+			}
+		};
+	});
+	const relations = [];
+	for (const key of section(doc, "relations").keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0)) {
+		const map = section(doc, "relations").get(key);
+		if (!(map instanceof LoroMap) || map.get("deleted") === true) continue;
+		const original = map.get("identity");
+		if (original.endpoints.some((id) => !ids.has(family(doc, id)))) continue;
+		const endpoints = original.endpoints.map((id) => currentId(doc, id, ids));
+		const relationId = equalJson(endpoints, original.endpoints) ? key : `relation_${hash([key, endpoints])}`;
+		relations.push({
+			relationId: createRelationId(relationId),
+			relationKind: original.kind,
+			endpoint0EntityId: createEntityId(endpoints[0]),
+			endpoint1EntityId: createEntityId(endpoints[1]),
+			metadata: requireMap(map, "metadata").toJSON(),
+			trace: requireMap(map, "trace").toJSON()
+		});
+	}
+	const project = {};
+	for (const [key, value] of Object.entries(section(doc, "attachments").toJSON())) {
+		if (typeof value !== "string") throw new Error(`Invalid project attachment ${key}`);
+		project[key] = currentId(doc, value, ids);
+	}
+	const state = {
+		rows: {
+			entities,
+			relations
+		},
+		project
+	};
+	if (!allowSelectionConflicts) for (const [key, id] of ids) {
+		const fingerprint = selectionFingerprint(state.rows, id);
+		if (fingerprint !== void 0 && workspace(doc, key).get("selectionBaseline") !== fingerprint) throw new Error(`Caption text selection conflict at ${id}: source text changed; revise its text ranges explicitly`);
+	}
+	return state;
+}
+/** Native editing containers survive domain version changes and merge independently. */
+var LoroEntityDocument = class LoroEntityDocument {
+	doc;
+	validate;
+	undoManager;
+	constructor(doc, validate) {
+		this.doc = doc;
+		this.validate = validate;
+		this.undoManager = new UndoManager(doc, {
+			mergeInterval: 0,
+			excludeOriginPrefixes: [MATERIALIZE_ORIGIN]
+		});
+	}
+	/** Open a causal snapshot using the same Loro runtime as the compiler. */
+	static fromSnapshot(snapshot, validate) {
+		const doc = new LoroDoc();
+		doc.import(snapshot);
+		readEntityDocument(doc);
+		return new LoroEntityDocument(doc, validate);
+	}
+	static create(rows, project = {}, peerId) {
+		const doc = new LoroDoc();
+		if (peerId !== void 0) doc.setPeerId(peerId);
+		root(doc).set("schema", LORO_ENTITY_SCHEMA);
+		for (const name of [
+			"editing",
+			"entities",
+			"origins",
+			"relations",
+			"project",
+			"attachments",
+			"ordering"
+		]) root(doc).ensureMergeableMap(name);
+		for (const row of rows.entities) apply(doc, {
+			type: "create",
+			row
+		});
+		for (const row of rows.relations) apply(doc, {
+			type: "relation",
+			row
+		});
+		for (const [slot, entityId] of Object.entries(project)) apply(doc, {
+			type: "attach",
+			slot,
+			entityId
+		});
+		for (const [group, ids] of entityOrderGroups(rows)) writeEntityOrder(doc, group, ids);
+		const initialState = readEntityDocument(doc, true);
+		for (const row of initialState.rows.entities) {
+			const fingerprint = selectionFingerprint(initialState.rows, row.entityId);
+			if (fingerprint !== void 0) workspace(doc, row.entityId).set("selectionBaseline", fingerprint);
+		}
+		assertState(readEntityDocument(doc));
+		materialize(doc);
+		doc.commit({ origin: MATERIALIZE_ORIGIN });
+		return new LoroEntityDocument(doc);
+	}
+	snapshot() {
+		return readEntityDocument(this.doc);
+	}
+	relationsOf(entityId) {
+		const id = currentIds(this.doc).get(family(this.doc, entityId));
+		if (id === void 0) return [];
+		return this.snapshot().rows.relations.filter((row) => row.endpoint0EntityId === id || row.endpoint1EntityId === id);
+	}
+	getVersion(id) {
+		const entity = section(this.doc, "entities").get(id);
+		if (!isJsonObject(entity)) return void 0;
+		const { id: entityId, kind, ...payload } = entity;
+		if (typeof entityId !== "string") throw new Error("Invalid stored entity ID");
+		return {
+			entityId: createEntityId(entityId),
+			entityKind: kind,
+			payload
+		};
+	}
+	/** The callback and every domain validation execute on a causally complete fork first. */
+	transact(edit) {
+		const probe = this.doc.fork();
+		const draft = new LoroEntityDraft(probe);
+		edit(draft);
+		draft.captureSelectionBaselines();
+		const state = readEntityDocument(probe);
+		assertState(state);
+		this.validate?.(state);
+		materialize(probe);
+		const from = this.doc.oplogVersion();
+		for (const command of draft.commands) apply(this.doc, command);
+		this.doc.commit({ origin: "medeo.edit" });
+		materialize(this.doc);
+		this.doc.commit({ origin: MATERIALIZE_ORIGIN });
+		return this.doc.export({
+			mode: "update",
+			from
+		});
+	}
+	/** Import preserves native operation identities; projection errors never discard remote operations. */
+	import(update) {
+		this.doc.import(update);
+		const state = this.snapshot();
+		assertState(state);
+		this.validate?.(state);
+		materialize(this.doc);
+		this.doc.commit({ origin: MATERIALIZE_ORIGIN });
+	}
+	canUndo() {
+		return this.undoManager.canUndo();
+	}
+	canRedo() {
+		return this.undoManager.canRedo();
+	}
+	undo() {
+		return this.historyEdit(() => this.undoManager.undo());
+	}
+	redo() {
+		return this.historyEdit(() => this.undoManager.redo());
+	}
+	historyEdit(run) {
+		const before = this.snapshot();
+		if (!run()) return false;
+		const after = this.snapshot();
+		for (const row of after.rows.entities) {
+			const id = family(this.doc, row.entityId);
+			const previous = before.rows.entities.find((item) => family(this.doc, item.entityId) === id);
+			if (previous && !equalJson(owned(previous.payload), owned(row.payload))) workspace(this.doc, id).ensureMergeableMap("changes").set(globalThis.crypto.randomUUID(), true);
+		}
+		materialize(this.doc);
+		this.doc.commit({ origin: MATERIALIZE_ORIGIN });
+		return true;
+	}
+};
+var LoroEntityDraft = class {
+	doc;
+	commands = [];
+	selectedRoots = /* @__PURE__ */ new Set();
+	constructor(doc) {
+		this.doc = doc;
+	}
+	snapshot() {
+		return readEntityDocument(this.doc, true);
+	}
+	order(groupId, entityIds) {
+		this.record({
+			type: "order",
+			group: family(this.doc, groupId),
+			roots: entityIds.map((id) => family(this.doc, id)),
+			token: globalThis.crypto.randomUUID()
+		});
+	}
+	create(row) {
+		this.record({
+			type: "create",
+			row: clone(row)
+		});
+	}
+	delete(entityId) {
+		this.record({
+			type: "delete",
+			root: family(this.doc, entityId)
+		});
+	}
+	attach(slot, entityId) {
+		this.record({
+			type: "attach",
+			slot,
+			entityId
+		});
+	}
+	link(row) {
+		this.record({
+			type: "relation",
+			row: clone(row)
+		});
+	}
+	patchRelation(relationId, metadata, trace) {
+		this.record({
+			type: "relation-fields",
+			root: this.relationRoot(relationId),
+			metadata: clone(metadata),
+			trace: clone(trace)
+		});
+	}
+	unlink(relationId) {
+		this.record({
+			type: "unlink",
+			root: this.relationRoot(relationId)
+		});
+	}
+	relationRoot(relationId) {
+		const ids = currentIds(this.doc);
+		for (const key of section(this.doc, "relations").keys()) {
+			const map = section(this.doc, "relations").get(key);
+			if (!(map instanceof LoroMap) || map.get("deleted") === true) continue;
+			const identity = map.get("identity");
+			if (identity.endpoints.some((id) => !ids.has(family(this.doc, id)))) continue;
+			const endpoints = identity.endpoints.map((id) => currentId(this.doc, id, ids));
+			if ((equalJson(endpoints, identity.endpoints) ? key : `relation_${hash([key, endpoints])}`) === relationId) return key;
+		}
+		throw new Error(`Unknown relation ${relationId}`);
+	}
+	update(entityId, fields) {
+		const state = this.snapshot();
+		const id = createEntityId(currentId(this.doc, entityId));
+		const updates = /* @__PURE__ */ new Map();
+		for (const [field, value] of Object.entries(fields)) {
+			const owner = resolveEntityFieldOwner(state.rows, id, field);
+			const payload = updates.get(owner) ?? clone(state.rows.entities.find((row) => row.entityId === owner).payload);
+			updates.set(owner, {
+				...payload,
+				[field]: clone(value)
+			});
+		}
+		for (const [owner, payload] of updates) this.replaceOwned(owner, payload);
+	}
+	declare(entityId, fields) {
+		const row = this.snapshot().rows.entities.find((row) => row.entityId === currentId(this.doc, entityId));
+		if (!row) throw new Error(`Unknown entity ${entityId}`);
+		this.replaceOwned(entityId, {
+			...row.payload,
+			...fields
+		});
+	}
+	replaceOwned(entityId, payload) {
+		this.record({
+			type: "write",
+			root: family(this.doc, entityId),
+			payload: clone(payload),
+			token: globalThis.crypto.randomUUID()
+		});
+	}
+	editText(entityId, path, start, deleteCount, text) {
+		if (typeof path[0] !== "string") throw new Error("Text path must start with a field");
+		const owner = resolveEntityFieldOwner(this.snapshot().rows, createEntityId(currentId(this.doc, entityId)), path[0]);
+		this.record({
+			type: "text",
+			root: family(this.doc, owner),
+			path: [...path],
+			start,
+			deleteCount,
+			text,
+			token: globalThis.crypto.randomUUID()
+		});
+	}
+	captureSelectionBaselines() {
+		const state = this.snapshot();
+		for (const key of this.selectedRoots) {
+			const id = currentIds(this.doc).get(key);
+			if (id === void 0) continue;
+			const fingerprint = selectionFingerprint(state.rows, id);
+			if (fingerprint !== void 0) this.record({
+				type: "selection-baseline",
+				root: key,
+				fingerprint
+			});
+		}
+	}
+	record(command) {
+		if (command.type === "create") this.selectedRoots.add(command.row.entityId);
+		if (command.type === "write" && !equalJson(content(workspace(this.doc, command.root)).selections, command.payload.selections)) this.selectedRoots.add(command.root);
+		apply(this.doc, command);
+		this.commands.push(command);
+	}
+};
+function apply(doc, command) {
+	switch (command.type) {
+		case "selection-baseline":
+			workspace(doc, command.root).set("selectionBaseline", command.fingerprint);
+			break;
+		case "order":
+			writeEntityOrder(doc, command.group, command.roots, command.token);
+			break;
+		case "create": {
+			const row = command.row;
+			if (section(doc, "origins").get(row.entityId) !== void 0) throw new Error(`Duplicate entity ${row.entityId}`);
+			const map = section(doc, "editing").ensureMergeableMap(row.entityId);
+			map.set("kind", row.entityKind);
+			map.ensureMergeableMap("changes");
+			section(doc, "origins").set(row.entityId, row.entityId);
+			writeObject(map.ensureMergeableMap("content"), {}, owned(row.payload));
+			writeBases(doc, map, baseIds(row.payload));
+			break;
+		}
+		case "write": {
+			const map = workspace(doc, command.root);
+			const before = content(map);
+			const after = owned(command.payload);
+			if (!equalJson(before, after)) {
+				writeObject(map.ensureMergeableMap("content"), before, after);
+				map.ensureMergeableMap("changes").set(command.token, true);
+			}
+			writeBases(doc, map, baseIds(command.payload));
+			break;
+		}
+		case "text": {
+			const map = workspace(doc, command.root);
+			const text = requireText(map.ensureMergeableMap("content"), command.path);
+			if (!Number.isSafeInteger(command.start) || !Number.isSafeInteger(command.deleteCount) || command.start < 0 || command.deleteCount < 0 || command.start + command.deleteCount > Array.from(text.toString()).length) throw new Error("Invalid text edit range");
+			const start = text.convertPos(command.start, "unicode", "utf16");
+			const end = text.convertPos(command.start + command.deleteCount, "unicode", "utf16");
+			text.splice(start, end - start, command.text);
+			map.ensureMergeableMap("changes").set(command.token, true);
+			break;
+		}
+		case "delete":
+			workspace(doc, command.root).set("deleted", true);
+			break;
+		case "relation": {
+			const row = command.row;
+			const map = section(doc, "relations").ensureMergeableMap(row.relationId);
+			const identity = {
+				kind: row.relationKind,
+				endpoints: [row.endpoint0EntityId, row.endpoint1EntityId]
+			};
+			const previous = map.get("identity");
+			if (previous !== void 0 && !equalJson(previous, identity)) throw new Error("Relation identity cannot change kind or endpoint positions");
+			if (previous === void 0) map.set("identity", identity);
+			if (map.get("deleted") === true) throw new Error("Deleted relation IDs cannot be reused");
+			const metadata = map.ensureMergeableMap("metadata");
+			const trace = map.ensureMergeableMap("trace");
+			writeObject(metadata, metadata.toJSON(), row.metadata);
+			writeObject(trace, trace.toJSON(), row.trace);
+			break;
+		}
+		case "unlink": {
+			const map = section(doc, "relations").get(command.root);
+			if (!(map instanceof LoroMap)) throw new Error("Unknown relation");
+			map.set("deleted", true);
+			break;
+		}
+		case "relation-fields": {
+			const map = section(doc, "relations").get(command.root);
+			if (!(map instanceof LoroMap)) throw new Error("Unknown relation");
+			const metadata = map.ensureMergeableMap("metadata");
+			const trace = map.ensureMergeableMap("trace");
+			writeObject(metadata, metadata.toJSON(), command.metadata);
+			writeObject(trace, trace.toJSON(), command.trace);
+			break;
+		}
+		case "attach":
+			section(doc, "attachments").set(command.slot, command.entityId);
+			break;
+	}
+}
+function writeBases(doc, map, ids) {
+	const links = map.ensureMergeableMap("bases");
+	const wanted = new Map(ids.map((id) => {
+		const origin = section(doc, "origins").get(id);
+		return [typeof origin === "string" ? origin : [...currentIds(doc)].find(([, current]) => current === id)?.[0] ?? id, id];
+	}));
+	if (wanted.size !== ids.length) throw new Error("Duplicate base entity family");
+	for (const key of links.keys()) if (!wanted.has(key)) links.delete(key);
+	for (const [key, id] of wanted) if (links.get(key) === void 0) links.set(key, id);
+}
+/** Numeric sub-spans must not silently quote different text after a collaborative edit. */
+function selectionFingerprint(rows, id) {
+	const row = rows.entities.find((row) => row.entityId === id);
+	if (row?.entityKind !== "caption" || !Array.isArray(row.payload.selections)) return void 0;
+	const ranged = row.payload.selections.filter((selection) => isJsonObject(selection) && selection.textRange !== void 0);
+	if (ranged.length === 0) return void 0;
+	const segments = assembleEntityContent(rows, row.entityId).payload.segments;
+	if (!Array.isArray(segments)) throw new Error("Caption text selection has no source segments");
+	return hash(ranged.map((selection) => {
+		if (!isJsonObject(selection)) throw new Error("Invalid Caption text selection");
+		const source = segments.find((segment) => isJsonObject(segment) && segment.segmentId === selection.segmentId);
+		if (!isJsonObject(source) || typeof source.text !== "string") throw new Error("Caption text selection source is missing");
+		return [selection, source.text];
+	}));
+}
+function assertState(state) {
+	for (const row of state.rows.entities) assembleEntityContent(state.rows, row.entityId);
+	const ids = new Set(state.rows.entities.map((row) => String(row.entityId)));
+	for (const row of state.rows.relations) if (!ids.has(row.endpoint0EntityId) || !ids.has(row.endpoint1EntityId)) throw new Error("Relation has a missing endpoint");
+}
+function materialize(doc) {
+	const state = readEntityDocument(doc);
+	const byId = section(doc, "entities");
+	const ids = currentIds(doc);
+	for (const [source, id] of ids) {
+		const origins = section(doc, "origins");
+		if (origins.get(id) !== source) origins.set(id, source);
+	}
+	for (const row of state.rows.entities) {
+		const next = {
+			id: row.entityId,
+			kind: row.entityKind,
+			...row.payload
+		};
+		const previous = byId.get(row.entityId);
+		if (isJsonObject(previous) && !equalJson(owned(previous), owned(next))) throw new Error("Immutable entity version collision");
+		if (!equalJson(previous, next)) byId.set(row.entityId, next);
+	}
+	const project = section(doc, "project");
+	for (const [slot, id] of Object.entries(state.project)) if (project.get(slot) !== id) project.set(slot, id);
+}
+//#endregion
 //#region src/document/mirror-read.ts
 /**
 * Project the mirror state (`VideoDocumentDraft`) into the authoritative
@@ -3398,7 +4058,9 @@ var MirrorVideoDocumentAdapter = class {
 		});
 	}
 	snapshot() {
-		return readVideoDocumentFromDraft(this.mirror.getState());
+		const document = readVideoDocumentFromDraft(this.mirror.getState());
+		if (this.doc.getMap("medeo").get("schema") === "medeo.entities.loro.v1") return projectEntityTimeline(readEntityDocument(this.doc).rows, document.meta);
+		return document;
 	}
 	/**
 	* True once the doc holds real document content. A fresh mirror over an empty
@@ -3620,4 +4282,4 @@ function createPlainMemoryAdapter(document, options) {
 	return new PlainMemoryAdapter(document, options);
 }
 //#endregion
-export { isEmptyVideoClip as $, buildSpeechHostMap as A, ensureLaneTrack as B, variantBaseEntityIds as C, hasSequence as D, createRelationId as E, assertValidVideoDocument as F, arrangeMainTrackSeamlessly as G, laneTrackId as H, validateVideoDocument as I, recalculateTimelineDuration as J, fillMainTrackTimeGaps as K, partUnionSchema as L, fromVideoDocument as M, toVideoDocument as N, isMediaAssetVariantKind as O, VideoDocumentValidationError as P, TIMELINE_SKELETON_DURATION_MS as Q, videoDocumentSchema as R, updateEntityFields as S, createEntityId as T, solveVideoDocument as U, findLaneTrack as V, cascadeAfterVideoClipChanges as W, resolveSpeechOverlapByShiftingVideos as X, resolveAllSpeechOverlaps as Y, syncAggregatedClipsTimePosition as Z, assembleEntityContent as _, applyEntityTimelineProjection as a, effectiveVideoClipDurationMs as at, findComposedAudioScript as b, writeVideoDocumentToDraft as c, recordEntries as ct, EntityProjectionGraph as d, bytesToBase64 as dt, partDurationMs as et, resolveEntityTimelineLayout as f, assembleCaptionContent as g, ScriptCompositionError as h, MirrorVideoDocumentAdapter as i, VIDEO_DOCUMENT_SCHEMA_VERSION as it, derivePositionFromAbs as j, buildInitialVideoDocument as k, readVideoDocumentFromDraft as l, videoDocumentMirrorSchema as lt, decodeEntityRelationRows as m, createPlainMemoryAdapter as n, DEFAULT_UNIT_TIME_MS as nt, createMirrorVideoDocument as o, speedOf as ot, EntityTimelineProjectionError as p, reassignSpeechesToVideoClipsByTime as q, generatePartId as r, ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION as rt, createMirrorVideoDocumentAdapter as s, partUnionToDraft as st, PlainMemoryAdapter as t, safeDurationMs as tt, projectEntityTimeline as u, base64ToBytes as ut, assemblePhoneticScriptContent as v, isJsonObject as w, selectAudioScriptSegments as x, assembleScriptText as y, LANE_KINDS_IN_STACK_ORDER as z };
+export { reassignSpeechesToVideoClipsByTime as $, isJsonObject as A, VideoDocumentValidationError as B, assembleEntityContent as C, selectAudioScriptSegments as D, findComposedAudioScript as E, buildInitialVideoDocument as F, LANE_KINDS_IN_STACK_ORDER as G, validateVideoDocument as H, buildSpeechHostMap as I, laneTrackId as J, ensureLaneTrack as K, derivePositionFromAbs as L, createRelationId as M, hasSequence as N, updateEntityFields as O, isMediaAssetVariantKind as P, fillMainTrackTimeGaps as Q, fromVideoDocument as R, assembleCaptionContent as S, assembleScriptText as T, partUnionSchema as U, assertValidVideoDocument as V, videoDocumentSchema as W, cascadeAfterVideoClipChanges as X, solveVideoDocument as Y, arrangeMainTrackSeamlessly as Z, EntityProjectionGraph as _, bytesToBase64 as _t, applyEntityTimelineProjection as a, isEmptyVideoClip as at, decodeEntityRelationRows as b, writeVideoDocumentToDraft as c, DEFAULT_UNIT_TIME_MS as ct, LoroEntityDocument as d, effectiveVideoClipDurationMs as dt, recalculateTimelineDuration as et, LoroEntityDraft as f, speedOf as ft, projectEntityTimeline as g, base64ToBytes as gt, equalJson as h, videoDocumentMirrorSchema as ht, MirrorVideoDocumentAdapter as i, TIMELINE_SKELETON_DURATION_MS as it, createEntityId as j, variantBaseEntityIds as k, readVideoDocumentFromDraft as l, ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION as lt, entityOrderGroups as m, recordEntries as mt, createPlainMemoryAdapter as n, resolveSpeechOverlapByShiftingVideos as nt, createMirrorVideoDocument as o, partDurationMs as ot, readEntityDocument as p, partUnionToDraft as pt, findLaneTrack as q, generatePartId as r, syncAggregatedClipsTimePosition as rt, createMirrorVideoDocumentAdapter as s, safeDurationMs as st, PlainMemoryAdapter as t, resolveAllSpeechOverlaps as tt, LORO_ENTITY_SCHEMA as u, VIDEO_DOCUMENT_SCHEMA_VERSION as ut, resolveEntityTimelineLayout as v, assemblePhoneticScriptContent as w, ScriptCompositionError as x, EntityTimelineProjectionError as y, toVideoDocument as z };