@mengine/medeo-client 1.3.1-alpha.1 → 1.3.1-alpha.11

package/dist/{document-Bf200CmD.js → document-CkbNx-mi.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;
@@ -1524,13 +1526,49 @@ function isRecord$1(value) {
 	return typeof value === "object" && value != null && !Array.isArray(value);
 }
 //#endregion
+//#region ../medeo-dsl/src/ids.ts
+function createEntityId(value) {
+	return createId(value, "EntityId");
+}
+function createRelationId(value) {
+	return createId(value, "RelationId");
+}
+function createId(value, label) {
+	if (value.length === 0 || value.trim() !== value) throw new Error(`${label} must be a non-empty trimmed string`);
+	return value;
+}
+//#endregion
+//#region ../medeo-dsl/src/json-values.ts
+const nativeObjectConstructorSource = Function.prototype.toString.call(Object);
+function isJsonObject(value) {
+	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;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object") return false;
+	if (!Array.isArray(value) && !isPlainObject(value)) return false;
+	if (ancestors.has(value)) return false;
+	ancestors.add(value);
+	const valid = Array.isArray(value) ? value.every((item) => isJsonValue(item, ancestors)) : Object.values(value).every((item) => isJsonValue(item, ancestors));
+	ancestors.delete(value);
+	return valid;
+}
+/** Recognize an ordinary object from any VM realm without admitting class instances. */
+function isPlainObject(value) {
+	try {
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype === null) return true;
+		if (Object.getPrototypeOf(prototype) !== null) return false;
+		const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
+		return typeof constructor === "function" && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === nativeObjectConstructorSource;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region ../medeo-dsl/src/composition.ts
-/**
-* Raised when a variant's complete content cannot be assembled from its
-* required composition Relation. Assembly never falls back to variant-local
-* text: a missing, ambiguous, or dangling source is an error, not an empty
-* read.
-*/
+/** Assembly fails explicitly when declared bases cannot provide valid, unambiguous content. */
 var ScriptCompositionError = class extends Error {
 	code;
 	entityId;
@@ -1541,23 +1579,111 @@ var ScriptCompositionError = class extends Error {
 		this.name = "ScriptCompositionError";
 	}
 };
-function compositionRelationKind(variantKind) {
-	return variantKind === "caption" ? "caption-composition" : "phonetic-script-composition";
+/** Direct base IDs are structural fields, never ordinary Relation endpoints. */
+function variantBaseEntityIds(entity) {
+	if (!Object.hasOwn(entity.payload, "baseEntityIds")) return [];
+	const ids = entity.payload.baseEntityIds;
+	if (!Array.isArray(ids) || ids.length === 0 || !ids.every((id) => typeof id === "string" && id.trim() === id && id.length > 0) || new Set(ids).size !== ids.length) throw new ScriptCompositionError("invalid_bases", entity.entityId, `Entity "${entity.entityId}" requires non-empty, unique baseEntityIds`);
+	return ids.map(createEntityId);
+}
+/** Validate all base providers before applying explicit own fields; ordering cannot resolve ambiguity. */
+function assembleEntityContent(rows, entityId) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const row of rows.entities) {
+		if (byId.has(row.entityId)) throw new ScriptCompositionError("composition_ambiguous", row.entityId, `duplicate entity id "${row.entityId}"`);
+		byId.set(row.entityId, row);
+	}
+	const active = /* @__PURE__ */ new Set();
+	const cache = /* @__PURE__ */ new Map();
+	const visit = (id) => {
+		const cached = cache.get(id);
+		if (cached !== void 0) return cached;
+		if (active.has(id)) throw new ScriptCompositionError("composition_cycle", id, `Cyclic baseEntityIds at "${id}"`);
+		const row = byId.get(id);
+		if (row === void 0) throw new ScriptCompositionError("composition_dangling", id, `Missing base entity "${id}" in this document`);
+		if (!isJsonObject(row.payload) || Object.hasOwn(row.payload, "entityId") || Object.hasOwn(row.payload, "entityKind")) throw new ScriptCompositionError("invalid_bases", id, `Entity "${id}" requires JSON own fields without reserved identity fields`);
+		active.add(id);
+		const inherited = {};
+		const providers = /* @__PURE__ */ new Map();
+		for (const baseId of variantBaseEntityIds(row)) {
+			const base = visit(baseId);
+			for (const [field, value] of Object.entries(base.payload)) {
+				if (field === "baseEntityIds") continue;
+				const previous = providers.get(field);
+				if (previous !== void 0) throw new ScriptCompositionError("field_conflict", id, `Entity "${id}" field "${field}" conflicts between bases "${previous}" and "${baseId}"; own fields cannot resolve base ambiguity`);
+				providers.set(field, baseId);
+				Object.defineProperty(inherited, field, {
+					value,
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+		}
+		const assembled = {
+			...row,
+			payload: JSON.parse(JSON.stringify({
+				...inherited,
+				...row.payload
+			}))
+		};
+		active.delete(id);
+		cache.set(id, assembled);
+		return assembled;
+	};
+	return visit(entityId);
+}
+/** Resolve a field's declaring entity after validating the entire composition. */
+function resolveEntityFieldOwner(rows, entityId, field) {
+	assembleEntityContent(rows, entityId);
+	const byId = new Map(rows.entities.map((row) => [row.entityId, row]));
+	const find = (id) => {
+		const row = byId.get(id);
+		if (Object.hasOwn(row.payload, field)) return id;
+		if (field === "baseEntityIds") return void 0;
+		for (const baseId of variantBaseEntityIds(row)) {
+			const owner = find(baseId);
+			if (owner !== void 0) return owner;
+		}
+	};
+	return find(entityId) ?? entityId;
+}
+/** Patch assembled fields without copying inherited fields into the variant's stored payload. */
+function updateEntityFields(rows, entityId, fields) {
+	assembleEntityContent(rows, entityId);
+	if (!isJsonObject(fields) || Object.hasOwn(fields, "entityId") || Object.hasOwn(fields, "entityKind")) throw new ScriptCompositionError("invalid_bases", entityId, "Field updates require JSON without reserved identity fields");
+	const updates = /* @__PURE__ */ new Map();
+	for (const [field, value] of Object.entries(fields)) {
+		const ownerId = resolveEntityFieldOwner(rows, entityId, field);
+		const owner = updates.get(ownerId) ?? rows.entities.find((row) => row.entityId === ownerId);
+		updates.set(ownerId, {
+			...owner,
+			payload: {
+				...owner.payload,
+				[field]: value
+			}
+		});
+	}
+	return [...updates.values()].map((row) => JSON.parse(JSON.stringify(row)));
 }
-/**
-* Resolve the one AudioScript a variant composes. Relations are queried from
-* both endpoints, so persisted endpoint positions do not matter.
-*/
+/** Find the actual AudioScript text owner through direct variant bases. */
 function findComposedAudioScript(rows, variantEntityId, variantKind) {
-	const kind = compositionRelationKind(variantKind);
-	const edges = rows.relations.filter((relation) => relation.relationKind === kind && (relation.endpoint0EntityId === variantEntityId || relation.endpoint1EntityId === variantEntityId));
-	if (edges.length === 0) throw new ScriptCompositionError("composition_missing", variantEntityId, `${variantKind} "${variantEntityId}" has no ${kind} Relation; it has no content without its AudioScript`);
-	if (edges.length > 1) throw new ScriptCompositionError("composition_ambiguous", variantEntityId, `${variantKind} "${variantEntityId}" has ${edges.length} ${kind} Relations; exactly one AudioScript is required`);
-	const edge = edges[0];
-	const otherId = edge.endpoint0EntityId === variantEntityId ? edge.endpoint1EntityId : edge.endpoint0EntityId;
-	const script = rows.entities.find((entity) => entity.entityId === otherId);
-	if (script === void 0 || script.entityKind !== "audio-script") throw new ScriptCompositionError("composition_dangling", variantEntityId, `${variantKind} "${variantEntityId}" ${kind} Relation must resolve a live AudioScript, got "${script?.entityKind ?? "missing entity"}"`);
-	return script;
+	const variant = requireEntityKind(rows, variantEntityId, variantKind);
+	assembleEntityContent(rows, variantEntityId);
+	const sources = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (row) => {
+		for (const id of variantBaseEntityIds(row)) {
+			if (seen.has(id)) continue;
+			seen.add(id);
+			const base = rows.entities.find((candidate) => candidate.entityId === id);
+			if (base.entityKind === "audio-script") sources.set(id, assembleEntityContent(rows, id));
+			else visit(base);
+		}
+	};
+	visit(variant);
+	if (sources.size !== 1) throw new ScriptCompositionError(sources.size === 0 ? "composition_missing" : "composition_ambiguous", variantEntityId, `${variantKind} "${variantEntityId}" baseEntityIds must resolve one AudioScript text owner, got ${sources.size}`);
+	return [...sources.values()][0];
 }
 /** Join the whole AudioScript text in segment order. */
 function assembleScriptText(script) {
@@ -1574,16 +1700,15 @@ function isScriptSegment(value) {
 	const segment = value;
 	return typeof segment.segmentId === "string" && segment.segmentId.trim() !== "" && typeof segment.text === "string" && (segment.language === void 0 || typeof segment.language === "string");
 }
-/**
-* Assemble the complete Caption content from its AudioScript: the selected
-* segments in selection order, joined as display text. The Caption payload
-* never carries text, so a broken composition fails here instead of silently
-* rendering an empty caption.
-*/
+/** Assemble selected text after base-field validation and explicit variant overrides. */
 function assembleCaptionContent(rows, captionEntityId) {
-	const caption = requireEntityKind(rows, captionEntityId, "caption");
+	requireEntityKind(rows, captionEntityId, "caption");
+	const caption = assembleEntityContent(rows, captionEntityId);
 	const script = findComposedAudioScript(rows, captionEntityId, "caption");
-	const segments = selectAudioScriptSegments(script, captionSelections(caption));
+	const segments = selectAudioScriptSegments({
+		...script,
+		payload: caption.payload
+	}, captionSelections(caption));
 	return {
 		caption,
 		audioScript: script,
@@ -1596,9 +1721,13 @@ function assembleCaptionContent(rows, captionEntityId) {
 * AudioScript's base text plus the variant's own phoneme and prosody fields.
 */
 function assemblePhoneticScriptContent(rows, phoneticScriptEntityId) {
-	const phoneticScript = requireEntityKind(rows, phoneticScriptEntityId, "phonetic-script");
+	requireEntityKind(rows, phoneticScriptEntityId, "phonetic-script");
+	const phoneticScript = assembleEntityContent(rows, phoneticScriptEntityId);
 	const audioScript = findComposedAudioScript(rows, phoneticScriptEntityId, "phonetic-script");
-	const segments = scriptSegments(audioScript);
+	const segments = scriptSegments({
+		...audioScript,
+		payload: phoneticScript.payload
+	});
 	return {
 		phoneticScript,
 		audioScript,
@@ -1641,16 +1770,15 @@ function requireEntityKind(rows, entityIdValue, entityKind) {
 	return entity;
 }
 //#endregion
-//#region ../medeo-dsl/src/ids.ts
-function createEntityId(value) {
-	return createId(value, "EntityId");
-}
-function createRelationId(value) {
-	return createId(value, "RelationId");
-}
-function createId(value, label) {
-	if (value.length === 0 || value.trim() !== value) throw new Error(`${label} must be a non-empty trimmed string`);
-	return value;
+//#region ../medeo-dsl/src/rows.ts
+function entityToRow(entity) {
+	const { entityId, entityKind, ...payload } = entity;
+	if (!isJsonObject(payload)) throw new Error(`Entity "${entityId}" payload must contain only JSON values`);
+	return {
+		entityId,
+		entityKind,
+		payload
+	};
 }
 //#endregion
 //#region ../medeo-dsl/src/invariants.ts
@@ -1671,6 +1799,19 @@ function validateMediaAssetIdentity(entity, index) {
 function validateEntityRelationSet(entityRefs, index, options) {
 	const { entities, issues } = collectRelatedEntities(entityRefs, index);
 	const entityIds = new Set(entities.map((entity) => entity.entityId));
+	const rows = {
+		entities: entities.map((entity) => entityToRow(entity.current())),
+		relations: []
+	};
+	for (const entity of entities) try {
+		assembleEntityContent(rows, entity.entityId);
+	} catch (error) {
+		issues.push({
+			code: "invalid_variant_composition",
+			entityId: entity.entityId,
+			message: error instanceof Error ? error.message : "Invalid variant composition"
+		});
+	}
 	for (const entity of entities) {
 		const current = entity.current();
 		const entityIssues = validateEntity(entity, entityIds);
@@ -1691,8 +1832,8 @@ function validateEntityRelationSet(entityRefs, index, options) {
 			issues.push(...validateClipPlacement(entity, index));
 		}
 		if (current.entityKind === "axvideo") issues.push(...validateAXVideoAdmission(entity, index));
-		if (current.entityKind === "caption") issues.push(...validateCaptionComposition(entity, index));
-		if (current.entityKind === "phonetic-script") issues.push(...validatePhoneticComposition(entity, index));
+		if (current.entityKind === "caption") issues.push(...validateCaptionComposition(entity, index, entities));
+		if (current.entityKind === "phonetic-script") issues.push(...validatePhoneticComposition(entity, index, entities));
 		issues.push(...validateSequenceComposition(entity));
 	}
 	issues.push(...validateClipAnchorCycles(entities, index));
@@ -1795,60 +1936,32 @@ function validateAXVideoAdmission(axVideo, index) {
 		message: "AXVideo must have exactly one live AXVideo-Marker Relation"
 	}];
 }
-/**
-* Variant composition is the content contract, not an optional label: a
-* Caption must compose exactly one live AudioScript and its segment selection
-* must name that script's own segments. Text is never stored on the variant,
-* so a missing source means no valid caption content and fails validation.
-*/
-function validateCaptionComposition(caption, index) {
-	return validateVariantComposition(caption, index, "caption", "caption-composition", "caption_composition_required");
+/** Validate a Caption against the complete entity set, including its directly held bases. */
+function validateCaptionComposition(caption, index, entities = []) {
+	return validateVariantComposition(caption, index, entities, "caption");
 }
-/** Same required-composition contract for the pronunciation variant. */
-function validatePhoneticComposition(phonetic, index) {
-	return validateVariantComposition(phonetic, index, "phonetic-script", "phonetic-script-composition", "phonetic_script_composition_required");
+function validatePhoneticComposition(phonetic, index, entities = []) {
+	return validateVariantComposition(phonetic, index, entities, "phonetic-script");
 }
-function validateVariantComposition(variant, index, variantKind, compositionKind, issueCode) {
-	const relations = [...index.relationsOf(variant)];
+function validateVariantComposition(variant, index, entities, kind) {
 	const issues = [];
-	const physicalEdges = ofKind(relations, "physical-asset");
-	if (variantKind === "caption" && physicalEdges.length > 0) issues.push({
+	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 compositionEdges = ofKind(relations, compositionKind);
-	if (compositionEdges.length !== 1) {
-		issues.push({
-			code: issueCode,
-			entityId: variant.entityId,
-			message: `${variantKind} must have exactly one ${compositionKind} Relation to a live AudioScript`
-		});
-		return issues;
-	}
-	const script = compositionEdges[0]?.other(variant)?.deref()?.current();
-	if (script?.entityKind !== "audio-script") {
-		issues.push({
-			code: issueCode,
-			entityId: variant.entityId,
-			message: `${variantKind} ${compositionKind} Relation must resolve a live AudioScript`
-		});
-		return issues;
-	}
-	if (variantKind !== "caption") return issues;
-	const selections = variant.current().selections;
-	if (!Array.isArray(selections)) return issues;
+	const rows = {
+		entities: collectRelatedEntities([...entities, variant], index).entities.map((ref) => entityToRow(ref.current())),
+		relations: []
+	};
 	try {
-		selectAudioScriptSegments({
-			entityId: script.entityId,
-			entityKind: "audio-script",
-			payload: { segments: script.segments.map((segment) => ({ ...segment })) }
-		}, selections);
+		if (kind === "caption") assembleCaptionContent(rows, variant.entityId);
+		else assemblePhoneticScriptContent(rows, variant.entityId);
 	} catch (error) {
 		issues.push({
-			code: "caption_selection_invalid",
+			code: kind === "caption" ? "caption_composition_required" : "phonetic_script_composition_required",
 			entityId: variant.entityId,
-			message: error instanceof Error ? error.message : "Invalid Caption selection"
+			message: error instanceof Error ? error.message : "Invalid variant composition"
 		});
 	}
 	return issues;
@@ -2123,7 +2236,6 @@ function validateVoicePayload(value, problems) {
 	if (voice.name !== void 0 && typeof voice.name !== "string") problems.push("voice.name must be a string when present");
 }
 function validateCaptionPayload(value, problems) {
-	if (value.text !== void 0) problems.push("text is composed from the AudioScript; Caption must not store a text copy");
 	const selections = value.selections;
 	if (!Array.isArray(selections)) problems.push("selections must be a non-empty array of AudioScript segment selections");
 	else {
@@ -2180,8 +2292,7 @@ function validateRange(value, path, required, problems) {
 }
 /** Phonetic variants store pronunciation fields only; base text stays in the AudioScript. */
 function validatePhoneticScriptPayload(value, problems) {
-	if (value.text !== void 0) problems.push("text is composed from AudioScript; PhoneticScript must not store a text copy");
-	if (value.segments !== void 0) problems.push("segments carry the base text owned by the AudioScript; PhoneticScript stores pronunciation fields only");
+	if (value.segments !== void 0) validateScriptPayload(value, problems);
 	if (value.phonemeScript !== void 0 && (typeof value.phonemeScript !== "string" || value.phonemeScript.trim() === "")) problems.push("phonemeScript must be a non-empty string when present");
 	if (value.prosody !== void 0 && !isRecord(value.prosody)) problems.push("prosody must be an object when present");
 }
@@ -2227,6 +2338,7 @@ function visitPeerEntityIdPaths(value, entityKind, parentPath, ancestors, paths)
 	if (Array.isArray(value)) for (const [index, item] of value.entries()) visitPeerEntityIdPaths(item, entityKind, `${parentPath}[${index}]`, ancestors, paths);
 	else for (const [key, child] of Object.entries(value)) {
 		const path = parentPath.length === 0 ? key : `${parentPath}.${key}`;
+		if (parentPath.length === 0 && key === "baseEntityIds") continue;
 		if (!(parentPath.length === 0 && key === "entityId") && !isOwnedLocalIdPath(entityKind, path) && isEntityIdFieldName(key)) paths.push(path);
 		visitPeerEntityIdPaths(child, entityKind, path, ancestors, paths);
 	}
@@ -2246,7 +2358,7 @@ function visitPeerEntityValues(value, entityKind, ownEntityId, entityIds, path,
 	ancestors.add(value);
 	if (Array.isArray(value)) for (const [index, item] of value.entries()) visitPeerEntityValues(item, entityKind, ownEntityId, entityIds, `${path}[${index}]`, ancestors, paths);
 	else for (const [key, child] of Object.entries(value)) {
-		if (path.length === 0 && (key === "entityId" || key === "entityKind")) continue;
+		if (path.length === 0 && (key === "entityId" || key === "entityKind" || key === "baseEntityIds")) continue;
 		visitPeerEntityValues(child, entityKind, ownEntityId, entityIds, path.length === 0 ? key : `${path}.${key}`, ancestors, paths);
 	}
 	ancestors.delete(value);
@@ -2267,12 +2379,20 @@ function isOwnedLocalEntityValuePath(entityKind, path) {
 	if (isMediaAssetVariantKind(entityKind) && /^(?:external\.(?:system|key)|storageKey)$/.test(path)) return true;
 	if (entityKind === "voice" && /^voice\.(?:system|key|name)$/.test(path)) return true;
 	if (entityKind === "caption" && (path.startsWith("style.") || /^selections\[\d+\]\.segmentId$/.test(path))) return true;
-	if (entityKind === "audio-script" && /^segments\[\d+\]\.(?:segmentId|text|language)$/.test(path)) return true;
+	if ([
+		"audio-script",
+		"caption",
+		"phonetic-script"
+	].includes(entityKind) && /^segments\[\d+\]\.(?:segmentId|text|language)$/.test(path)) return true;
 	return false;
 }
 function isOwnedLocalIdPath(entityKind, path) {
 	if (path === "lifecycle.actorId") return true;
-	if (entityKind === "audio-script" && /^segments\[\d+\]\.segmentId$/.test(path)) return true;
+	if ([
+		"audio-script",
+		"caption",
+		"phonetic-script"
+	].includes(entityKind) && /^segments\[\d+\]\.segmentId$/.test(path)) return true;
 	if (entityKind === "caption" && /^selections\[\d+\]\.segmentId$/.test(path)) return true;
 	if (entityKind === "sequence-marker" && /^segmentRanges\[\d+\]\.segmentId$/.test(path)) return true;
 	if (entityKind === "asset" && /^(?:tracks\[\d+\]\.trackId|renditions\[\d+\]\.renditionId)$/.test(path)) return true;
@@ -2329,35 +2449,6 @@ function ofKind(relations, kind) {
 	return relations.filter((relation) => relation.kind === kind);
 }
 //#endregion
-//#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;
-}
-function isJsonValue(value, ancestors) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-	if (typeof value === "number") return Number.isFinite(value);
-	if (typeof value !== "object") return false;
-	if (!Array.isArray(value) && !isPlainObject(value)) return false;
-	if (ancestors.has(value)) return false;
-	ancestors.add(value);
-	const valid = Array.isArray(value) ? value.every((item) => isJsonValue(item, ancestors)) : Object.values(value).every((item) => isJsonValue(item, ancestors));
-	ancestors.delete(value);
-	return valid;
-}
-/** Recognize an ordinary object from any VM realm without admitting class instances. */
-function isPlainObject(value) {
-	try {
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype === null) return true;
-		if (Object.getPrototypeOf(prototype) !== null) return false;
-		const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-		return typeof constructor === "function" && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === nativeObjectConstructorSource;
-	} catch {
-		return false;
-	}
-}
-//#endregion
 //#region ../medeo-dsl/src/relation-specs.ts
 const timelineTrackRelationSpec = emptySpec("timeline-track", "timeline", "track");
 const trackClipRelationSpec = emptySpec("track-clip", "track", "clip");
@@ -2380,15 +2471,6 @@ const generatedRelationSpec = Object.freeze({
 	validateEndpoints: (endpoints) => endpoints.every((endpoint) => isGeneratedMedia(endpoint.current())),
 	validateMetadata: isEmptyMetadata
 });
-/**
-* Variant composition: the required content relation between a variant and its
-* AudioScript. This is the assembly source for the variant's base text — never
-* a downgradeable provenance label. A variant without exactly one live
-* composition Relation has no valid content and fails validation.
-*/
-const phoneticScriptCompositionRelationSpec = metadataSpec("phonetic-script-composition", "phonetic-script", "audio-script", isSegmentAlignmentMetadata);
-/** See {@link phoneticScriptCompositionRelationSpec}; Caption is the display variant. */
-const captionCompositionRelationSpec = metadataSpec("caption-composition", "caption", "audio-script", isSegmentAlignmentMetadata);
 const captionAlignmentRelationSpec = Object.freeze({
 	kind: "caption-alignment",
 	validateEndpoints: (endpoints) => hasKinds(endpoints, new Set(["caption"]), new Set(["audio", "voice"])),
@@ -2437,8 +2519,6 @@ const builtInRelationSpecs = Object.freeze([
 	markerTimelineRelationSpec,
 	physicalAssetRelationSpec,
 	generatedRelationSpec,
-	phoneticScriptCompositionRelationSpec,
-	captionCompositionRelationSpec,
 	captionAlignmentRelationSpec,
 	clipAnchorRelationSpec,
 	phoneticScriptRenderRelationSpec,
@@ -2481,9 +2561,6 @@ function isAssetBinding(value) {
 	const orderingKey = /(order|ordinal|position|rank|index|z[_-]?index)/i;
 	return Object.keys(value).every((key) => !orderingKey.test(key));
 }
-function isSegmentAlignmentMetadata(value) {
-	return isJsonObject(value) && Object.hasOwn(value, "segmentAlignment");
-}
 function isCaptionAlignmentMetadata(value) {
 	return isJsonObject(value) && Object.hasOwn(value, "alignment");
 }
@@ -2669,7 +2746,13 @@ function decodeEntityRelationRows(rows, options) {
 	const entitiesById = /* @__PURE__ */ new Map();
 	const extensionEntityKinds = new Set(options.entityKinds ?? []);
 	for (const row of rows.entities) {
-		const entity = decodeEntityRow(row, extensionEntityKinds, issues);
+		let entity = decodeEntityRow(row, extensionEntityKinds, issues);
+		if (entity != null) try {
+			entity = decodeEntityRow(assembleEntityContent(rows, row.entityId), extensionEntityKinds, issues);
+		} catch (error) {
+			issues.push(errorMessage(error));
+			continue;
+		}
 		if (entity == null) continue;
 		const ref = createEntityRef(entity);
 		if (entitiesById.has(ref.entityId)) {
@@ -2849,9 +2932,9 @@ var EntityProjectionGraph = class {
 	timeline;
 	constructor(rows) {
 		this.rows = rows;
-		decodeEntityRelationRows(rows, { compareMarkerPoints: (_marker, _range, left, right) => finite(left, "range point") - finite(right, "range point") });
-		this.entities = new Map(rows.entities.map((row) => [String(row.entityId), row]));
-		const roots = rows.entities.filter((row) => row.entityKind === "timeline");
+		const decoded = decodeEntityRelationRows(rows, { compareMarkerPoints: (_marker, _range, left, right) => finite(left, "range point") - finite(right, "range point") });
+		this.entities = new Map([...decoded.entitiesById.values()].map((ref) => [String(ref.entityId), entityToRow(ref.current())]));
+		const roots = [...this.entities.values()].filter((row) => row.entityKind === "timeline");
 		if (roots.length !== 1) fail("compatibility projection requires exactly one Timeline");
 		this.timeline = roots[0];
 	}
@@ -3226,6 +3309,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
@@ -3317,7 +4064,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
@@ -3539,4 +4288,4 @@ function createPlainMemoryAdapter(document, options) {
 	return new PlainMemoryAdapter(document, options);
 }
 //#endregion
-export { ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION as $, VideoDocumentValidationError as A, cascadeAfterVideoClipChanges as B, hasSequence as C, derivePositionFromAbs as D, buildSpeechHostMap as E, LANE_KINDS_IN_STACK_ORDER as F, resolveAllSpeechOverlaps as G, fillMainTrackTimeGaps as H, ensureLaneTrack as I, TIMELINE_SKELETON_DURATION_MS as J, resolveSpeechOverlapByShiftingVideos as K, findLaneTrack as L, validateVideoDocument as M, partUnionSchema as N, fromVideoDocument as O, videoDocumentSchema as P, DEFAULT_UNIT_TIME_MS as Q, laneTrackId as R, selectAudioScriptSegments as S, buildInitialVideoDocument as T, reassignSpeechesToVideoClipsByTime as U, arrangeMainTrackSeamlessly as V, recalculateTimelineDuration as W, partDurationMs as X, isEmptyVideoClip as Y, safeDurationMs as Z, ScriptCompositionError as _, applyEntityTimelineProjection as a, videoDocumentMirrorSchema as at, assembleScriptText as b, writeVideoDocumentToDraft as c, resolveEntityTimelineLayout as d, VIDEO_DOCUMENT_SCHEMA_VERSION as et, EntityTimelineProjectionError as f, createRelationId as g, createEntityId as h, MirrorVideoDocumentAdapter as i, recordEntries as it, assertValidVideoDocument as j, toVideoDocument as k, readVideoDocumentFromDraft as l, isJsonObject as m, createPlainMemoryAdapter as n, speedOf as nt, createMirrorVideoDocument as o, base64ToBytes as ot, decodeEntityRelationRows as p, syncAggregatedClipsTimePosition as q, generatePartId as r, partUnionToDraft as rt, createMirrorVideoDocumentAdapter as s, bytesToBase64 as st, PlainMemoryAdapter as t, effectiveVideoClipDurationMs as tt, projectEntityTimeline as u, assembleCaptionContent as v, isMediaAssetVariantKind as w, findComposedAudioScript as x, assemblePhoneticScriptContent as y, solveVideoDocument 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 };