@mengine/medeo-client 2.1.0 → 2.1.1-dsl.1

package/dist/legacy.js

@@ -0,0 +1,4349 @@
+import { n as bytesToBase64, t as base64ToBytes } from "./base64-D-jd-dr5.js";
+import { c as readMengineEventStream, d as MenginePushRejectedError, i as openManualDocument, l as MengineHttpClient, n as MedeoHttpDocStorage, o as decodeDocVersionMark, r as ManualSyncTransport, s as encodeDocVersionMark, t as MemoryDocStorage, u as MengineHttpRequestError } from "./storage-BW3tI_ER.js";
+import { a as documentFormat, r as UnsupportedDocumentFormatError, t as DEFAULT_UNIT_TIME_MS } from "./video-draft-types-TXRv3wS6.js";
+import { u as volumeSchema } from "./shared-iWnU2osE.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { LoroDoc, LoroMap, LoroMovableList, LoroText, UndoManager } from "loro-crdt";
+import { bytesToHex } from "@noble/hashes/utils.js";
+//#region ../medeo-dsl/depreacted/src/entities/types.ts
+function entityToRow(entity) {
+	const { entityId, entityKind, ...payload } = entity;
+	return {
+		entityId,
+		entityKind,
+		payload
+	};
+}
+//#endregion
+//#region ../medeo-dsl/depreacted/src/entities/specs.ts
+/**
+* What every known entity kind declares.
+*
+* Every question of the form "which kinds are X" is answered here and nowhere
+* else: code asks `declaresKind` and never lists kinds of its own. A kind that
+* shares nothing declares nothing; the order of a declaration carries no
+* meaning.
+*
+* `Caption` declares `Sequence` on purpose: it owns the display timing of the
+* one AudioScript segment it shows, which is what admits it into a Clip.
+* `Voice` declares no `Sequence` — it is a timbre identity, not playable
+* content; rendered speech is a `voiceover-recording` entity.
+*/
+const ENTITY_KINDS = Object.freeze({
+	timeline: Object.freeze([]),
+	track: Object.freeze([]),
+	clip: Object.freeze([]),
+	asset: Object.freeze([]),
+	video: Object.freeze([
+		"Sequence",
+		"Visual",
+		"Audible",
+		"MediaFile"
+	]),
+	audio: Object.freeze([
+		"Sequence",
+		"Audible",
+		"MediaFile"
+	]),
+	"voiceover-recording": Object.freeze([
+		"Sequence",
+		"Audible",
+		"MediaFile"
+	]),
+	image: Object.freeze([
+		"Sequence",
+		"Visual",
+		"MediaFile"
+	]),
+	voice: Object.freeze([]),
+	"sequence-marker": Object.freeze([]),
+	"audio-script": Object.freeze(["SegmentText", "MediaFile"]),
+	"phonetic-script": Object.freeze([
+		"SegmentText",
+		"Composed",
+		"MediaFile"
+	]),
+	caption: Object.freeze([
+		"SegmentText",
+		"Composed",
+		"Sequence",
+		"MediaFile"
+	])
+});
+function isKnownEntityKind(kind) {
+	return Object.hasOwn(ENTITY_KINDS, kind);
+}
+/** Whether a kind declares a trait. */
+function declaresKind(entityKind, kind) {
+	return isKnownEntityKind(entityKind) && ENTITY_KINDS[entityKind].includes(kind);
+}
+/**
+* Sequence admission is a declaration, not a shape: a kind is admitted because
+* it declares `Sequence`, and a malformed payload is a separate, louder failure
+* than a silently non-Sequence entity.
+*/
+function hasSequence(entity) {
+	return declaresKind(entity.entityKind, "Sequence");
+}
+function isMediaAssetVariantKind(kind) {
+	return declaresKind(kind, "Visual") || declaresKind(kind, "Audible");
+}
+const required = (check) => ({
+	required: true,
+	check
+});
+const optional = (check) => ({
+	required: false,
+	check
+});
+const must = (holds, be) => (value, path) => holds(value) ? [] : [`${path} must ${be}`];
+const isWhole = (value) => typeof value === "number" && Number.isSafeInteger(value);
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const string = must((value) => typeof value === "string", "be a string");
+const name = must((value) => typeof value === "string" && value.trim() !== "", "be a non-empty string");
+const boolean = must((value) => typeof value === "boolean", "be a boolean");
+const finite$1 = must((value) => typeof value === "number" && Number.isFinite(value), "be a finite number");
+const wholeMs = must(isWhole, "be whole milliseconds");
+const wholeMsFromZero = must((value) => isWhole(value) && value >= 0, "be whole milliseconds at or after zero");
+const count = must((value) => isWhole(value) && value >= 0, "be a whole code-point count at or after zero");
+const positive$1 = must((value) => typeof value === "number" && value > 0, "be a positive number");
+const onlyTrue = must((value) => value === true, "be true when stated");
+const duration = must((value) => value === null || isWhole(value) && value > 0, "be positive whole milliseconds, or null for infinite");
+const decibels = must((value) => typeof value === "number" && value >= -60 && value <= 20, "be decibels between -60 and 20");
+const exactly = (constant) => must((value) => value === constant, `be "${constant}"`);
+/** Composition judges `bases` for the whole document; see `checkComposition`. */
+const bases$1 = () => [];
+/** An object stating exactly the fields of `T`: each checked, the required ones present, nothing else. */
+function fields(rules) {
+	return (value, path) => isRecord$1(value) ? problemsIn(rules, value, path, true) : [`${path} must be an object`];
+}
+const list = (item) => (value, path) => Array.isArray(value) ? value.flatMap((entry, index) => item(entry, `${path}[${index}]`)) : [`${path} must be a list`];
+function problemsIn(rules, value, path, closed) {
+	const at = (field) => path === "" ? field : `${path}.${field}`;
+	const problems = closed ? Object.keys(value).filter((field) => !Object.hasOwn(rules, field)).map((field) => `${at(field)} is not a field here`) : [];
+	for (const [field, rule] of Object.entries(rules)) if (value[field] === void 0) {
+		if (rule.required) problems.push(`${at(field)} is required`);
+	} else problems.push(...rule.check(value[field], at(field)));
+	return problems;
+}
+const segmentTime = fields({
+	segmentId: required(string),
+	startMs: required(wholeMsFromZero),
+	endMs: required(wholeMsFromZero)
+});
+const segmentRanges = (value, path) => {
+	if (!Array.isArray(value)) return [`${path} must be a list`];
+	const seen = /* @__PURE__ */ new Set();
+	return value.flatMap((range, index) => {
+		const at = `${path}[${index}]`;
+		const problems = [...segmentTime(range, at)];
+		const segmentId = isRecord$1(range) ? range.segmentId : void 0;
+		if (typeof segmentId === "string") {
+			if (seen.has(segmentId)) problems.push(`${at}.segmentId must be unique`);
+			seen.add(segmentId);
+		}
+		if (problems.length === 0 && range.startMs > range.endMs) problems.push(`${at}.startMs must not exceed endMs`);
+		return problems;
+	});
+};
+const textRange = (value, path) => {
+	const problems = fields({
+		start: required(count),
+		end: required(count)
+	})(value, path);
+	if (problems.length > 0 || value.end > value.start) return problems;
+	return [`${path} must be a non-empty half-open code-point range`];
+};
+const style = fields({
+	font: optional(fields({
+		system: required(exactly("font-library")),
+		key: required(name)
+	})),
+	fontSize: optional(finite$1),
+	fontColor: optional(string),
+	fontWeight: optional(finite$1),
+	entranceAnimation: optional(string),
+	entranceAnimationDurationMs: optional(finite$1),
+	strokeColor: optional(string),
+	strokeWidth: optional(finite$1),
+	positionX: optional(finite$1),
+	positionY: optional(finite$1)
+});
+const media = { durationMs: required(duration) };
+/**
+* The fields every known kind stores, and how each is checked. The table is
+* held to the contract: it names every field a kind states, and no other.
+* `bases` is composition's to judge for every kind that may name it.
+*/
+const ENTITY_FIELDS = Object.freeze({
+	timeline: {},
+	track: {
+		role: required(string),
+		hidden: optional(boolean)
+	},
+	clip: { volume: optional(decibels) },
+	"sequence-marker": {
+		inMs: required(wholeMsFromZero),
+		outMs: required(wholeMs),
+		startMs: optional(wholeMsFromZero),
+		rate: optional(positive$1),
+		fillTimeline: optional(onlyTrue),
+		segmentRanges: optional(segmentRanges)
+	},
+	video: media,
+	audio: media,
+	"voiceover-recording": media,
+	image: media,
+	voice: { voice: required(fields({
+		system: required(exactly("voice-library")),
+		key: required(name),
+		name: optional(string)
+	})) },
+	"audio-script": { segments: required(list(fields({
+		segmentId: required(name),
+		text: required(string),
+		language: optional(string)
+	}))) },
+	"phonetic-script": {
+		bases: required(bases$1),
+		phonemeScript: optional(name)
+	},
+	caption: {
+		durationMs: required(duration),
+		bases: required(bases$1),
+		selection: required(fields({
+			segmentId: required(name),
+			textRange: optional(textRange)
+		})),
+		style: optional(style),
+		segmentRanges: optional(segmentRanges)
+	},
+	asset: {
+		system: required(must((value) => value === "memota" || value === "memota-speech", "be \"memota\" or \"memota-speech\"")),
+		key: required(name),
+		storageKey: optional(name),
+		digest: optional(name),
+		writable: optional(onlyTrue)
+	}
+});
+/**
+* What is wrong with one entity's fields. Pass the assembled entity: a
+* variant's required fields may come from its bases. Whether the stored row
+* states a field its kind does not have is `unknownFields`' question.
+*/
+function validateEntity(entity) {
+	if (!isKnownEntityKind(entity.entityKind)) return [];
+	const value = entity;
+	const problems = problemsIn(ENTITY_FIELDS[entity.entityKind], value, "", false);
+	if (problems.length === 0) problems.push(...crossFieldProblems(entity.entityKind, value));
+	return problems.map((problem) => `Entity "${entity.entityKind}" ${problem}`);
+}
+/** The fields a stored row states that its kind does not have. `bases` is composition's to judge. */
+function unknownFields(entityKind, payload) {
+	if (!isKnownEntityKind(entityKind)) return [];
+	return Object.keys(payload).filter((field) => field !== "bases" && !Object.hasOwn(ENTITY_FIELDS[entityKind], field));
+}
+function crossFieldProblems(entityKind, value) {
+	if (entityKind === "sequence-marker" && value.outMs <= value.inMs) return ["outMs must be greater than inMs"];
+	if (entityKind === "caption" && Array.isArray(value.segmentRanges)) {
+		const [only, ...rest] = value.segmentRanges;
+		if (rest.length > 0 || only?.segmentId !== value.selection.segmentId) return ["segmentRanges must contain only the selected segment timing"];
+	}
+	return [];
+}
+const FIELD_MERGE = Object.freeze({
+	/** One segment reference, narrowed by an optional code-point range. */
+	selection: "atomic",
+	textRange: "atomic",
+	/** Collaborative text, merged by code point. */
+	text: "text",
+	phonemeScript: "text",
+	/** Element identity is the segment id, so inserts and moves survive each other. */
+	segments: "list",
+	segmentRanges: "list",
+	bases: "list"
+});
+//#endregion
+//#region ../medeo-dsl/depreacted/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/depreacted/src/entities/runtime.ts
+var ScriptCompositionError = class extends Error {
+	code;
+	entityId;
+	constructor(code, entityId, message) {
+		super(message);
+		this.code = code;
+		this.entityId = entityId;
+		this.name = "ScriptCompositionError";
+	}
+};
+/** A row's fields by name, for the walks below that read whatever field they are asked for. */
+function payloadOf(row) {
+	return row.payload;
+}
+/** The ids a variant composes. Their shape is checked when rows compile, not on read. */
+function basesOf(entity) {
+	const ids = payloadOf(entity).bases;
+	return Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : [];
+}
+/**
+* An entity read through its `bases`: an own field wins, otherwise the field
+* comes from the base that has it, however deep.
+*
+* The payload is a live, read-only view. Reads follow edits to any base; writes
+* are refused, and go through `updateEntityFields`, which finds the entity that
+* actually owns the field.
+*
+* Reading never judges the composition. Missing bases, cycles and two bases
+* supplying one field are compile errors, reported by `checkComposition`; on
+* uncompiled rows a read skips what it cannot reach and takes the first base
+* that has the field.
+*
+* Naming the kind the caller expects narrows the row to that kind's fields.
+*/
+function assembleEntityContent(rows, entityId, kind) {
+	const byId = new Map(rows.entities.map((row) => [row.entityId, row]));
+	const row = byId.get(entityId);
+	if (row === void 0) throw new ScriptCompositionError("composition_dangling", entityId, `Entity "${entityId}" does not exist`);
+	if (kind !== void 0 && row.entityKind !== kind) throw new Error(`Entity "${entityId}" is a ${row.entityKind}, not a ${kind}`);
+	return {
+		...row,
+		payload: composedPayload(row, byId)
+	};
+}
+function composedPayload(row, byId) {
+	const read = (key, entity, path) => {
+		if (Object.hasOwn(entity.payload, key)) return {
+			found: true,
+			value: payloadOf(entity)[key]
+		};
+		if (key === "bases") return { found: false };
+		for (const id of basesOf(entity)) {
+			const base = byId.get(id);
+			if (base === void 0 || path.has(id)) continue;
+			const hit = read(key, base, new Set(path).add(id));
+			if (hit.found) return hit;
+		}
+		return { found: false };
+	};
+	const collect = (entity, path, keys) => {
+		for (const key of Object.keys(entity.payload)) if (entity === row || key !== "bases") keys.add(key);
+		for (const id of basesOf(entity)) {
+			const base = byId.get(id);
+			if (base !== void 0 && !path.has(id)) collect(base, new Set(path).add(id), keys);
+		}
+		return keys;
+	};
+	const root = new Set([row.entityId]);
+	const hit = (key) => typeof key === "string" ? read(key, row, root) : { found: false };
+	return new Proxy({}, {
+		get: (target, key) => {
+			const found = hit(key);
+			return found.found ? found.value : Reflect.get(target, key);
+		},
+		has: (target, key) => hit(key).found || Reflect.has(target, key),
+		ownKeys: () => [...collect(row, root, /* @__PURE__ */ new Set())],
+		getOwnPropertyDescriptor: (_, key) => {
+			const found = hit(key);
+			return found.found ? {
+				value: found.value,
+				enumerable: true,
+				configurable: true,
+				writable: false
+			} : void 0;
+		},
+		set: () => false,
+		defineProperty: () => false,
+		deleteProperty: () => false
+	});
+}
+/**
+* Check every variant's `bases` for the whole document, once, when rows compile.
+*
+* Every kind but an Asset may state `bases`. Each is a non-empty list
+* of distinct ids of entities in these rows; no entity reaches itself through
+* them; and no two bases supply one field — not even with equal values, and not
+* even when the variant states the field itself. An own field overrides a
+* base; it cannot choose between two.
+*/
+function checkComposition(rows) {
+	const byId = new Map(rows.entities.map((row) => [row.entityId, row]));
+	const issues = [];
+	for (const row of rows.entities) {
+		if (!Object.hasOwn(row.payload, "bases")) continue;
+		if (row.entityKind === "asset") {
+			issues.push({
+				code: "invalid_bases",
+				entityId: row.entityId,
+				message: `Entity "${row.entityId}" is an asset: stored bytes have no bases`
+			});
+			continue;
+		}
+		const ids = payloadOf(row).bases;
+		if (!Array.isArray(ids) || ids.length === 0 || !ids.every((id) => typeof id === "string" && id.length > 0 && id.trim() === id) || new Set(ids).size !== ids.length) {
+			issues.push({
+				code: "invalid_bases",
+				entityId: row.entityId,
+				message: `Entity "${row.entityId}" requires non-empty, unique bases`
+			});
+			continue;
+		}
+		for (const id of ids) if (!byId.has(id)) issues.push({
+			code: "composition_dangling",
+			entityId: row.entityId,
+			message: `Entity "${row.entityId}" names missing base entity "${id}" in this document`
+		});
+	}
+	const done = /* @__PURE__ */ new Set();
+	const stack = /* @__PURE__ */ new Set();
+	const walk = (id) => {
+		if (done.has(id)) return;
+		if (stack.has(id)) {
+			issues.push({
+				code: "composition_cycle",
+				entityId: id,
+				message: `Cyclic bases at "${id}"`
+			});
+			return;
+		}
+		stack.add(id);
+		for (const baseId of basesOf(byId.get(id))) if (byId.has(baseId)) walk(baseId);
+		stack.delete(id);
+		done.add(id);
+	};
+	for (const row of rows.entities) walk(row.entityId);
+	if (issues.length > 0) return issues;
+	const supplied = /* @__PURE__ */ new Map();
+	const fieldsOf = (id) => {
+		const known = supplied.get(id);
+		if (known !== void 0) return known;
+		const row = byId.get(id);
+		const fields = new Set(Object.keys(row.payload).filter((key) => key !== "bases"));
+		for (const baseId of basesOf(row)) for (const field of fieldsOf(baseId)) fields.add(field);
+		supplied.set(id, fields);
+		return fields;
+	};
+	for (const row of rows.entities) {
+		const providers = /* @__PURE__ */ new Map();
+		for (const baseId of basesOf(row)) for (const field of fieldsOf(baseId)) {
+			const previous = providers.get(field);
+			if (previous === void 0) {
+				providers.set(field, baseId);
+				continue;
+			}
+			issues.push({
+				code: "field_conflict",
+				entityId: row.entityId,
+				message: `Entity "${row.entityId}" field "${field}" conflicts between bases "${previous}" and "${baseId}"; own fields cannot resolve base ambiguity`
+			});
+		}
+	}
+	return issues;
+}
+/**
+* A kind that holds text as segments and composes reads them through its
+* bases, so what it composes has to supply them; a Caption's `selection` has
+* to name one of them. Run it over a composition `checkComposition` accepted.
+*/
+function checkComposedText(rows) {
+	const issues = [];
+	for (const row of rows.entities) {
+		if (!declaresKind(row.entityKind, "SegmentText") || !Object.hasOwn(row.payload, "bases")) continue;
+		const assembled = assembleEntityContent(rows, row.entityId);
+		try {
+			segmentsOf(assembled);
+			if (row.entityKind === "caption") selectedSegment(assembled);
+		} catch (error) {
+			if (!(error instanceof ScriptCompositionError)) throw error;
+			issues.push({
+				code: error.code,
+				entityId: row.entityId,
+				message: error.message
+			});
+		}
+	}
+	return issues;
+}
+/** The entity whose own payload holds `field` for this entity — itself or a base — or undefined when none does. */
+function resolveEntityFieldOwner(rows, entityId, field) {
+	const byId = new Map(rows.entities.map((row) => [row.entityId, row]));
+	const find = (id, path) => {
+		const row = byId.get(id);
+		if (row === void 0) return void 0;
+		if (Object.hasOwn(row.payload, field)) return id;
+		if (field === "bases") return void 0;
+		for (const baseId of basesOf(row)) {
+			if (path.has(baseId)) continue;
+			const owner = find(baseId, new Set(path).add(baseId));
+			if (owner !== void 0) return owner;
+		}
+	};
+	return find(entityId, new Set([entityId]));
+}
+/**
+* The entity that supplies `field` to this one through its bases — never the
+* entity itself, so an own override does not hide where the field comes from —
+* or undefined when no base supplies it.
+*/
+function baseFieldOwner(rows, entityId, field) {
+	const row = rows.entities.find((candidate) => candidate.entityId === entityId);
+	if (row === void 0) return void 0;
+	for (const baseId of basesOf(row)) {
+		const owner = resolveEntityFieldOwner(rows, baseId, field);
+		if (owner !== void 0) return owner;
+	}
+}
+/**
+* The Asset whose bytes an entity is made from. An Asset is its own; any other
+* entity reaches one through its own `from-asset`, else through its bases, the
+* way it reads a field it does not state.
+*/
+function assetOf(rows, entityId) {
+	const byId = new Map(rows.entities.map((row) => [row.entityId, row]));
+	const find = (id, path) => {
+		const row = byId.get(id);
+		if (row === void 0) return void 0;
+		if (row.entityKind === "asset") return row;
+		const own = rows.relations.find((relation) => relation.relationKind === "from-asset" && relation.endpoint0EntityId === id);
+		if (own !== void 0) {
+			const asset = byId.get(own.endpoint1EntityId);
+			return asset?.entityKind === "asset" ? asset : void 0;
+		}
+		for (const baseId of basesOf(row)) {
+			if (path.has(baseId)) continue;
+			const found = find(baseId, new Set(path).add(baseId));
+			if (found !== void 0) return found;
+		}
+	};
+	return find(entityId, new Set([entityId]));
+}
+/**
+* Write assembled fields to the entities that own them. A field no one owns yet
+* becomes the entity's own; an inherited field is edited where it lives, so
+* every variant reading it sees the edit, and nothing is copied down.
+*/
+function updateEntityFields(rows, entityId, fields) {
+	if (Object.hasOwn(fields, "entityId") || Object.hasOwn(fields, "entityKind")) throw new ScriptCompositionError("invalid_bases", entityId, "Field updates cannot rewrite an identity field");
+	const updates = /* @__PURE__ */ new Map();
+	for (const [field, value] of Object.entries(fields)) {
+		const ownerId = resolveEntityFieldOwner(rows, entityId, field) ?? entityId;
+		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)));
+}
+/** The whole text a row carries — its own segments or those it reads through its bases — in segment order. */
+function assembleScriptText(row) {
+	return segmentsOf(row).map((segment) => segment.text).join("");
+}
+/** A row's segments, own or composed; pass an assembled row to read through its bases. */
+function segmentsOf(row) {
+	const segments = payloadOf(row).segments;
+	if (!Array.isArray(segments)) throw new ScriptCompositionError("composition_dangling", row.entityId, `Entity "${row.entityId}" carries no segments`);
+	if (!segments.every(isScriptSegment) || new Set(segments.map((s) => s.segmentId)).size !== segments.length) throw new ScriptCompositionError("invalid_script", row.entityId, "Segments require unique local segmentId and text");
+	return segments;
+}
+function isScriptSegment(value) {
+	if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
+	const segment = value;
+	return typeof segment.segmentId === "string" && segment.segmentId.trim() !== "" && typeof segment.text === "string" && (segment.language === void 0 || typeof segment.language === "string");
+}
+/**
+* The text a Caption shows: the segment its `selection` names, among the
+* segments it reads through its bases, narrowed by `textRange`. Pass the
+* assembled Caption; a stored Caption holds no segments of its own.
+*/
+function selectedSegment(caption) {
+	const selection = payloadOf(caption).selection;
+	if (Object.hasOwn(caption.payload, "selections") || !isSegmentSelection(selection)) throw new ScriptCompositionError("invalid_selection", caption.entityId, "Caption requires one selection object with segmentId and optional textRange; selections arrays are forbidden");
+	return selectSegment(caption, selection);
+}
+function isSegmentSelection(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value) && typeof value.segmentId === "string" && value.segmentId.trim() !== "" && Object.keys(value).every((key) => key === "segmentId" || key === "textRange");
+}
+/** Select from any row carrying segments, without creating another authoritative text field. */
+function selectSegment(row, selection) {
+	if (!isSegmentSelection(selection)) throw new ScriptCompositionError("invalid_selection", row.entityId, "Caption requires one selection object with segmentId and optional textRange");
+	const segment = segmentsOf(row).find((entry) => entry.segmentId === selection.segmentId);
+	if (segment === void 0) throw new ScriptCompositionError("unknown_segment", row.entityId, `Caption selection "${selection.segmentId}" names no segment that "${row.entityId}" reads`);
+	const selected = (() => {
+		if (selection.textRange === void 0) return segment;
+		const range = selection.textRange;
+		const points = Array.from(segment.text);
+		if (typeof range !== "object" || range === null || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start || range.end > points.length || Object.keys(range).some((key) => key !== "start" && key !== "end")) throw new ScriptCompositionError("invalid_selection", row.entityId, "Caption textRange must be a non-empty half-open Unicode code-point range within its source segment");
+		return {
+			...segment,
+			text: points.slice(range.start, range.end).join("")
+		};
+	})();
+	if (!selected.text.trim()) throw new ScriptCompositionError("empty_selection", row.entityId, "Caption selection must contain visible source text");
+	return selected;
+}
+//#endregion
+//#region ../medeo-dsl/depreacted/src/relations/types.ts
+function createEntityRef(entity) {
+	return {
+		entityId: entity.entityId,
+		current: () => entity
+	};
+}
+//#endregion
+//#region ../medeo-dsl/depreacted/src/relations/specs.ts
+/**
+* Every Relation kind and the pairs it admits.
+*
+* As in `ENTITY_KINDS`, a question of the form "which kinds are X" is answered
+* by a trait; an end names a kind only when the pair is about that one kind.
+*/
+const RELATION_KINDS = {
+	/**
+	* What a Container holds: a Timeline holds Tracks, a Track holds Clips, and
+	* a Clip — the placement itself — holds content that declares Sequence. A
+	* Track's Clips play in the order their Relations sit in.
+	*/
+	contain: {
+		admits: [
+			["timeline", "track"],
+			["track", "clip"],
+			["clip", "Sequence"]
+		],
+		sequenced: true
+	},
+	/**
+	* A point marked on endpoint 0's timeline. A Clip takes a display Marker —
+	* the window and placement it plays its content through; an AudioScript
+	* takes an annotation Marker — assigned per-Segment times. What the Marker
+	* means is the marked entity's own business.
+	*/
+	marker: { admits: [[["clip", "audio-script"], "sequence-marker"]] },
+	/**
+	* `from-asset(entity, asset)` — the entity was made from that stored
+	* resource. Any entity with the `MediaFile` trait may be bound; the bytes
+	* stay named in exactly one place, so no entity copies the locator into its
+	* own row and one Asset can back several entities.
+	*/
+	"from-asset": { admits: [["MediaFile", "asset"]] },
+	/**
+	* `to-asset(entity, asset)` — the entity's content was written out to that
+	* stored resource.
+	*
+	* The mirror of `from-asset`, and deliberately a separate relation kind:
+	* eligibility is the same either way, but which way the content flowed is
+	* what says whether an entity may still be edited. An entity reached by
+	* `from-asset` was produced from bytes it does not own, so changing it would
+	* contradict them. An entity with a `to-asset` owns its content and the
+	* resource is a snapshot of it, which is what goes stale and gets written
+	* again. A transcript that is later edited carries both at once, and only
+	* the distinct relation kinds keep them apart.
+	*
+	* Writing a snapshot is the host's; a script reads these, and never writes one.
+	*/
+	"to-asset": { admits: [["MediaFile", "asset"]] },
+	/**
+	* What a thing was made from; endpoint 0 is the product, endpoint 1 what it
+	* came from. A generated medium is made from anything seen or heard, a
+	* Voiceover Recording from the Phonetic Script it was spoken from, and a
+	* transcribed Audio Script from media it was read off.
+	*/
+	"derived-from": { admits: [
+		[["Visual", "Audible"], ["Visual", "Audible"]],
+		["voiceover-recording", "phonetic-script"],
+		["audio-script", "Audible"]
+	] },
+	/** The Voiceover Recording a Caption follows. */
+	"caption-alignment": { admits: [["caption", "voiceover-recording"]] },
+	/** `clip-anchor(child, host)`: endpoint 0 follows endpoint 1. */
+	"clip-anchor": { admits: [["clip", "clip"]] },
+	/**
+	* The timbre identity a Voiceover was synthesized with. Voice stays an
+	* identity: it never carries the audio itself, so several takes can name
+	* one voice.
+	*/
+	"voice-timbre": { admits: [["voiceover-recording", "voice"]] }
+};
+function isRelationKind(kind) {
+	return Object.hasOwn(RELATION_KINDS, kind);
+}
+/** Whether a kind relates these two entities, in these positions. */
+function admits(kind, [first, second]) {
+	return RELATION_KINDS[kind].admits.some(([a, b]) => isAt(a, first.current()) && isAt(b, second.current()));
+}
+/** Whether this kind's Relations are ordered among themselves inside one container. */
+function isSequencedRelationKind(kind) {
+	return isRelationKind(kind) && RELATION_KINDS[kind].sequenced === true;
+}
+/** Whether an entity sits at an end: its kind is the one named there, or it declares the trait named there. */
+function isAt(end, entity) {
+	if (typeof end !== "string") return end.some((one) => isAt(one, entity));
+	return isKnownEntityKind(end) ? entity.entityKind === end : declaresKind(entity.entityKind, end);
+}
+//#endregion
+//#region ../medeo-dsl/depreacted/src/relations/runtime.ts
+/** Check one Relation: two distinct entities, in positions its kind admits. */
+function checkRelation(kind, endpoints) {
+	if (endpoints[0].entityId === endpoints[1].entityId) throw new Error("A Relation cannot connect an entity to itself");
+	if (!admits(kind, endpoints)) throw new Error(`Relation "${kind}" received invalid endpoints`);
+}
+/**
+* Every Relation of a compiled document, found from either endpoint. It is
+* built once when rows compile and never changes; the rows stay the
+* persistence authority.
+*/
+var RelationIndex = class {
+	byEntity = /* @__PURE__ */ new Map();
+	relationIds = /* @__PURE__ */ new Set();
+	/** Check a Relation and add it; a Relation id appears once per index. */
+	link({ relationId, kind, endpoints }) {
+		if (this.relationIds.has(relationId)) throw new Error(`Relation id "${relationId}" already exists`);
+		checkRelation(kind, endpoints);
+		const [first, second] = endpoints;
+		const relation = {
+			relationId,
+			kind,
+			endpoints,
+			other: (entity) => entity.entityId === first.entityId ? second : entity.entityId === second.entityId ? first : void 0
+		};
+		this.relationIds.add(relationId);
+		for (const { entityId } of endpoints) {
+			const relations = this.byEntity.get(entityId) ?? /* @__PURE__ */ new Set();
+			relations.add(relation);
+			this.byEntity.set(entityId, relations);
+		}
+		return relation;
+	}
+	/** The Relations touching an entity, on either side. */
+	relationsOf(entity) {
+		return this.byEntity.get(entity.entityId) ?? /* @__PURE__ */ new Set();
+	}
+};
+/** Relations of `kind` where `entityId` is endpoint 0 — the container, the product, the child. */
+function relationsFrom(relations, kind, entityId) {
+	return relations.filter((row) => row.relationKind === kind && row.endpoint0EntityId === entityId);
+}
+/** Relations of `kind` where `entityId` is endpoint 1 — what is contained, the source, the host. */
+function relationsTo(relations, kind, entityId) {
+	return relations.filter((row) => row.relationKind === kind && row.endpoint1EntityId === entityId);
+}
+/**
+* What has to hold across Relations once every entity's own fields are valid:
+* how Markers, Clips and their content fit together, and where Clips sit.
+*/
+function validateRelationGraph(entities, index) {
+	const issues = [];
+	for (const entity of entities) {
+		const kind = entity.current().entityKind;
+		if (kind === "sequence-marker") {
+			const marker = entity;
+			issues.push(...validateMarkerUse(marker, index), ...validateMarkerSourceBounds(marker, index));
+		}
+		if (kind === "clip") {
+			const clip = entity;
+			issues.push(...validateClipAdmission(clip, index), ...validateClipPlacement(clip, index));
+		}
+	}
+	issues.push(...validateClipAnchorCycles(entities, index));
+	return issues;
+}
+function validateMarkerUse(marker, index) {
+	const markerEdges = ofKind([...index.relationsOf(marker)], "marker");
+	const markedKind = (relation) => relation.other(marker)?.current().entityKind;
+	const clipEdges = markerEdges.filter((relation) => markedKind(relation) === "clip");
+	const scriptEdges = markerEdges.filter((relation) => markedKind(relation) === "audio-script");
+	const issues = [];
+	if (scriptEdges.length > 0) {
+		if (clipEdges.length > 0) issues.push({
+			code: "marker_container_xor",
+			entityId: marker.entityId,
+			message: "An AudioScript annotation Marker must not carry Clip or content relations"
+		});
+		const ranges = marker.current().segmentRanges;
+		if (!ranges?.length) issues.push({
+			code: "marker_annotation_invalid",
+			entityId: marker.entityId,
+			message: "An AudioScript annotation Marker requires segmentRanges"
+		});
+		for (const relation of scriptEdges) {
+			const segments = relation.other(marker).current().segments;
+			if (!Array.isArray(segments)) continue;
+			const segmentIds = new Set(segments.map((segment) => segment.segmentId));
+			if (ranges?.some((range) => !segmentIds.has(range.segmentId))) issues.push({
+				code: "marker_annotation_invalid",
+				entityId: marker.entityId,
+				message: "Annotation segmentRanges must name segments of the related AudioScript"
+			});
+		}
+		return issues;
+	}
+	if (marker.current().segmentRanges !== void 0) issues.push({
+		code: "marker_annotation_invalid",
+		entityId: marker.entityId,
+		message: "segmentRanges belongs to an AudioScript annotation Marker, not a display Marker"
+	});
+	if (clipEdges.length !== 1) issues.push({
+		code: "marker_container_xor",
+		entityId: marker.entityId,
+		message: "A display Sequence Marker belongs to exactly one Clip"
+	});
+	return issues;
+}
+function validateClipAdmission(clip, index) {
+	if (markersOn(clip, index).length !== 1) return [{
+		code: "clip_marker_cardinality",
+		entityId: clip.entityId,
+		message: "Clip must have exactly one authoritative Clip-Marker Relation"
+	}];
+	const contentEdges = holds(clip, index);
+	if (contentEdges.length !== 1) return [{
+		code: "clip_content_cardinality",
+		entityId: clip.entityId,
+		message: "Clip must contain exactly one content entity"
+	}];
+	const content = contentEdges[0].other(clip).current();
+	if (!hasSequence(content)) return [{
+		code: "clip_content_not_sequence",
+		entityId: clip.entityId,
+		message: `Clip contains non-Sequence entity "${content.entityId}"`
+	}];
+	return [];
+}
+function validateClipPlacement(clip, index) {
+	const marker = markersOn(clip, index)[0]?.other(clip);
+	if (marker === void 0) return [];
+	const markerValue = marker.current();
+	const anchors = ofKind([...index.relationsOf(clip)], "clip-anchor").filter((relation) => relation.endpoints[0].entityId === clip.entityId);
+	const hasStart = markerValue.startMs !== void 0;
+	const issues = [];
+	if (anchors.length > 1) issues.push({
+		code: "clip_anchor_cardinality",
+		entityId: clip.entityId,
+		message: "A Clip may follow at most one host Clip"
+	});
+	if (anchors.length > 0 && !hasStart) issues.push({
+		code: "clip_placement_invalid",
+		entityId: clip.entityId,
+		message: "A Clip following a host states startMs, the offset inside that host"
+	});
+	if (markerValue.fillTimeline === true) {
+		const content = holds(clip, index)[0]?.other(clip)?.current();
+		const track = heldBy(clip, index)[0]?.other(clip)?.current();
+		const trackRole = track?.entityKind === "track" ? track.role : void 0;
+		if (content?.entityKind !== "audio" || trackRole !== "bgm") issues.push({
+			code: "timeline_duration_policy_invalid",
+			entityId: marker.entityId,
+			message: "Marker fillTimeline is only valid for ordered or absolutely placed Audio Clips on the bgm Track"
+		});
+	}
+	return issues;
+}
+function validateClipAnchorCycles(entities, index) {
+	const hostByChild = /* @__PURE__ */ new Map();
+	for (const entity of entities) {
+		if (entity.current().entityKind !== "clip") continue;
+		for (const relation of ofKind([...index.relationsOf(entity)], "clip-anchor")) if (relation.endpoints[0].entityId === entity.entityId) hostByChild.set(entity.entityId, relation.endpoints[1].entityId);
+	}
+	const issues = [];
+	for (const child of hostByChild.keys()) {
+		const seen = /* @__PURE__ */ new Set();
+		let current = child;
+		while (current !== void 0 && !seen.has(current)) {
+			seen.add(current);
+			current = hostByChild.get(current);
+		}
+		if (current === void 0) continue;
+		issues.push({
+			code: "clip_anchor_cycle",
+			entityId: child,
+			message: "clip-anchor Relations must form an acyclic dependency graph"
+		});
+	}
+	return issues;
+}
+function validateMarkerSourceBounds(marker, index) {
+	const clip = markedBy(marker, index)[0]?.other(marker);
+	if (clip == null) return [];
+	const contentEdges = holds(clip, index);
+	if (contentEdges.length !== 1) return [];
+	const content = contentEdges[0]?.other(clip)?.current();
+	if (content == null || !hasSequence(content)) return [];
+	const { inMs, outMs } = marker.current();
+	if (inMs >= 0 && (content.durationMs == null || outMs <= content.durationMs)) return [];
+	return [{
+		code: "marker_source_out_of_bounds",
+		entityId: marker.entityId,
+		message: "Sequence Marker in and out points must stay inside the length its content states"
+	}];
+}
+/** Marker edges where this entity is what the Marker is marked on. */
+function markersOn(target, index) {
+	return ofKind([...index.relationsOf(target)], "marker").filter((relation) => relation.endpoints[0].entityId === target.entityId);
+}
+/** Marker edges seen from the Marker itself. */
+function markedBy(marker, index) {
+	return ofKind([...index.relationsOf(marker)], "marker").filter((relation) => relation.endpoints[1].entityId === marker.entityId);
+}
+/** Contain edges where this entity is the Container. */
+function holds(container, index) {
+	return ofKind([...index.relationsOf(container)], "contain").filter((relation) => relation.endpoints[0].entityId === container.entityId);
+}
+/** Contain edges where this entity is what a Container holds. */
+function heldBy(contained, index) {
+	return ofKind([...index.relationsOf(contained)], "contain").filter((relation) => relation.endpoints[1].entityId === contained.entityId);
+}
+function ofKind(relations, kind) {
+	return relations.filter((relation) => relation.kind === kind);
+}
+//#endregion
+//#region ../medeo-dsl/depreacted/src/compile.ts
+/** Every problem a document has, reported together. */
+var CompileError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(`Medeo document does not compile:\n- ${issues.join("\n- ")}`);
+		this.issues = issues;
+		this.name = "CompileError";
+	}
+};
+/**
+* Compile a document's stored rows into checked entities and relations. Every
+* problem found is thrown together in one `CompileError`; nothing partial is
+* returned.
+*/
+function compile(rows) {
+	const entitiesById = /* @__PURE__ */ new Map();
+	const issues = checkComposition(rows).map((issue) => issue.message);
+	for (const row of rows.entities) {
+		const entityId = checkEntityRow(row, issues);
+		if (entityId === void 0) continue;
+		if (entitiesById.has(entityId)) {
+			issues.push(`duplicate entity id "${entityId}"`);
+			continue;
+		}
+		const { payload } = assembleEntityContent(rows, entityId);
+		entitiesById.set(entityId, createEntityRef({
+			...payload,
+			entityId,
+			entityKind: row.entityKind
+		}));
+	}
+	const relationIndex = new RelationIndex();
+	const relations = [];
+	const relationIds = /* @__PURE__ */ new Set();
+	for (const row of rows.relations) {
+		let relationId;
+		try {
+			relationId = createRelationId(row.relationId);
+		} catch (error) {
+			issues.push(errorMessage(error));
+			continue;
+		}
+		if (relationIds.has(relationId)) {
+			issues.push(`duplicate relation id "${relationId}"`);
+			continue;
+		}
+		relationIds.add(relationId);
+		if (!isRelationKind(row.relationKind)) {
+			issues.push(`relation "${relationId}" has unknown kind "${String(row.relationKind)}"`);
+			continue;
+		}
+		let endpoint0EntityId;
+		let endpoint1EntityId;
+		try {
+			endpoint0EntityId = createEntityId(row.endpoint0EntityId);
+			endpoint1EntityId = createEntityId(row.endpoint1EntityId);
+		} catch (error) {
+			issues.push(errorMessage(error));
+			continue;
+		}
+		const endpoint0 = entitiesById.get(endpoint0EntityId);
+		const endpoint1 = entitiesById.get(endpoint1EntityId);
+		if (endpoint0 == null || endpoint1 == null) {
+			const missing = [endpoint0 == null ? endpoint0EntityId : void 0, endpoint1 == null ? endpoint1EntityId : void 0].filter((value) => value != null).join(", ");
+			issues.push(`relation "${relationId}" references missing entity id(s): ${missing}`);
+			continue;
+		}
+		try {
+			relations.push(relationIndex.link({
+				relationId,
+				kind: row.relationKind,
+				endpoints: [endpoint0, endpoint1]
+			}));
+		} catch (error) {
+			issues.push(errorMessage(error));
+		}
+	}
+	if (issues.length === 0) for (const entity of entitiesById.values()) for (const problem of validateEntity(entity.current())) issues.push(`invalid_entity_payload: ${problem}`);
+	if (issues.length === 0) for (const issue of checkComposedText(rows)) issues.push(issue.message);
+	if (issues.length === 0) for (const issue of validateRelationGraph([...entitiesById.values()], relationIndex)) issues.push(`${issue.code}: ${issue.message}`);
+	if (issues.length > 0) throw new CompileError(issues);
+	return {
+		entitiesById,
+		relationIndex,
+		relations
+	};
+}
+/** Check what a stored row states about itself; the entity is then read through its bases. */
+function checkEntityRow(row, issues) {
+	let entityId;
+	try {
+		entityId = createEntityId(row.entityId);
+	} catch (error) {
+		issues.push(errorMessage(error));
+		return;
+	}
+	if (!isKnownEntityKind(row.entityKind)) {
+		issues.push(`entity "${entityId}" has unknown kind "${String(row.entityKind)}"`);
+		return;
+	}
+	if (typeof row.payload !== "object" || row.payload === null || Array.isArray(row.payload)) {
+		issues.push(`entity "${entityId}" payload must be an object`);
+		return;
+	}
+	const reserved = ["entityId", "entityKind"].filter((key) => Object.hasOwn(row.payload, key));
+	if (reserved.length > 0) {
+		issues.push(`entity "${entityId}" payload contains reserved field(s): ${reserved.join(", ")}`);
+		return;
+	}
+	const unknown = unknownFields(row.entityKind, row.payload);
+	if (unknown.length > 0) {
+		issues.push(`entity "${entityId}" states field(s) its kind does not have: ${unknown.join(", ")}`);
+		return;
+	}
+	return entityId;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/legacy/projection/entity-projection-values.ts
+/** A graph cannot be represented faithfully by the compatibility reader. */
+var EntityTimelineProjectionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "EntityTimelineProjectionError";
+	}
+};
+function fail(message) {
+	throw new EntityTimelineProjectionError(message);
+}
+function finite(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) fail(`${label} must be finite`);
+	return value;
+}
+function positive(value, label) {
+	const result = finite(value, label);
+	if (result <= 0) fail(`${label} must be positive`);
+	return result;
+}
+function milliseconds(value, label) {
+	const result = finite(value, label);
+	if (!Number.isSafeInteger(result) || result < 0) fail(`${label} must be non-negative whole milliseconds`);
+	return result;
+}
+function range(start, end, label) {
+	if (start >= end) fail(`${label} must be non-empty`);
+	return {
+		start,
+		end
+	};
+}
+//#endregion
+//#region src/legacy/projection/entity-timeline-layout.ts
+/** Validated graph lookup shared by the compatibility layout and projection. */
+var EntityProjectionGraph = class {
+	rows;
+	entities;
+	timeline;
+	constructor(rows) {
+		this.rows = rows;
+		const compiled = compile(rows);
+		this.entities = new Map([...compiled.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];
+	}
+	/** The entity with this id; naming its kind narrows the row to that kind's fields. */
+	entity(id, kind) {
+		const row = this.entities.get(id);
+		if (row === void 0 || kind !== void 0 && row.entityKind !== kind) fail(`Expected ${kind ?? "Entity"} ${id}`);
+		return row;
+	}
+	adjacent(id, kind) {
+		return [...new Set(this.rows.relations.filter((row) => row.relationKind === kind && (row.endpoint0EntityId === id || row.endpoint1EntityId === id)).map((row) => row.endpoint0EntityId === id ? row.endpoint1EntityId : row.endpoint0EntityId))].map((entityId) => this.entity(entityId));
+	}
+	/** What this entity contains, as opposed to what contains it. */
+	holds(id) {
+		return this.rows.relations.filter((row) => row.relationKind === "contain" && row.endpoint0EntityId === id).map((row) => this.entity(row.endpoint1EntityId));
+	}
+	heldBy(id) {
+		return this.rows.relations.filter((row) => row.relationKind === "contain" && row.endpoint1EntityId === id).map((row) => this.entity(row.endpoint0EntityId));
+	}
+	/**
+	* Ordered relations put the product at endpoint 0 and its source at endpoint 1.
+	* One entity can sit on both sides of the same kind — a Voiceover Recording is
+	* spoken from a PhoneticScript and is itself what a transcript was read from —
+	* so provenance is never read through the undirected `adjacent`.
+	*/
+	madeFrom(id, kind) {
+		return this.rows.relations.filter((row) => row.relationKind === kind && row.endpoint0EntityId === id).map((row) => this.entity(row.endpoint1EntityId));
+	}
+	madeInto(id, kind) {
+		return this.rows.relations.filter((row) => row.relationKind === kind && row.endpoint1EntityId === id).map((row) => this.entity(row.endpoint0EntityId));
+	}
+	one(id, relation, kind, values = this.adjacent(id, relation)) {
+		if (values.length !== 1 || kind !== void 0 && values[0]?.entityKind !== kind) fail(`entity ${id} requires exactly one ${relation}${kind === void 0 ? "" : ` to ${kind}`}`);
+		return values[0];
+	}
+};
+const roleOrder$1 = {
+	caption: 0,
+	video_clip: 1,
+	speech: 2,
+	bgm: 3
+};
+/**
+* Resolve only entity-owned placement facts. This does not choose new anchors,
+* manufacture clips, or mutate a graph while reading. Write-side operations
+* must express any detach/reparent/overlap decision in their entity plan.
+*/
+function resolveEntityTimelineLayout(rows) {
+	return resolveGraphLayout(new EntityProjectionGraph(rows));
+}
+function resolveGraphLayout(graph) {
+	const facts = /* @__PURE__ */ new Map();
+	const seenRoles = /* @__PURE__ */ new Set();
+	const tracks = graph.holds(graph.timeline.entityId).map((track) => {
+		if (track.entityKind !== "track" || !Object.hasOwn(roleOrder$1, track.payload.role)) fail(`unsupported compatibility Track role on ${track.entityId}`);
+		const { role } = track.payload;
+		if (seenRoles.has(role)) fail(`The compatibility editor supports only one ${role} Track`);
+		seenRoles.add(role);
+		const typedRole = role;
+		const order = roleOrder$1[typedRole];
+		const trackFacts = graph.holds(track.entityId).map((clip, clipIndex) => {
+			if (clip.entityKind !== "clip" || graph.heldBy(clip.entityId).length !== 1) fail(`Clip ${clip.entityId} must belong to exactly one Track`);
+			const marker = graph.one(clip.entityId, "marker", "sequence-marker");
+			const held = graph.holds(clip.entityId);
+			if (held.length !== 1) fail(`Clip ${clip.entityId} must contain exactly one content entity`);
+			const content = held[0];
+			const expected = typedRole === "video_clip" ? ["image", "video"] : typedRole === "speech" ? ["voiceover-recording"] : typedRole === "caption" ? ["caption"] : ["audio"];
+			if (!expected.includes(content.entityKind)) fail(`${typedRole} Track accepts ${expected.join(" or ")}, got ${content.entityKind}`);
+			const inMs = milliseconds(marker.payload.inMs, "inMs");
+			const outMs = milliseconds(marker.payload.outMs, "outMs");
+			const rate = marker.payload.rate === void 0 ? 1 : positive(marker.payload.rate, "rate");
+			const duration = positive(Math.round((outMs - inMs) / rate), "duration");
+			if (!Number.isSafeInteger(duration)) fail("Compatibility duration must be whole milliseconds");
+			const fillTimeline = marker.payload.fillTimeline === true;
+			if (fillTimeline && typedRole !== "bgm") fail("fillTimeline is only supported for timeline-filling background Audio");
+			const anchors = graph.rows.relations.filter((row) => row.relationKind === "clip-anchor" && row.endpoint0EntityId === clip.entityId);
+			if (anchors.length > 1) fail(`Clip ${clip.entityId} has multiple anchors`);
+			const startMs = marker.payload.startMs === void 0 ? void 0 : milliseconds(marker.payload.startMs, "startMs");
+			const anchorId = anchors[0]?.endpoint1EntityId;
+			let mode;
+			let absoluteStart;
+			let anchorOffset;
+			if (anchorId !== void 0) {
+				if (startMs === void 0) fail(`Anchored Marker ${marker.entityId} requires startMs inside its host`);
+				mode = "anchored";
+				anchorOffset = startMs;
+			} else if (startMs !== void 0) {
+				mode = "absolute";
+				absoluteStart = startMs;
+			} else mode = "sequential";
+			const fact = {
+				clip,
+				marker,
+				content,
+				trackId: track.entityId,
+				role: typedRole,
+				duration,
+				mode,
+				order: clipIndex,
+				absoluteStart,
+				anchorId,
+				anchorOffset,
+				fillTimeline
+			};
+			facts.set(clip.entityId, fact);
+			return fact;
+		});
+		if (typedRole === "bgm" && trackFacts.length > 1) fail("The compatibility editor supports only one background Audio Clip");
+		const sequential = trackFacts.filter((fact) => fact.mode === "sequential");
+		sequential.forEach((fact, index) => {
+			fact.predecessor = sequential[index - 1]?.clip.entityId;
+		});
+		return {
+			entityId: String(track.entityId),
+			role: typedRole,
+			order,
+			hidden: track.payload.hidden === true,
+			trackFacts
+		};
+	});
+	tracks.sort((left, right) => left.order - right.order || left.entityId.localeCompare(right.entityId));
+	const resolved = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	const resolve = (id) => {
+		const cached = resolved.get(id);
+		if (cached !== void 0) return cached;
+		if (visiting.has(id)) fail(`Cyclic Clip placement dependency at ${id}`);
+		visiting.add(id);
+		const fact = facts.get(id);
+		if (fact === void 0) fail(`Placement refers to unplaced Clip ${id}`);
+		let start = fact.absoluteStart ?? 0;
+		if (fact.mode === "anchored") {
+			const host = resolve(fact.anchorId);
+			if (fact.role === "speech" && !["video_clip", "bgm"].includes(facts.get(host.clipEntityId).role)) fail("An anchored voiceover must use a visual or BGM Clip as its host");
+			start = host.start + fact.anchorOffset;
+		} else if (fact.predecessor !== void 0) {
+			const prior = resolve(fact.predecessor);
+			start = prior.start + prior.duration;
+		}
+		milliseconds(start + fact.duration, "Clip end");
+		const result = {
+			clipEntityId: id,
+			markerEntityId: fact.marker.entityId,
+			contentEntityId: fact.content.entityId,
+			trackEntityId: fact.trackId,
+			start: milliseconds(start, "Clip start"),
+			duration: fact.duration,
+			mode: fact.mode,
+			...fact.anchorId === void 0 ? {} : {
+				anchorClipEntityId: fact.anchorId,
+				anchorOffset: fact.anchorOffset
+			}
+		};
+		visiting.delete(id);
+		resolved.set(id, result);
+		return result;
+	};
+	for (const id of facts.keys()) resolve(id);
+	const durationMs = Math.max(0, ...[...resolved.values()].filter((clip) => facts.get(clip.clipEntityId).role !== "bgm").map((clip) => clip.start + clip.duration));
+	for (const [id, fact] of facts) if (fact.fillTimeline) {
+		const clip = resolved.get(id);
+		resolved.set(id, {
+			...clip,
+			duration: durationMs
+		});
+	}
+	return {
+		durationMs,
+		clips: resolved,
+		tracks: tracks.map(({ trackFacts, ...track }) => ({
+			...track,
+			clips: trackFacts.map((fact) => resolved.get(fact.clip.entityId)).sort((left, right) => left.start - right.start || left.clipEntityId.localeCompare(right.clipEntityId))
+		}))
+	};
+}
+//#endregion
+//#region src/legacy/projection/entity-projection.ts
+/**
+* One-way compatibility view over the Entity graph. A legacy part is never
+* consulted as an editing fact. Peer IDs appear only in this derived read
+* contract, reconstructed from relations; they are not stored in payloads.
+*/
+function projectEntityTimeline(rows) {
+	const graph = new EntityProjectionGraph(rows);
+	const layout = resolveGraphLayout(graph);
+	for (const track of layout.tracks) {
+		if (track.role !== "video_clip") continue;
+		for (let index = 1; index < track.clips.length; index += 1) {
+			const previous = track.clips[index - 1];
+			if (track.clips[index].start < previous.start + previous.duration) fail("Overlapping visual Clips require an explicit overlay adapter; the current editor supports one visual lane");
+		}
+	}
+	const parts = {};
+	for (const track of layout.tracks) for (const placement of track.clips) {
+		const clip = graph.entity(placement.clipEntityId, "clip");
+		const marker = graph.entity(placement.markerEntityId, "sequence-marker");
+		const volume = volumeSchema.safeParse(clip.payload.volume ?? 0);
+		if (!volume.success) fail("Clip volume must be decibels between -60 and 20");
+		if (track.role === "video_clip") {
+			const content = graph.entity(placement.contentEntityId);
+			const asset = mediaAsset(graph, content);
+			const source = markerWindow$1(marker);
+			const external = externalLocator(asset, "memota");
+			const speed = videoSpeed(content, marker, placement);
+			parts[clip.entityId] = { video_clip: {
+				id: clip.entityId,
+				kind: "video_clip",
+				duration_ms: placement.duration,
+				origin_media_id: external.key,
+				play_in: content.entityKind === "image" && speed === void 0 ? 0 : source.start,
+				play_out: content.entityKind === "image" && speed === void 0 ? placement.duration : source.end,
+				volume: volume.data,
+				...speed === void 0 ? {} : { speed_shift: speed }
+			} };
+		} else if (track.role === "speech") {
+			const content = graph.entity(placement.contentEntityId, "voiceover-recording");
+			const asset = mediaAsset(graph, content);
+			requireUntrimmedAudio(content, marker, placement);
+			const external = externalLocator(asset, "memota-speech");
+			const renderEdges = graph.madeFrom(content.entityId, "derived-from");
+			const timbreEdges = graph.adjacent(content.entityId, "voice-timbre");
+			const spokenText = renderEdges.length > 0 || timbreEdges.length > 0 ? assembleScriptText(assembleEntityContent(rows, graph.one(content.entityId, "derived-from", "phonetic-script", renderEdges).entityId)) : void 0;
+			if (timbreEdges.length > 1) fail("A voiceover resolves at most one Voice identity");
+			const transcripts = graph.madeInto(content.entityId, "derived-from");
+			const voice = timbreEdges.length === 0 ? void 0 : graph.one(content.entityId, "voice-timbre", "voice").payload.voice;
+			const captionIds = layout.tracks.flatMap((candidate) => candidate.role === "caption" ? candidate.clips.filter((caption) => caption.anchorClipEntityId === clip.entityId).map((caption) => caption.clipEntityId) : []);
+			parts[clip.entityId] = { speech: {
+				id: clip.entityId,
+				kind: "speech",
+				duration_ms: placement.duration,
+				audio_storage_key: storageKey(asset),
+				origin_speech_id: external.key,
+				audio_script: spokenText ?? (transcripts.length > 0 ? assembleScriptText(graph.one(content.entityId, "derived-from", "audio-script", transcripts)) : ""),
+				volume: volume.data,
+				voice: voice === void 0 ? void 0 : {
+					id: voice.key,
+					name: voice.name
+				},
+				caption_ids: captionIds
+			} };
+		} else if (track.role === "caption") {
+			const caption = assembleEntityContent(rows, graph.entity(placement.contentEntityId).entityId, "caption");
+			const segment = selectedSegment(caption);
+			const text = segment.text;
+			const cues = captionDisplayCues(caption, segment, marker, placement.duration);
+			const style = captionStyle(caption.payload.style);
+			const anchor = placement.anchorClipEntityId === void 0 ? void 0 : layout.clips.get(placement.anchorClipEntityId);
+			const anchoredToSpeech = anchor !== void 0 && trackRoleOf(layout, anchor.trackEntityId) === "speech";
+			parts[clip.entityId] = { caption: {
+				id: clip.entityId,
+				kind: "caption",
+				text,
+				...cues === void 0 ? {} : { display_cues: cues },
+				speech_part_id: anchoredToSpeech ? placement.anchorClipEntityId : void 0,
+				start_ms: anchoredToSpeech ? placement.anchorOffset : 0,
+				duration_ms: placement.duration,
+				...style === void 0 ? {} : { style }
+			} };
+		} else {
+			const content = graph.entity(placement.contentEntityId, "audio");
+			const asset = mediaAsset(graph, content);
+			const external = externalLocator(asset, "memota");
+			if (marker.payload.fillTimeline !== true) fail("Background Audio requires an explicit fillTimeline");
+			if (marker.payload.rate !== void 0) fail("BGM rate is not supported by this reader");
+			const source = markerWindow$1(marker);
+			if (source.start !== 0 || content.payload.durationMs !== source.end) fail("Background Audio compatibility requires the complete source");
+			parts[clip.entityId] = { bgm: {
+				id: clip.entityId,
+				kind: "bgm",
+				duration_ms: placement.duration,
+				audio_storage_key: storageKey(asset),
+				origin_media_id: external.key,
+				volume: volume.data
+			} };
+		}
+	}
+	const tracks = layout.tracks.map((track) => ({
+		id: track.entityId,
+		parts_kind: track.role,
+		is_hidden: track.hidden,
+		items: track.clips.map((clip) => ({
+			part_id: clip.clipEntityId,
+			abs_time_position: clip.start
+		}))
+	}));
+	const aggregations = /* @__PURE__ */ new Map();
+	for (const track of layout.tracks) {
+		if (track.role !== "speech") continue;
+		for (const clip of track.clips) {
+			if (clip.anchorClipEntityId === void 0) continue;
+			const attachments = aggregations.get(clip.anchorClipEntityId) ?? [];
+			attachments.push({
+				part_id: clip.clipEntityId,
+				relative_time_position: clip.anchorOffset
+			});
+			aggregations.set(clip.anchorClipEntityId, attachments);
+		}
+	}
+	return {
+		timeline: {
+			duration_ms: layout.durationMs,
+			unit_time_ms: DEFAULT_UNIT_TIME_MS
+		},
+		main_track: tracks.find((track) => track.parts_kind === "video_clip"),
+		above_main_tracks: tracks.filter((track) => track.parts_kind === "caption"),
+		below_main_tracks: tracks.filter((track) => track.parts_kind === "speech" || track.parts_kind === "bgm"),
+		part_aggregations: [...aggregations].map(([body_part_id, attachments]) => ({
+			body_part_id,
+			attachments
+		})),
+		part_library: parts
+	};
+}
+function trackRoleOf(layout, trackEntityId) {
+	return layout.tracks.find((track) => track.entityId === trackEntityId)?.role;
+}
+/** The Asset a media entity was made from — its own, or its bases' — where the bytes are named alone. */
+function mediaAsset(graph, content) {
+	const asset = assetOf(graph.rows, content.entityId);
+	if (asset === void 0) fail(`entity ${content.entityId} requires a from-asset to an asset`);
+	return graph.entity(asset.entityId, "asset");
+}
+function storageKey(asset) {
+	const { storageKey } = asset.payload;
+	if (storageKey === void 0 || storageKey.trim() === "") fail("Asset " + asset.entityId + " requires its factual storageKey");
+	return storageKey;
+}
+function externalLocator(asset, system) {
+	if (asset.payload.system !== system) fail("Asset " + asset.entityId + " requires an explicit " + system + " key");
+	return { key: asset.payload.key };
+}
+function captionStyle(value) {
+	if (value === void 0) return void 0;
+	const { font, ...owned } = value;
+	const fields = {
+		fontSize: "font_size",
+		fontColor: "font_color",
+		fontWeight: "font_weight",
+		entranceAnimation: "entrance_animation",
+		entranceAnimationDurationMs: "entrance_animation_duration_ms",
+		strokeColor: "stroke_color",
+		strokeWidth: "stroke_width",
+		positionX: "position_x",
+		positionY: "position_y"
+	};
+	const style = {};
+	for (const [key, field] of Object.entries(owned)) style[fields[key]] = field;
+	return font === void 0 ? style : {
+		...style,
+		font_id: font.key
+	};
+}
+function requireUntrimmedAudio(content, marker, placement) {
+	const source = markerWindow$1(marker);
+	if (source.start !== 0 || content.payload.durationMs !== source.end || placement.duration !== source.end || marker.payload.rate !== void 0) fail("Voiceover compatibility requires the complete, unremapped take");
+}
+/** The Marker's window, in the {start,end} shape this compatibility reader speaks. */
+function markerWindow$1(marker) {
+	return {
+		start: marker.payload.inMs,
+		end: marker.payload.outMs
+	};
+}
+function videoSpeed(content, marker, placement) {
+	const { rate } = marker.payload;
+	if (content.entityKind === "image" && rate === void 0) return void 0;
+	const source = markerWindow$1(marker);
+	if (rate !== void 0) {
+		if (Math.round((source.end - source.start) / rate) !== placement.duration) fail("rate on " + marker.entityId + " must agree with Marker duration");
+		return {
+			category: "linear",
+			mode: "constant",
+			config: { linear: { speed: rate } }
+		};
+	}
+	const speed = (source.end - source.start) / placement.duration;
+	return speed === 1 ? void 0 : {
+		category: "linear",
+		mode: "constant",
+		config: { linear: { speed } }
+	};
+}
+/** Preserve selected text intervals without minting synthetic editable Clip identities. */
+function captionDisplayCues(caption, segment, marker, duration) {
+	const ranges = caption.payload.segmentRanges;
+	if (ranges === void 0) return void 0;
+	const source = markerWindow$1(marker);
+	const scale = duration / (source.end - source.start);
+	return [segment].flatMap((segment) => {
+		const timing = ranges.find((entry) => entry.segmentId === segment.segmentId);
+		if (timing === void 0) fail(`Caption timing is missing for selected segment ${segment.segmentId}`);
+		const intrinsic = range(timing.startMs, timing.endMs, "Caption segmentRange");
+		const start = Math.max(source.start, intrinsic.start);
+		const end = Math.min(source.end, intrinsic.end);
+		if (end <= start) return [];
+		const startMs = Math.round((start - source.start) * scale);
+		const endMs = Math.round((end - source.start) * scale);
+		return endMs > startMs ? [{
+			segmentId: segment.segmentId,
+			text: segment.text,
+			startMs,
+			durationMs: endMs - startMs
+		}] : [];
+	});
+}
+//#endregion
+//#region src/entity-crdt/json-values.ts
+const nativeObjectConstructorSource = Function.prototype.toString.call(Object);
+/**
+* A plain object whose values are all JSON, however deep: finite numbers, no
+* class instances, no cycles. Objects built in a script's VM realm pass, since
+* their prototypes are that realm's `Object`, not this one's.
+*/
+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 src/entity-crdt/field-changes.ts
+/** Merge behaviour is declared with the field shapes in @mengine/medeo-dsl. */
+const merge = (key) => FIELD_MERGE[key];
+const atomicFields = { has: (key) => merge(key) === "atomic" };
+const textFields = { has: (key) => merge(key) === "text" };
+const orderedFields = { has: (key) => merge(key) === "list" };
+const unsafeKeys = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+function listElementId(value) {
+	const id = typeof value === "string" ? value : isJsonObject(value) ? value.segmentId : void 0;
+	if (typeof id !== "string" || !id.trim()) throw new Error("List elements require a nonempty segmentId or string identity");
+	return id;
+}
+function assertFieldChanges(changes) {
+	if (!Array.isArray(changes) || changes.length === 0) throw new Error("changes must be a nonempty array");
+	for (const change of changes) {
+		if (!isJsonObject(change) || ![
+			"set",
+			"unset",
+			"text.splice",
+			"list.insert",
+			"list.move",
+			"list.remove"
+		].includes(change.op)) throw new Error("Unknown field operation");
+		if (!Array.isArray(change.path) || !change.path.length || typeof change.path[0] !== "string") throw new Error("Field paths must start with a field name");
+		for (const part of change.path) if (typeof part === "string") {
+			if (!part || unsafeKeys.has(part)) throw new Error("Invalid field name");
+		} else if (!isJsonObject(part) || Object.keys(part).length !== 1 || typeof part.elementId !== "string" || !part.elementId.trim()) throw new Error("List paths require { elementId }; numeric indices are not supported");
+	}
+}
+/** Resolve against the sequential causal view; the numeric path never crosses the API boundary. */
+function resolveFieldPath(payload, path) {
+	let value = payload;
+	const resolved = [];
+	for (const [index, part] of path.entries()) if (typeof part === "string") {
+		if (!isJsonObject(value)) throw new Error(`Field path does not reach a map: ${part}`);
+		if (index < path.length - 1 && atomicFields.has(part)) throw new Error(`Atomic field ${part} must be changed as one value`);
+		resolved.push(part);
+		value = value[part];
+	} else {
+		if (!Array.isArray(value)) throw new Error("Element selector requires a list");
+		const matches = value.flatMap((item, i) => listElementId(item) === part.elementId ? [i] : []);
+		if (matches.length !== 1) throw new Error(`Missing or ambiguous list element ${part.elementId}`);
+		resolved.push(matches[0]);
+		value = value[matches[0]];
+	}
+	return resolved;
+}
+/** Detached plan evaluation. The Loro write replays the original operations, not this snapshot. */
+function applyFieldChanges(payload, changes) {
+	assertFieldChanges(changes);
+	const result = structuredClone(payload);
+	for (const change of changes) {
+		const path = resolveFieldPath(result, change.path);
+		const key = path.at(-1);
+		if (typeof key !== "string") throw new Error("Change fields inside a list element or use list operations");
+		let parent = result;
+		for (const part of path.slice(0, -1)) parent = parent[part];
+		if (!isJsonObject(parent)) throw new Error("Field parent is not a map");
+		const mutable = parent;
+		const value = mutable[key];
+		if ([
+			"entityId",
+			"entityKind",
+			"entity_id",
+			"entity_kind",
+			"segmentId"
+		].includes(key)) throw new Error(`Identity field ${key} cannot be edited`);
+		switch (change.op) {
+			case "set":
+				if (textFields.has(key) || orderedFields.has(key) || !atomicFields.has(key) && (isJsonObject(value) || isJsonObject(change.value) || Array.isArray(value) || Array.isArray(change.value))) throw new Error(`Field ${key} requires a text, list, or leaf operation; snapshot replacement is not allowed`);
+				if (change.value === void 0 || !isJsonObject({ value: change.value })) throw new Error("set requires a JSON value");
+				if (value !== void 0 && value !== null && change.value !== null && typeof value !== typeof change.value) throw new Error(`Field ${key} cannot change type`);
+				mutable[key] = structuredClone(change.value);
+				break;
+			case "unset":
+				if (!Object.hasOwn(parent, key)) throw new Error(`Field ${key} is absent`);
+				delete mutable[key];
+				break;
+			case "text.splice": {
+				if (!textFields.has(key) || typeof value !== "string") throw new Error(`Field ${key} is not collaborative text`);
+				const chars = Array.from(value);
+				if (!Number.isSafeInteger(change.index) || !Number.isSafeInteger(change.deleteCount) || change.index < 0 || change.deleteCount < 0 || change.index + change.deleteCount > chars.length || typeof change.text !== "string") throw new Error("Invalid text splice range");
+				chars.splice(change.index, change.deleteCount, ...Array.from(change.text));
+				mutable[key] = chars.join("");
+				break;
+			}
+			default: {
+				if (!orderedFields.has(key) || !Array.isArray(value)) throw new Error(`Field ${key} is not a collaborative list`);
+				const ids = value.map(listElementId);
+				if (new Set(ids).size !== ids.length) throw new Error("Duplicate collaborative list identity");
+				const requireIndex = (id) => {
+					const index = ids.indexOf(id);
+					if (index < 0) throw new Error(`Unknown list element ${id}`);
+					return index;
+				};
+				if (change.op === "list.remove") value.splice(requireIndex(change.elementId), 1);
+				else {
+					if (change.beforeElementId !== null && typeof change.beforeElementId !== "string") throw new Error("beforeElementId must be an identity or null");
+					const before = change.beforeElementId === null ? value.length : requireIndex(change.beforeElementId);
+					if (change.op === "list.insert") {
+						const id = listElementId(change.value);
+						if (ids.includes(id)) throw new Error(`Duplicate list element ${id}`);
+						value.splice(before, 0, structuredClone(change.value));
+					} else {
+						if (change.elementId === change.beforeElementId) throw new Error("Cannot move a list element before itself");
+						const from = requireIndex(change.elementId);
+						const [item] = value.splice(from, 1);
+						value.splice(before > from ? before - 1 : before, 0, item);
+					}
+				}
+			}
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/entity-crdt/json-containers.ts
+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);
+}
+/** Write 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 readItem(list, index) {
+	const value = list.get(index);
+	return value instanceof LoroMap ? value.toJSON() : value;
+}
+function writeList(list, values) {
+	const wanted = values.map(listElementId);
+	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(listElementId(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 (listElementId(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;
+}
+/** Apply the authored operation directly, preserving text positions and moved item identity. */
+function applyNativeFieldChange(map, path, change) {
+	let parent = map;
+	for (const part of path.slice(0, -1)) if (parent instanceof LoroMap && typeof part === "string") parent = parent.get(part);
+	else if (parent instanceof LoroMovableList && typeof part === "number") parent = parent.get(part);
+	else throw new Error("Invalid native field path");
+	const key = path.at(-1);
+	if (!(parent instanceof LoroMap) || typeof key !== "string") throw new Error("Invalid native field parent");
+	if (change.op === "set") {
+		parent.set(key, change.value);
+		return;
+	}
+	if (change.op === "unset") {
+		parent.delete(key);
+		return;
+	}
+	const value = parent.get(key);
+	if (change.op === "text.splice") {
+		if (!(value instanceof LoroText)) throw new Error("Field is not collaborative text");
+		const start = value.convertPos(change.index, "unicode", "utf16");
+		const end = value.convertPos(change.index + change.deleteCount, "unicode", "utf16");
+		value.splice(start, end - start, change.text);
+		return;
+	}
+	if (!(value instanceof LoroMovableList)) throw new Error("Field is not a collaborative list");
+	applyNativeListChange(value, change);
+}
+function applyNativeListChange(list, change) {
+	const ids = Array.from({ length: list.length }, (_, i) => listElementId(readItem(list, i)));
+	const index = (id) => {
+		const found = ids.indexOf(id);
+		if (found < 0) throw new Error(`Unknown list element ${id}`);
+		return found;
+	};
+	if (change.op === "list.remove") {
+		list.delete(index(change.elementId), 1);
+		return;
+	}
+	const before = change.beforeElementId === null ? list.length : index(change.beforeElementId);
+	if (change.op === "list.insert") if (isJsonObject(change.value)) writeObject(list.insertContainer(before, new LoroMap()), {}, change.value);
+	else list.insert(before, change.value);
+	else {
+		const from = index(change.elementId);
+		const to = before > from ? before - 1 : before;
+		if (from !== to) list.move(from, to);
+	}
+}
+//#endregion
+//#region src/entity-crdt/ordering.ts
+/**
+* Domain order is scoped by membership: the members of one container, in the
+* order their `contain` Relations sit in the rows.
+*
+* Nothing carries a copy of its own position, so this reads the order rather
+* than deriving it — the rows are already in it.
+*/
+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) {
+		if (!isSequencedRelationKind(relation.relationKind)) continue;
+		const childKind = entities.get(String(relation.endpoint1EntityId))?.entityKind;
+		if (childKind !== "track" && childKind !== "clip") continue;
+		const parent = String(relation.endpoint0EntityId);
+		groups.set(parent, [...groups.get(parent) ?? [], String(relation.endpoint1EntityId)]);
+	}
+	return groups;
+}
+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/apply.ts
+/**
+* Apply rows to a document as native Loro operations, returning the update.
+* On a live peer the edit joins its local undo history; an edit made on an
+* earlier baseline is applied to `LoroEntityDocument.fromSnapshot` of it.
+*/
+function apply(editor, rows) {
+	const baseline = editor.snapshot();
+	const before = baseline.rows;
+	const oldEntities = new Map(before.entities.map((row) => [row.entityId, row]));
+	const newEntities = new Map(rows.entities.map((row) => [row.entityId, row]));
+	const oldRelations = new Map(before.relations.map((row) => [row.relationId, row]));
+	const newRelations = new Map(rows.relations.map((row) => [row.relationId, row]));
+	if (newEntities.size !== rows.entities.length || newRelations.size !== rows.relations.length) throw new Error("Duplicate domain identity");
+	return {
+		update: editor.transact((draft) => {
+			for (const row of before.relations) {
+				const next = newRelations.get(row.relationId);
+				if (!next) draft.unlink(row.relationId);
+				else if (next.relationKind !== row.relationKind || next.endpoint0EntityId !== row.endpoint0EntityId || next.endpoint1EntityId !== row.endpoint1EntityId) throw new Error("Relation identity cannot change kind or endpoint positions");
+			}
+			let attached = baseline.project.audioScriptEntityId !== void 0;
+			for (const row of rows.entities) {
+				const previous = oldEntities.get(row.entityId);
+				if (!previous) {
+					draft.create(row);
+					if (!attached && row.entityKind === "audio-script") {
+						draft.attach("audioScriptEntityId", String(row.entityId));
+						attached = true;
+					}
+				} else {
+					if (previous.entityKind !== row.entityKind) throw new Error("Entity kind cannot change");
+					if (!equalJson(previous.payload, row.payload)) draft.replaceOwned(row.entityId, row.payload);
+				}
+			}
+			for (const row of rows.relations) if (!oldRelations.has(row.relationId)) draft.link(row);
+			const beforeOrder = entityOrderGroups(before), afterOrder = entityOrderGroups(rows);
+			for (const group of new Set([...beforeOrder.keys(), ...afterOrder.keys()])) {
+				const next = afterOrder.get(group) ?? [];
+				if (!equalJson(beforeOrder.get(group) ?? [], next)) draft.order(group, next);
+			}
+			for (const row of before.entities) if (!newEntities.has(row.entityId)) draft.delete(row.entityId);
+		}),
+		state: editor.snapshot()
+	};
+}
+//#endregion
+//#region src/entity-crdt/audio-script-assets.ts
+/** A segment as a resource file writes it. */
+function segmentJson({ segmentId, text, language }) {
+	return {
+		segmentId,
+		text,
+		...language === void 0 ? {} : { language }
+	};
+}
+/** The bytes a resource is stored as: its JSON text, exactly as uploaded. */
+function assetBytes(content) {
+	return new TextEncoder().encode(JSON.stringify(content));
+}
+/** The fingerprint of those bytes: `sha256:` and the hex of their SHA-256. */
+function assetDigest(content) {
+	return `sha256:${bytesToHex(sha256(assetBytes(content)))}`;
+}
+/** A resource is a snapshot of text; the native Loro text remains the editing authority. */
+function audioScriptAssetContent(rows, entityId) {
+	return { segments: segmentsOf(assembleEntityContent(rows, createEntityId(entityId), "audio-script")).map(segmentJson) };
+}
+/** What a script's snapshot holds, which is a different document for each kind of script. */
+function scriptAssetContent(rows, entityId) {
+	const kind = rows.entities.find((row) => String(row.entityId) === entityId)?.entityKind;
+	if (kind === "audio-script") return audioScriptAssetContent(rows, entityId);
+	if (kind === "phonetic-script") return phoneticScriptAssetContent(rows, entityId);
+	throw new Error(`Entity ${entityId} is a ${String(kind)}, which writes out no snapshot`);
+}
+/**
+* Whether a script's snapshot still holds its content: the Asset's digest is
+* that of what the script would be saved as now.
+*
+* Only a `writable` Asset can be judged this way, because only for bytes this
+* document wrote is the digest one it can work out again. Anything else holds a
+* store's bytes and is left alone; a writable one with no digest cannot say
+* what it holds, so the content is written out again.
+*/
+function scriptSnapshotIsCurrent(rows, entityId) {
+	const snapshot = scriptSnapshotAssetOf(rows, entityId)?.payload;
+	if (snapshot === void 0) return false;
+	if (snapshot.writable !== true) return true;
+	return snapshot.digest !== void 0 && snapshot.digest === assetDigest(scriptAssetContent(rows, entityId));
+}
+/**
+* The Asset a script was written out to. It is a snapshot the script owns, so
+* it is reached by `to-asset` — not `from-asset`, which would say the script
+* was produced from bytes it cannot change.
+*/
+function scriptSnapshotAssetOf(rows, entityId) {
+	return boundAsset(rows, entityId, "to-asset");
+}
+/**
+* The Asset a script was made from — a transcript it does not own. A script
+* that has one never writes a snapshot of its own: the bytes it would describe
+* are already named, and rewriting them would contradict their source.
+*/
+function scriptSourceAssetOf(rows, entityId) {
+	return boundAsset(rows, entityId, "from-asset");
+}
+function boundAsset(rows, entityId, relationKind) {
+	const link = rows.relations.find((relation) => relation.relationKind === relationKind && (String(relation.endpoint0EntityId) === entityId || String(relation.endpoint1EntityId) === entityId));
+	if (link === void 0) return void 0;
+	const otherId = String(link.endpoint0EntityId) === entityId ? link.endpoint1EntityId : link.endpoint0EntityId;
+	return rows.entities.find((row) => String(row.entityId) === String(otherId) && row.entityKind === "asset");
+}
+/**
+* What a PhoneticScript hands to synthesis: the base AudioScript's text as the
+* variant pronounces it, plus the variant's own phoneme control.
+*
+* The variant's content is written by a model — deciding how words are said is
+* text work, not a mechanical copy — but the bytes a synthesizer reads have to
+* leave the entity graph to reach it, because synthesis does not handle
+* entities. Writing this resource down is that crossing, and it is why speech
+* can only come from a PhoneticScript.
+*/
+function phoneticScriptAssetContent(rows, entityId) {
+	const phonetic = assembleEntityContent(rows, createEntityId(entityId), "phonetic-script");
+	const { phonemeScript } = phonetic.payload;
+	return {
+		text: assembleScriptText(phonetic),
+		segments: segmentsOf(phonetic).map(segmentJson),
+		...phonemeScript === void 0 ? {} : { phonemeScript }
+	};
+}
+//#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) {
+	return content(workspace(doc, key));
+}
+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)));
+}
+/** The JSON tree the document keeps a row's fields as. */
+function tree(payload) {
+	return payload;
+}
+/** A row read back from the document. Every state it holds compiled, so its fields are its kind's. */
+function entityRow(entityId, entityKind, payload) {
+	return {
+		entityId: createEntityId(entityId),
+		entityKind,
+		payload
+	};
+}
+function owned(payload) {
+	const { bases: _bases, ...fields } = payload;
+	return fields;
+}
+function baseIds(payload) {
+	const ids = payload.bases ?? [];
+	if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string") || new Set(ids).size !== ids.length) throw new Error("bases 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 (["dsl", "mixed"].includes(documentFormat(doc))) throw new UnsupportedDocumentFormatError();
+	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 current = bases(map).map((id) => currentId(doc, id, ids));
+		return entityRow(entityId, map.get("kind"), {
+			...entityContent(doc, key),
+			...current.length ? { bases: current } : {}
+		});
+	});
+	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])
+		});
+	}
+	sortSequencedRelations(doc, relations);
+	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;
+		if (["dsl", "mixed"].includes(documentFormat(doc))) throw new UnsupportedDocumentFormatError();
+		this.undoManager = new UndoManager(doc, {
+			mergeInterval: 0,
+			excludeOriginPrefixes: [MATERIALIZE_ORIGIN]
+		});
+	}
+	/** Open the causal snapshot an edit is applied against. */
+	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$1(doc, {
+			type: "create",
+			row
+		});
+		for (const row of rows.relations) apply$1(doc, {
+			type: "relation",
+			row
+		});
+		for (const [slot, entityId] of Object.entries(project)) apply$1(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);
+	}
+	/** Resolve a queued edit target through its native identity without changing history. */
+	resolveCurrentEntityId(id) {
+		return currentId(this.doc, 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 entityRow(entityId, 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$1(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 });
+	}
+	/**
+	* Bind a saved snapshot without rewriting text operations or resolving
+	* selection conflicts. The script names the bytes the same way everything
+	* else does — an Asset entity plus a Relation — and the Asset's digest says
+	* which content they hold, which is what tells a stale snapshot from a
+	* current one. The Relation is `to-asset`: these bytes are the script's own
+	* content written out, not a source it was made from, so the Asset is
+	* `writable`.
+	*/
+	bindScriptAsset(entityId, snapshot) {
+		const key = family(this.doc, entityId);
+		const rows = readEntityDocument(this.doc, true).rows;
+		const current = currentIds(this.doc).get(key);
+		const script = rows.entities.find((row) => row.entityId === current);
+		if (script?.entityKind !== "audio-script" && script?.entityKind !== "phonetic-script") throw new Error("Resource binding requires an active script");
+		if (assetDigest(scriptAssetContent(rows, script.entityId)) !== snapshot.digest) throw new Error("Script changed while saving its resource");
+		const assetId = snapshot.key;
+		if (!assetId.trim()) throw new Error("Script resource writer returned an empty asset ID");
+		const before = this.doc.oplogVersion();
+		const existing = rows.entities.find((row) => row.entityKind === "asset" && row.payload.system === "memota" && row.payload.key === assetId);
+		const assetEntityId = existing?.entityId ?? createEntityId(`asset_${assetId}`);
+		if (existing !== void 0 && existing.payload.writable !== true) throw new Error(`Asset ${assetId} holds a store's own bytes`);
+		if (existing?.payload.digest !== void 0 && existing.payload.digest !== snapshot.digest) throw new Error(`Asset ${assetId} already holds other bytes`);
+		if (existing === void 0) this.transact((draft) => draft.create({
+			entityId: assetEntityId,
+			entityKind: "asset",
+			payload: {
+				system: "memota",
+				key: assetId,
+				digest: snapshot.digest,
+				writable: true
+			}
+		}));
+		else if (existing.payload.digest === void 0) this.transact((draft) => draft.declare(assetEntityId, { digest: snapshot.digest }));
+		if (scriptSnapshotAssetOf(readEntityDocument(this.doc, true).rows, entityId)?.entityId !== assetEntityId) this.transact((draft) => {
+			const current = readEntityDocument(this.doc, true).rows;
+			for (const relation of current.relations) if (relation.relationKind === "to-asset" && (String(relation.endpoint0EntityId) === String(entityId) || String(relation.endpoint1EntityId) === String(entityId))) draft.unlink(String(relation.relationId));
+			draft.link({
+				relationId: createRelationId(`relation_to-asset_${entityId}_${assetId}`),
+				relationKind: "to-asset",
+				endpoint0EntityId: createEntityId(entityId),
+				endpoint1EntityId: assetEntityId
+			});
+		});
+		return this.doc.export({
+			mode: "update",
+			from: before
+		});
+	}
+	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 = new Map(this.snapshot().rows.entities.map((row) => [family(this.doc, row.entityId), row]));
+		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.get(id);
+			if (previous && !equalJson(owned(tree(previous.payload)), owned(tree(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();
+	relationAliases = /* @__PURE__ */ new Map();
+	constructor(doc) {
+		this.doc = doc;
+		for (const row of this.snapshot().rows.relations) this.relationAliases.set(row.relationId, this.relationRoot(row.relationId));
+	}
+	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()
+		});
+	}
+	/** Project the final scalar placement intents onto the existing native ordering containers. */
+	reconcileOrder(rows) {
+		const before = new Map([...entityOrderGroups(this.snapshot().rows)].map(([id, ids]) => [family(this.doc, id), ids.map((id) => family(this.doc, id))]));
+		const after = new Map([...entityOrderGroups(rows)].map(([id, ids]) => [family(this.doc, id), ids.map((id) => family(this.doc, id))]));
+		for (const group of new Set([...before.keys(), ...after.keys()])) {
+			const next = after.get(group) ?? [];
+			if (!equalJson(before.get(group) ?? [], next)) this.order(group, next);
+		}
+	}
+	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)
+		});
+	}
+	unlink(relationId) {
+		this.record({
+			type: "unlink",
+			root: this.relationRoot(relationId)
+		});
+	}
+	relationRoot(relationId) {
+		const alias = this.relationAliases.get(relationId);
+		if (alias !== void 0) return alias;
+		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 || key === 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(tree(fields))) {
+			const owner = resolveEntityFieldOwner(state.rows, id, field) ?? id;
+			const payload = updates.get(owner) ?? clone(tree(state.rows.entities.find((row) => row.entityId === owner).payload));
+			updates.set(owner, {
+				...payload,
+				[field]: clone(value)
+			});
+		}
+		for (const [owner, payload] of updates) this.write(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.write(entityId, {
+			...tree(row.payload),
+			...tree(fields)
+		});
+	}
+	replaceOwned(entityId, payload) {
+		this.write(entityId, tree(payload));
+	}
+	write(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 state = this.snapshot();
+		const target = createEntityId(currentId(this.doc, entityId));
+		const owner = resolveEntityFieldOwner(state.rows, target, path[0]) ?? target;
+		this.record({
+			type: "text",
+			root: family(this.doc, owner),
+			path: [...path],
+			start,
+			deleteCount,
+			text,
+			token: globalThis.crypto.randomUUID()
+		});
+	}
+	/** Generic assembled-field edit applied at the author's causal position. */
+	change(entityId, changes) {
+		assertFieldChanges(changes);
+		for (const raw of changes) {
+			const change = clone(raw);
+			if (change.path[0] === "bases") {
+				if (change.op === "list.insert" && typeof change.value === "string") change.value = currentId(this.doc, change.value);
+				if (change.op === "list.remove" || change.op === "list.move") change.elementId = currentId(this.doc, change.elementId);
+				if ((change.op === "list.insert" || change.op === "list.move") && change.beforeElementId !== null) change.beforeElementId = currentId(this.doc, change.beforeElementId);
+			}
+			const state = this.snapshot();
+			const id = createEntityId(currentId(this.doc, entityId));
+			const owner = resolveEntityFieldOwner(state.rows, id, change.path[0]) ?? id;
+			const payload = tree(state.rows.entities.find((row) => row.entityId === owner).payload);
+			if (equalJson(payload, applyFieldChanges(payload, [change]))) continue;
+			this.record({
+				type: "field",
+				root: family(this.doc, owner),
+				path: resolveFieldPath(payload, change.path),
+				change: clone(change),
+				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)).selection, command.payload.selection)) this.selectedRoots.add(command.root);
+		if (command.type === "field" && command.path[0] === "selection") this.selectedRoots.add(command.root);
+		apply$1(this.doc, command);
+		this.commands.push(command);
+	}
+};
+function apply$1(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(tree(row.payload)));
+			writeBases(doc, map, baseIds(tree(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 "field": {
+			const map = workspace(doc, command.root);
+			if (command.path[0] === "bases") {
+				const before = { bases: bases(map).map((id) => currentId(doc, id)) };
+				if (command.change.op === "list.move") throw new Error("Composition bases are unordered; list.move is not applicable");
+				writeBases(doc, map, baseIds(applyFieldChanges(before, [command.change])));
+			} else {
+				applyNativeFieldChange(requireMap(map, "content"), command.path, command.change);
+				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");
+			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 "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") return void 0;
+	const { selection } = row.payload;
+	if (selection?.textRange === void 0) return void 0;
+	const source = segmentsOf(assembleEntityContent(rows, row.entityId)).find((segment) => segment.segmentId === selection.segmentId);
+	if (source === void 0) throw new Error("Caption text selection source is missing");
+	return hash([selection, source.text]);
+}
+function assertState(state) {
+	const composition = checkComposition(state.rows);
+	if (composition.length > 0) throw new Error(composition.map((issue) => issue.message).join("; "));
+	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, allowSelectionConflicts = false) {
+	const state = readEntityDocument(doc, allowSelectionConflicts);
+	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,
+			...tree(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);
+}
+/**
+* Put each container's sequenced Relations in the order its native list states.
+*
+* Per container, never across: a Timeline's Tracks and a Track's Clips are two
+* separate orders, and sorting them together would interleave them.
+*/
+function sortSequencedRelations(doc, relations) {
+	const containers = /* @__PURE__ */ new Map();
+	for (const [slot, relation] of relations.entries()) {
+		if (!isSequencedRelationKind(relation.relationKind)) continue;
+		const container = String(relation.endpoint0EntityId);
+		const ordinal = entityOrdinal(doc, family(doc, String(relation.endpoint1EntityId))) ?? slot;
+		containers.set(container, [...containers.get(container) ?? [], {
+			slot,
+			relation,
+			ordinal
+		}]);
+	}
+	for (const members of containers.values()) {
+		const slots = members.map((member) => member.slot);
+		const ordered = [...members].sort((left, right) => left.ordinal - right.ordinal);
+		slots.forEach((slot, at) => relations[slot] = ordered[at].relation);
+	}
+}
+//#endregion
+//#region src/entity-editor/document-audio-script.ts
+/** Read only the attached version and preserve every segment; never aggregate other scripts. */
+function readDocumentAudioScript(state) {
+	const id = state.audioScriptEntityId;
+	if (id === null) throw new EntityTimelineProjectionError("Document AudioScript is not initialized");
+	if (typeof id !== "string" || id.trim() !== id || !id) throw new EntityTimelineProjectionError("Invalid document AudioScript identity");
+	const entity = state.rows.entities.find((row) => row.entityId === id);
+	if (!entity || entity.entityKind !== "audio-script") throw new EntityTimelineProjectionError(`Document AudioScript ${id} must name the project AudioScript`);
+	return {
+		entityId: id,
+		segments: structuredClone(segmentsOf(entity))
+	};
+}
+//#endregion
+//#region src/entity-editor/editor-resources.ts
+const roleOrder = {
+	caption: 0,
+	video_clip: 1,
+	speech: 2,
+	bgm: 3
+};
+/**
+* MEngine editor policy, not a cardinality restriction on the general-purpose DSL.
+*
+* Resources live on Asset entities and are reached through `from-asset`: no
+* other entity carries a locator, one Asset claims each `(system, key)` pair,
+* and media reaches at most one Asset. Media whose bytes are not named through
+* that Relation is rejected rather than guessed at.
+*/
+function assertCanonicalEditorResources(rows) {
+	if (rows.entities.filter((row) => row.entityKind === "timeline").length > 1) throw new EntityTimelineProjectionError("Editor requires exactly one Timeline");
+	for (const role of Object.keys(roleOrder)) if (rows.entities.filter((row) => row.entityKind === "track" && roleOf(rows, row) === role).length > 1) throw new EntityTimelineProjectionError(`Editor has multiple ${role} Tracks`);
+	const identityByAssetKey = /* @__PURE__ */ new Map();
+	for (const entity of rows.entities) {
+		if (entity.entityKind === "asset") {
+			const locator = memotaLocator(entity.payload);
+			if (locator === void 0) throw new EntityTimelineProjectionError(`Asset ${entity.entityId} must state where its bytes live`);
+			const key = JSON.stringify([locator.system, locator.key]);
+			const previous = identityByAssetKey.get(key);
+			if (previous !== void 0 && previous !== entity.entityId) throw new EntityTimelineProjectionError(`Duplicate Asset for ${key}; reuse ${previous}`);
+			identityByAssetKey.set(key, entity.entityId);
+			continue;
+		}
+		if (memotaLocator(entity.payload) !== void 0) throw new EntityTimelineProjectionError(`Entity ${entity.entityId} must not carry a locator; link its Asset with from-asset`);
+	}
+	for (const entity of rows.entities) {
+		if (!isMediaAssetVariantKind(entity.entityKind)) continue;
+		const own = assetIdsOf(rows, entity.entityId).length;
+		if (own > 1 || own === 0 && assetOf(rows, entity.entityId) === void 0) throw new EntityTimelineProjectionError(`Media Entity ${entity.entityId} requires exactly one from-asset Asset`);
+	}
+}
+/** A Track's role, read through its bases. */
+function roleOf(rows, track) {
+	return assembleEntityContent(rows, track.entityId, "track").payload.role;
+}
+/** The Asset ids one entity reaches, in row order. */
+function assetIdsOf(rows, entityId) {
+	const assets = new Set(rows.entities.filter((row) => row.entityKind === "asset").map((row) => String(row.entityId)));
+	return rows.relations.filter((relation) => relation.relationKind === "from-asset").map((relation) => String(relation.endpoint0EntityId) === entityId ? String(relation.endpoint1EntityId) : String(relation.endpoint1EntityId) === entityId ? String(relation.endpoint0EntityId) : void 0).filter((id) => id !== void 0 && assets.has(id));
+}
+/**
+* Commit-transition policy shared by the editor, the HTTP commit boundary, the
+* host tool, and the entity stores. It compares the authoritative before and
+* after rows of one CAS commit and enforces the resource rules on the complete
+* after state, with no exemption for historical graphs:
+*
+* 1. every media Entity reaches exactly one Asset through `from-asset`;
+* 2. no entity other than an Asset carries a locator;
+* 3. an Asset's locator is immutable — pointing it at other bytes would
+*    silently rewrite every entity already made from it.
+*
+* Deleting media is explicit and allowed.
+*/
+function assertMediaAssetWritePolicy(before, after) {
+	const beforeEntities = new Map(before.entities.map((row) => [String(row.entityId), row]));
+	assertCanonicalEditorResources(after);
+	for (const row of after.entities) {
+		if (row.entityKind !== "asset") continue;
+		const prior = memotaLocator(beforeEntities.get(String(row.entityId))?.payload);
+		if (prior === void 0) continue;
+		const next = memotaLocator(row.payload);
+		if (next !== void 0 && (next.system !== prior.system || next.key !== prior.key)) throw new EntityTimelineProjectionError(`Asset ${row.entityId} cannot be pointed at other bytes; create a new Asset instead`);
+	}
+}
+/**
+* The locator a payload states, if any. The rows checked here may break the
+* contract — a media entity still carrying the locator it had before Assets —
+* so the payload is read field by field rather than trusted by its kind.
+*/
+function memotaLocator(payload) {
+	const { system, key } = payload ?? {};
+	if (system !== "memota" && system !== "memota-speech" || typeof key !== "string" || key.trim() === "") return void 0;
+	return {
+		system,
+		key
+	};
+}
+/**
+* Bootstrap an empty script when the foundation has no candidate. Without an
+* explicit project attachment, multiple candidates are ambiguous. Existing
+* content IDs are reused here; Loro editing advances their immutable versions.
+*/
+function ensureDocumentAudioScript(entities, selectedEntityId) {
+	if (selectedEntityId != null) {
+		if (!entities.some((row) => row.entityKind === "audio-script" && row.entityId === selectedEntityId)) throw new EntityTimelineProjectionError(`Selected AudioScript ${selectedEntityId} does not exist`);
+		return selectedEntityId;
+	}
+	const scripts = entities.filter((row) => row.entityKind === "audio-script");
+	if (scripts.length > 1) throw new EntityTimelineProjectionError("Select an AudioScript for the editor panel when multiple scripts exist");
+	return scripts[0]?.entityId ?? null;
+}
+/** Add only missing editor structure; existing identities and owned settings are never replaced. */
+function ensureEditorFoundation(initial, idFactory = (prefix) => `${prefix}_${globalThis.crypto.randomUUID()}`, selectedAudioScriptEntityId) {
+	const entities = structuredClone([...initial.entities]);
+	const relations = structuredClone([...initial.relations]);
+	const roots = entities.filter((row) => row.entityKind === "timeline");
+	if (roots.length > 1) throw new EntityTimelineProjectionError("Editor requires exactly one Timeline");
+	const mintEntity = () => {
+		const id = createEntityId(idFactory("entity"));
+		if (entities.some((row) => row.entityId === id)) throw new Error(`Duplicate entity id ${id}`);
+		return id;
+	};
+	let timeline = roots[0];
+	if (timeline === void 0) {
+		timeline = {
+			entityId: mintEntity(),
+			entityKind: "timeline",
+			payload: {}
+		};
+		entities.push(timeline);
+	}
+	const trackEntityIds = {};
+	for (const role of Object.keys(roleOrder)) {
+		const matches = entities.filter((row) => row.entityKind === "track" && roleOf({
+			entities,
+			relations
+		}, row) === role);
+		if (matches.length > 1) throw new EntityTimelineProjectionError(`Editor has multiple ${role} Tracks`);
+		let track = matches[0];
+		if (track === void 0) {
+			track = {
+				entityId: mintEntity(),
+				entityKind: "track",
+				payload: { role }
+			};
+			entities.push(track);
+		}
+		const bindings = relations.filter((row) => row.relationKind === "contain" && (row.endpoint0EntityId === track.entityId || row.endpoint1EntityId === track.entityId));
+		if (bindings.some((row) => row.endpoint0EntityId !== timeline.entityId && row.endpoint1EntityId !== timeline.entityId)) throw new EntityTimelineProjectionError(`Track ${track.entityId} belongs to another Timeline`);
+		if (bindings.length === 0) {
+			const relationId = createRelationId(idFactory("relation"));
+			if (relations.some((row) => row.relationId === relationId)) throw new Error(`Duplicate relation id ${relationId}`);
+			relations.push({
+				relationId,
+				relationKind: "contain",
+				endpoint0EntityId: timeline.entityId,
+				endpoint1EntityId: track.entityId
+			});
+		}
+		trackEntityIds[role] = track.entityId;
+	}
+	const audioScriptEntityId = ensureDocumentAudioScript(entities, selectedAudioScriptEntityId);
+	return {
+		rows: {
+			entities,
+			relations
+		},
+		timelineEntityId: timeline.entityId,
+		trackEntityIds,
+		audioScriptEntityId
+	};
+}
+//#endregion
+//#region src/entity-editor/entity-graph-http-client.ts
+const MENGINE_API_PREFIX = "/api/mengine/v1";
+/** Browser-safe authenticated Loro client for a document's Entity graph. */
+var EntityGraphHttpClient = class {
+	options;
+	transport;
+	endpoint;
+	constructor(options) {
+		this.options = options;
+		this.transport = new MengineHttpClient(options);
+		const origin = options.httpOrigin.replace(/\/$/, "");
+		this.endpoint = `${origin}${MENGINE_API_PREFIX}/docs/${encodeURIComponent(options.docId)}/entity-state`;
+	}
+	async fetchState() {
+		return this.request({ method: "GET" });
+	}
+	/**
+	* Apply edits against the original causal snapshot and publish native Loro operations.
+	*
+	* Deletion intent is derived from baseline IDs omitted from `nextRows`, so a
+	* transient create-then-remove never becomes a request to delete unknown
+	* persisted data.
+	*/
+	async commit(baseState, nextRows, options = {}) {
+		if (options.migrationBaseVv !== void 0) throw new Error("Legacy entity migration is not supported by the Loro contract");
+		const next = cloneAndValidateRows(nextRows);
+		assertMediaAssetWritePolicy(baseState.rows, next);
+		const applied = apply(LoroEntityDocument.fromSnapshot(base64ToBytes(baseState.loroSnapshot)), next);
+		return this.commitUpdate(bytesToBase64(applied.update));
+	}
+	/** Send the same prepared bytes on retry; never re-apply an unconfirmed edit. */
+	async commitUpdate(update) {
+		return this.request({
+			method: "POST",
+			body: JSON.stringify({ update })
+		});
+	}
+	async request(init) {
+		const response = await this.transport.fetch(this.endpoint, {
+			...init,
+			headers: this.transport.headers()
+		});
+		const payload = await safeReadJson(response);
+		if (!response.ok) throw new MengineHttpRequestError(response.status, payload);
+		return parseWireState(payload, this.options.docId);
+	}
+};
+function parseWireState(value, expectedDocId) {
+	if (!isRecord(value) || typeof value.doc_id !== "string" || !isNonNegativeSafeInteger(value.revision)) throw new Error("Invalid entity-state response envelope");
+	if (value.doc_id !== expectedDocId) throw new Error(`Entity-state response doc_id mismatch: expected "${expectedDocId}"`);
+	const rows = parseWireRows(value.rows);
+	compile(rows);
+	const attached = value.audio_script_entity_id;
+	if (attached !== null && typeof attached !== "string") throw new Error("Invalid document AudioScript identity");
+	if (typeof value.loro_snapshot !== "string") throw new Error("Missing causal Loro snapshot");
+	const state = {
+		revision: value.revision,
+		loroSnapshot: value.loro_snapshot,
+		rows,
+		audioScriptEntityId: attached
+	};
+	if (attached !== null) readDocumentAudioScript(state);
+	return state;
+}
+function parseWireRows(value) {
+	if (!isRecord(value) || !Array.isArray(value.entities) || !Array.isArray(value.relations)) throw new Error("Invalid entity-state response rows");
+	return {
+		entities: value.entities.map(parseWireEntity),
+		relations: value.relations.map(parseWireRelation)
+	};
+}
+/** Shape only: `compile` then judges each row as its kind states it. */
+function parseWireEntity(value) {
+	if (!isRecord(value) || !isRecord(value.payload)) throw new Error("Invalid Entity row in entity-state response");
+	return {
+		entityId: createEntityId(requiredString(value.entity_id, "entity_id")),
+		entityKind: requiredString(value.entity_kind, "entity_kind"),
+		payload: structuredClone(value.payload)
+	};
+}
+function parseWireRelation(value) {
+	if (!isRecord(value)) throw new Error("Invalid Relation row in entity-state response");
+	return {
+		relationId: createRelationId(requiredString(value.relation_id, "relation_id")),
+		relationKind: requiredString(value.relation_kind, "relation_kind"),
+		endpoint0EntityId: createEntityId(requiredString(value.endpoint_0_entity_id, "endpoint_0_entity_id")),
+		endpoint1EntityId: createEntityId(requiredString(value.endpoint_1_entity_id, "endpoint_1_entity_id"))
+	};
+}
+function cloneAndValidateRows(rows) {
+	const clone = structuredClone(rows);
+	compile(clone);
+	return clone;
+}
+function requiredString(value, field) {
+	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) throw new Error(`Invalid ${field} in entity-state response`);
+	return value;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonNegativeSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+async function safeReadJson(response) {
+	const text = await response.text();
+	if (text.length === 0) return null;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+//#endregion
+//#region src/entity-editor/caption-content.ts
+/** Author Caption content from semantic intent; callers never reconcile variant bases or assembled fields. */
+function prepareCaptionContent(rows, input) {
+	const entityId = createEntityId(input.contentEntityId);
+	const scriptId = createEntityId(input.audioScriptEntityId);
+	if (!Number.isFinite(input.durationMs) || input.durationMs <= 0) throw new Error("Caption duration must be positive");
+	const previous = rows.entities.find((row) => row.entityId === entityId);
+	if (previous !== void 0 && previous.entityKind !== "caption") throw new Error("Caption content identity has a different kind");
+	let nextBases = [scriptId];
+	if (previous !== void 0) {
+		const source = baseFieldOwner(rows, entityId, "segments");
+		if (source === void 0) throw new Error("Caption composes no AudioScript");
+		const previousBases = basesOf(previous);
+		if (source !== scriptId && !previousBases.includes(source)) throw new Error("Replacing an indirectly composed AudioScript requires an explicit composition change");
+		nextBases = previousBases.map((id) => id === source ? scriptId : id);
+	}
+	const candidate = {
+		entityId,
+		entityKind: "caption",
+		payload: {
+			...previous?.payload,
+			bases: nextBases,
+			durationMs: previous?.payload.durationMs ?? input.durationMs
+		}
+	};
+	const graph = {
+		...rows,
+		entities: [...rows.entities.filter((row) => row.entityId !== entityId), candidate]
+	};
+	const assembled = assembleEntityContent(graph, entityId);
+	const selected = {
+		...candidate,
+		payload: {
+			...candidate.payload,
+			selection: captionSelection(input.selection ?? selectCaptionText(assembled, input.text))
+		}
+	};
+	if (selectedSegment(assembleEntityContent({
+		...graph,
+		entities: graph.entities.map((row) => row.entityId === entityId ? selected : row)
+	}, entityId)).text !== input.text) throw new Error("Caption review text differs from its assembled variant content");
+	return selected;
+}
+/** A selection as it is stored: the segment it names and, when narrowed, its code-point range, nothing else. */
+function captionSelection({ segmentId, textRange }) {
+	return textRange === void 0 ? { segmentId } : {
+		segmentId,
+		textRange: {
+			start: textRange.start,
+			end: textRange.end
+		}
+	};
+}
+function selectCaptionText(caption, text) {
+	if (!text.trim()) throw new Error("Caption text selection must not be blank");
+	const matches = [];
+	for (const segment of segmentsOf(caption)) {
+		let offset = segment.text.indexOf(text);
+		while (offset !== -1) {
+			const start = Array.from(segment.text.slice(0, offset)).length;
+			matches.push({
+				segmentId: segment.segmentId,
+				textRange: {
+					start,
+					end: start + Array.from(text).length
+				}
+			});
+			offset = segment.text.indexOf(text, offset + 1);
+		}
+	}
+	if (matches.length !== 1) throw new Error("Caption text must select a unique AudioScript range; provide explicit selection");
+	return matches[0];
+}
+//#endregion
+//#region src/entity-editor/media-asset-import.ts
+/**
+* Import at the editor boundary, not at asset generation time. Existing
+* provenance is retained.
+*
+* The bytes are named once, on an Asset entity, and the media entity reaches
+* them through a `from-asset` Relation. Re-importing the same `(system, key)`
+* reuses that Asset and the media already made from it, so one stored resource
+* is never copied into several rows.
+*/
+function importMediaAsset(initial, fact, idFactory = (prefix) => `${prefix}_${globalThis.crypto.randomUUID()}`) {
+	if (!fact.assetId || fact.assetId.trim() !== fact.assetId) throw new Error("Expected an asset id");
+	if (!isMediaAssetVariantKind(fact.kind)) throw new Error("Unsupported media kind");
+	const durationMs = statedDuration(fact);
+	if ((fact.kind === "audio" || fact.kind === "voiceover-recording") && fact.storageKey.trim() === "") throw new Error(`${fact.kind} ${fact.assetId} requires its physical storage key`);
+	compile(initial);
+	assertCanonicalEditorResources(initial);
+	const entities = structuredClone([...initial.entities]);
+	const relations = structuredClone([...initial.relations]);
+	const system = fact.kind === "voiceover-recording" ? "memota-speech" : "memota";
+	const entityKind = fact.kind;
+	const timbre = fact.kind === "voiceover-recording" ? fact.voice : void 0;
+	const asset = ensureAsset(entities, {
+		system,
+		key: fact.assetId,
+		storageKey: fact.storageKey
+	}, idFactory);
+	const madeFromAsset = entities.filter((row) => row.entityId !== asset.entityId && assetIdOf(relations, row.entityId) === asset.entityId);
+	if (madeFromAsset.length > 1) throw new Error(`Duplicate media identities for ${fact.assetId}; reuse ${madeFromAsset[0].entityId}`);
+	const existing = madeFromAsset[0];
+	if (existing !== void 0) {
+		if (existing.entityKind !== entityKind || existing.payload.durationMs !== durationMs) throw new Error(`Media facts conflict with existing identity for ${fact.assetId}`);
+		const voiceEntityId = bindVoiceTimbre(entities, relations, existing.entityId, timbre, idFactory);
+		return {
+			rows: {
+				entities,
+				relations
+			},
+			contentEntityId: existing.entityId,
+			assetEntityId: asset.entityId,
+			...voiceEntityId
+		};
+	}
+	const entityId = createEntityId(idFactory("entity"));
+	if (entities.some((row) => row.entityId === entityId)) throw new Error(`Duplicate entity id ${entityId}`);
+	entities.push({
+		entityId,
+		entityKind,
+		payload: { durationMs }
+	});
+	relations.push(assetLink(entityId, asset.entityId, idFactory));
+	if (fact.kind === "voiceover-recording" && fact.phoneticScriptEntityId !== void 0) {
+		const phonetic = entities.find((row) => String(row.entityId) === fact.phoneticScriptEntityId);
+		if (phonetic?.entityKind !== "phonetic-script") throw new Error(`Voiceover ${fact.assetId} requires the PhoneticScript it was spoken from`);
+		relations.push({
+			relationId: createRelationId(idFactory("relation")),
+			relationKind: "derived-from",
+			endpoint0EntityId: entityId,
+			endpoint1EntityId: phonetic.entityId
+		});
+	}
+	const voiceEntityId = bindVoiceTimbre(entities, relations, entityId, timbre, idFactory);
+	const rows = {
+		entities,
+		relations
+	};
+	compile(rows);
+	assertCanonicalEditorResources(rows);
+	return {
+		rows,
+		contentEntityId: entityId,
+		assetEntityId: asset.entityId,
+		...voiceEntityId
+	};
+}
+/**
+* One Asset per `(system, key)`: the bytes are named in exactly one row.
+*
+* Imported media is a store's own, which the Asset says by stating no
+* `writable` — unlike a snapshot the document wrote out of its own content.
+*/
+function ensureAsset(entities, locator, idFactory) {
+	const found = entities.find((row) => row.entityKind === "asset" && row.payload.system === locator.system && row.payload.key === locator.key);
+	if (found !== void 0) {
+		if (locator.storageKey === void 0 || found.payload.storageKey === locator.storageKey) return found;
+		if (found.payload.storageKey !== void 0) throw new Error(`Media facts conflict with existing storage key for ${locator.key}`);
+		const filled = {
+			...found,
+			payload: {
+				...found.payload,
+				storageKey: locator.storageKey
+			}
+		};
+		replaceEntity$1(entities, found.entityId, filled);
+		return filled;
+	}
+	const asset = {
+		entityId: createEntityId(idFactory("entity")),
+		entityKind: "asset",
+		payload: {
+			system: locator.system,
+			key: locator.key,
+			...locator.storageKey === void 0 ? {} : { storageKey: locator.storageKey }
+		}
+	};
+	entities.push(asset);
+	return asset;
+}
+function assetLink(entityId, assetEntityId, idFactory) {
+	return {
+		relationId: createRelationId(idFactory("relation")),
+		relationKind: "from-asset",
+		endpoint0EntityId: createEntityId(entityId),
+		endpoint1EntityId: createEntityId(assetEntityId)
+	};
+}
+function assetIdOf(relations, entityId) {
+	const link = relations.find((relation) => relation.relationKind === "from-asset" && (relation.endpoint0EntityId === entityId || relation.endpoint1EntityId === entityId));
+	if (link === void 0) return void 0;
+	return String(link.endpoint0EntityId === entityId ? link.endpoint1EntityId : link.endpoint0EntityId);
+}
+/**
+* Attach the timbre a synthesized voiceover was rendered with. One Voice
+* identity is shared by every take naming the same library entry, so an
+* existing row is reused rather than duplicated. Recorded media declares no
+* timbre and keeps no link.
+*/
+function bindVoiceTimbre(entities, relations, audioEntityId, descriptor, idFactory) {
+	const linked = relations.filter((relation) => relation.relationKind === "voice-timbre" && (relation.endpoint0EntityId === audioEntityId || relation.endpoint1EntityId === audioEntityId));
+	if (linked.length > 1) throw new Error(`Voiceover ${audioEntityId} has multiple Voice timbre relations`);
+	if (descriptor === void 0) {
+		if (linked.length > 0) throw new Error(`Recorded media ${audioEntityId} cannot keep a synthesized Voice timbre`);
+		return {};
+	}
+	const voice = entities.find((row) => row.entityKind === "voice" && sameVoiceDescriptor(assembleEntityContent({
+		entities,
+		relations
+	}, row.entityId, "voice").payload.voice, descriptor)) ?? appendVoiceIdentity(entities, descriptor, idFactory);
+	const existing = linked[0];
+	if (existing === void 0) relations.push({
+		relationId: createRelationId(idFactory("relation")),
+		relationKind: "voice-timbre",
+		endpoint0EntityId: createEntityId(audioEntityId),
+		endpoint1EntityId: createEntityId(voice.entityId)
+	});
+	else if (existing.endpoint0EntityId !== audioEntityId || existing.endpoint1EntityId !== voice.entityId) throw new Error(`Voiceover ${audioEntityId} already carries a different Voice timbre`);
+	return { voiceEntityId: voice.entityId };
+}
+function appendVoiceIdentity(entities, descriptor, idFactory) {
+	const voice = {
+		entityId: createEntityId(idFactory("entity")),
+		entityKind: "voice",
+		payload: { voice: {
+			system: descriptor.system,
+			key: descriptor.key,
+			...descriptor.name === void 0 ? {} : { name: descriptor.name }
+		} }
+	};
+	entities.push(voice);
+	return voice;
+}
+/** Two takes share a Voice identity only when they name the same library entry. */
+function sameVoiceDescriptor(stored, descriptor) {
+	return stored.system === descriptor.system && stored.key === descriptor.key && stored.name === descriptor.name;
+}
+function replaceEntity$1(entities, entityId, replacement) {
+	const index = entities.findIndex((row) => row.entityId === entityId);
+	if (index < 0) throw new Error(`Entity id ${entityId} does not exist`);
+	entities[index] = replacement;
+}
+/** The length a media fact states: whole milliseconds, or `null` for infinite. */
+function statedDuration(fact) {
+	if (fact.durationMs === null) return null;
+	if (!(Number.isFinite(fact.durationMs) && fact.durationMs > 0)) throw new Error(`${fact.kind} ${fact.assetId} requires its factual positive duration`);
+	return fact.durationMs;
+}
+//#endregion
+//#region src/entity-editor/entity-timeline-editor.ts
+/**
+* Resolve the AudioScript a PhoneticScript composes: the base that supplies its
+* segments. The composition is the required text source, so a variant that
+* reads no segments has no content and fails here.
+*/
+function requireComposedAudioScript(rows, phoneticScriptEntityId) {
+	segmentsOf(assembleEntityContent(rows, phoneticScriptEntityId));
+	const owner = baseFieldOwner(rows, phoneticScriptEntityId, "segments");
+	if (owner === void 0) throw new Error(`PhoneticScript "${phoneticScriptEntityId}" composes no AudioScript`);
+	return owner;
+}
+/** Placing a medium whole runs it to its end, which an infinite medium does not have. */
+function wholeLength(media) {
+	if (media.durationMs === null) throw new Error(`${media.kind} ${media.assetId} is infinite and cannot be placed whole`);
+	return media.durationMs;
+}
+function captionBaseIds(ids) {
+	if (!Array.isArray(ids) || ids.length === 0) throw new Error("Caption requires non-empty bases");
+	return ids.map(createEntityId);
+}
+function assertCaptionScript(rows, captionId, scriptId) {
+	if (baseFieldOwner(rows, captionId, "segments") !== scriptId) throw new Error("Voiceover Caption must compose the same AudioScript as the PhoneticScript");
+}
+const defaultIdFactory = (prefix) => `${prefix}_${globalThis.crypto.randomUUID()}`;
+/**
+* Graph-native timeline authoring over authoritative Medeo Entity and Relation rows.
+*
+* Each mutation is applied to a detached graph, validated as a complete DSL set,
+* and committed only after validation succeeds.
+*/
+var EntityTimelineEditor = class {
+	idFactory;
+	state;
+	constructor(initialRows, idFactory = defaultIdFactory) {
+		this.idFactory = idFactory;
+		this.state = cloneRows(initialRows);
+	}
+	rows() {
+		return cloneRows(this.state);
+	}
+	insertClip(input) {
+		const requestedOrder = input.order;
+		const order = typeof requestedOrder === "number" ? requestedOrder : nextSequentialOrder(this.state, createEntityId(input.trackEntityId));
+		return this.insertPlacedClip({
+			trackEntityId: input.trackEntityId,
+			contentEntityId: input.contentEntityId,
+			inMs: input.inMs,
+			outMs: input.outMs,
+			placement: input.startMs === void 0 ? {
+				kind: "sequential",
+				order
+			} : {
+				kind: "absolute",
+				startMs: input.startMs
+			},
+			clipPayload: input.clipPayload
+		});
+	}
+	insertPlacedClip(input) {
+		return this.transact((draft) => this.insertPlacedClipIntoDraft(draft, input));
+	}
+	updateClipMarker(input) {
+		this.transact((draft) => {
+			const { marker } = requireClipTopology(draft, input.clipEntityId);
+			const payload = structuredClone(marker.payload);
+			if (input.inMs !== void 0) payload.inMs = finiteNonNegative(input.inMs, "inMs");
+			if (input.outMs !== void 0) payload.outMs = finitePositive(input.outMs, "outMs");
+			if (Object.hasOwn(input, "startMs")) if (input.startMs === void 0) {
+				delete payload.startMs;
+				if (!hasOutgoingClipAnchor(draft, input.clipEntityId)) {}
+			} else payload.startMs = finiteNonNegative(input.startMs, "startMs");
+			if (Object.hasOwn(input, "rate")) if (input.rate === void 0) delete payload.rate;
+			else payload.rate = finitePositive(input.rate, "linear speed rate");
+			replaceEntity(draft, marker.entityId, {
+				...marker,
+				payload
+			});
+		});
+	}
+	setClipPlacement(input) {
+		this.transact((draft) => this.applyClipPlacement(draft, input.clipEntityId, input.placement));
+	}
+	moveSequentialClips(input) {
+		if (input.clipEntityIds.length === 0) throw new Error("At least one Clip is required");
+		this.transact((draft) => {
+			const original = resolveEntityTimelineLayout(draft);
+			this.normalizeMainSequential(draft);
+			const before = resolveEntityTimelineLayout(draft);
+			const targetIds = new Set(input.clipEntityIds);
+			if (targetIds.size !== input.clipEntityIds.length) throw new Error("Clip ids must be unique");
+			const placements = input.clipEntityIds.map((id) => before.clips.get(id));
+			if (placements.some((placement) => placement === void 0 || placement.mode !== "sequential")) throw new Error("moveSequentialClips accepts only sequential Clips");
+			const trackIds = new Set(placements.map((placement) => placement.trackEntityId));
+			if (trackIds.size !== 1) throw new Error("Moved Clips must belong to one Track");
+			const trackId = [...trackIds][0];
+			const track = before.tracks.find((candidate) => candidate.entityId === trackId);
+			if (track?.role !== "video_clip") throw new Error("Only the video_clip Track supports sequential block moves");
+			const ordered = track.clips.filter((placement) => placement.mode === "sequential").map((placement) => placement.clipEntityId);
+			if (input.anchor.position !== "trackStart" && targetIds.has(input.anchor.clipEntityId)) throw new Error("Move anchor cannot be one of the moved Clips");
+			const moved = ordered.filter((id) => targetIds.has(id));
+			if (moved.length !== targetIds.size) throw new Error("Every moved Clip must exist on the target Track");
+			const remaining = ordered.filter((id) => !targetIds.has(id));
+			let insertAt = 0;
+			if (input.anchor.position !== "trackStart") {
+				const anchorIndex = remaining.indexOf(input.anchor.clipEntityId);
+				if (anchorIndex < 0) throw new Error("Move anchor Clip does not exist on the target Track");
+				insertAt = anchorIndex + (input.anchor.position === "after" ? 1 : 0);
+			}
+			[
+				...remaining.slice(0, insertAt),
+				...moved,
+				...remaining.slice(insertAt)
+			].forEach((clipId, order) => setClipOrder(draft, clipId, order));
+			if (input.onAnchored === "keepAbsolute") {
+				const affected = outgoingAnchorChildren(draft, new Set(track.clips.map((clip) => clip.clipEntityId))).filter((childId) => clipRole(draft, childId) === "speech").map((childId) => {
+					const placement = original.clips.get(childId);
+					if (placement === void 0) throw new Error(`Anchored child Clip "${childId}" is not placed`);
+					return {
+						childId,
+						start: placement.start
+					};
+				});
+				const after = resolveEntityTimelineLayout(draft);
+				for (const child of affected) this.reanchorAtAbsolute(draft, child.childId, child.start, after);
+			}
+			this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	moveClipsToStarts(input) {
+		if (input.moves.length === 0) throw new Error("At least one Clip move is required");
+		this.transact((draft) => {
+			const original = resolveEntityTimelineLayout(draft);
+			const originalVideo = original.tracks.find((track) => track.role === "video_clip");
+			if (originalVideo === void 0) throw new Error("The timeline has no video_clip Track");
+			const preservedVoiceovers = outgoingAnchorChildren(draft, new Set(originalVideo.clips.map((clip) => clip.clipEntityId))).filter((clipId) => clipRole(draft, clipId) === "speech").map((clipId) => ({
+				clipId,
+				start: original.clips.get(clipId).start
+			}));
+			this.normalizeMainSequential(draft);
+			for (const move of input.moves) {
+				finiteNonNegative(move.newStartMs, "newStartMs");
+				requireClipOnRole(draft, move.clipEntityId, "video_clip");
+				const track = resolveEntityTimelineLayout(draft).tracks.find((candidate) => candidate.role === "video_clip");
+				const ordered = track.clips.map((clip) => clip.clipEntityId);
+				const from = ordered.indexOf(move.clipEntityId);
+				if (from < 0) throw new Error(`Clip "${move.clipEntityId}" is not on the video_clip Track`);
+				const remaining = track.clips.filter((clip) => clip.clipEntityId !== move.clipEntityId);
+				let cursor = 0;
+				let target = remaining.length;
+				for (const [index, clip] of remaining.entries()) {
+					if (move.newStartMs <= cursor + clip.duration / 2) {
+						target = index;
+						break;
+					}
+					cursor += clip.duration;
+				}
+				const next = [...ordered];
+				next.splice(from, 1);
+				next.splice(target, 0, move.clipEntityId);
+				next.forEach((clipId, order) => setClipOrder(draft, clipId, order));
+			}
+			const after = resolveEntityTimelineLayout(draft);
+			for (const voiceover of preservedVoiceovers) this.reanchorAtAbsolute(draft, voiceover.clipId, voiceover.start, after);
+			this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	moveClip(input) {
+		this.transact((draft) => {
+			const topology = requireClipTopology(draft, input.clipEntityId);
+			const track = requireEntityKind(draft, input.trackEntityId, "track");
+			requireTrackTimeline(draft, track.entityId);
+			this.relinkRelation(draft, topology.trackRelation, {
+				endpoint0EntityId: track.entityId,
+				endpoint1EntityId: topology.clip.entityId
+			});
+		});
+	}
+	replaceClipContent(input) {
+		this.transact((draft) => {
+			const topology = requireClipTopology(draft, input.clipEntityId);
+			const content = requireSequenceContent(draft, input.contentEntityId);
+			const payload = {
+				...structuredClone(topology.marker.payload),
+				...requireWindow(input.inMs, input.outMs)
+			};
+			delete payload.startMs;
+			delete payload.rate;
+			if (input.startMs !== void 0) payload.startMs = finiteNonNegative(input.startMs, "startMs");
+			if (input.rate !== void 0) payload.rate = finitePositive(input.rate, "linear speed rate");
+			replaceEntity(draft, topology.marker.entityId, {
+				...topology.marker,
+				payload
+			});
+			this.relinkRelation(draft, topology.contentRelation, {
+				endpoint0EntityId: topology.clip.entityId,
+				endpoint1EntityId: content.entityId
+			});
+		});
+	}
+	insertMediaClip(input) {
+		return this.transact((draft) => {
+			if (input.placement.kind === "sequential") this.normalizeMainSequential(draft);
+			const imported = importMediaAsset(draft, input.media, this.idFactory);
+			replaceRows(draft, imported.rows);
+			const track = this.ensureRoleTrack(draft, input.timelineEntityId, "video_clip");
+			const window = requireWindow(input.inMs, input.outMs);
+			const clipId = this.insertPlacedClipIntoDraft(draft, {
+				trackEntityId: track.entityId,
+				contentEntityId: imported.contentEntityId,
+				...window,
+				placement: input.placement,
+				...input.clipEntityId === void 0 ? {} : { clipEntityId: input.clipEntityId },
+				...input.volume === void 0 ? {} : { clipPayload: { volume: requireVolume(input.volume) } }
+			});
+			if (input.placement.kind === "sequential") this.resolveOneVoiceoverOverlap(draft);
+			return clipId;
+		});
+	}
+	insertMediaClips(input) {
+		if (input.clips.length === 0) throw new Error("At least one media Clip is required");
+		return this.transact((draft) => {
+			this.normalizeMainSequential(draft);
+			const track = this.ensureRoleTrack(draft, input.timelineEntityId, "video_clip");
+			const ordered = resolveEntityTimelineLayout(draft).tracks.find((candidate) => candidate.entityId === track.entityId)?.clips ?? [];
+			let insertAt = ordered.length;
+			const insertion = input.insertion;
+			if (insertion.kind === "before" || insertion.kind === "after") {
+				const anchorIndex = ordered.findIndex((clip) => clip.clipEntityId === insertion.clipEntityId);
+				if (anchorIndex >= 0) insertAt = anchorIndex + (insertion.kind === "after" ? 1 : 0);
+			} else {
+				const startMs = finiteNonNegative(insertion.startMs, "firstStart.startMs");
+				let cursor = 0;
+				for (const [index, clip] of ordered.entries()) {
+					if (startMs <= cursor + clip.duration / 2) {
+						insertAt = index;
+						break;
+					}
+					cursor += clip.duration;
+				}
+			}
+			const created = [];
+			for (const [offset, clip] of input.clips.entries()) {
+				const imported = importMediaAsset(draft, clip.media, this.idFactory);
+				replaceRows(draft, imported.rows);
+				const window = requireWindow(clip.inMs, clip.outMs);
+				created.push(this.insertPlacedClipIntoDraft(draft, {
+					trackEntityId: track.entityId,
+					contentEntityId: imported.contentEntityId,
+					...window,
+					placement: {
+						kind: "sequential",
+						order: ordered.length + offset
+					},
+					...clip.clipEntityId === void 0 ? {} : { clipEntityId: clip.clipEntityId },
+					...clip.volume === void 0 ? {} : { clipPayload: { volume: requireVolume(clip.volume) } }
+				}));
+			}
+			const desired = ordered.map((clip) => clip.clipEntityId);
+			desired.splice(insertAt, 0, ...created);
+			desired.forEach((clipId, order) => setClipOrder(draft, clipId, order));
+			this.resolveOneVoiceoverOverlap(draft);
+			return created;
+		});
+	}
+	replaceMediaClip(input) {
+		this.transact((draft) => {
+			this.normalizeMainSequential(draft);
+			const topology = requireClipOnRole(draft, input.clipEntityId, "video_clip");
+			const imported = importMediaAsset(draft, input.media, this.idFactory);
+			replaceRows(draft, imported.rows);
+			const window = requireWindow(input.inMs, input.outMs);
+			const markerPayloadValue = {
+				...structuredClone(topology.marker.payload),
+				...window
+			};
+			delete markerPayloadValue.rate;
+			replaceEntity(draft, topology.marker.entityId, {
+				...topology.marker,
+				payload: markerPayloadValue
+			});
+			this.relinkRelation(draft, topology.contentRelation, {
+				endpoint0EntityId: topology.clip.entityId,
+				endpoint1EntityId: createEntityId(imported.contentEntityId)
+			});
+			this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	setClipVolume(input) {
+		this.transact((draft) => {
+			const topology = requireClipTopology(draft, input.clipEntityId);
+			requireSupportedRole(draft, topology);
+			replaceEntity(draft, topology.clip.entityId, {
+				...topology.clip,
+				payload: {
+					...topology.clip.payload,
+					volume: requireVolume(input.volume)
+				}
+			});
+		});
+	}
+	setClipSpeed(input) {
+		this.transact((draft) => {
+			const initialTopology = requireClipOnRole(draft, input.clipEntityId, "video_clip");
+			const content = requireSequenceContent(draft, otherEndpoint(initialTopology.contentRelation, initialTopology.clip.entityId));
+			if (content.entityKind !== "video" && content.entityKind !== "image") throw new Error("Clip speed is supported only for Video or Image content");
+			const initialPayload = fieldsOf(draft, initialTopology.marker.entityId, "sequence-marker");
+			const priorWindow = markerWindow(initialPayload);
+			if (input.rate === null && initialPayload.rate === void 0) return;
+			this.normalizeMainSequential(draft);
+			const topology = requireClipTopology(draft, input.clipEntityId);
+			const payload = { ...structuredClone(topology.marker.payload) };
+			const window = content.entityKind === "image" && initialPayload.rate === void 0 && input.rate !== null ? {
+				inMs: 0,
+				outMs: markerDuration(initialPayload, priorWindow)
+			} : priorWindow;
+			Object.assign(payload, window);
+			if (input.rate === null) delete payload.rate;
+			else {
+				const rate = finitePositive(input.rate, "linear speed rate");
+				const duration = Math.round((window.outMs - window.inMs) / rate);
+				if (duration <= 0 || !Number.isSafeInteger(duration)) throw new Error("Linear speed produces an invalid duration");
+				payload.rate = rate;
+			}
+			replaceEntity(draft, topology.marker.entityId, {
+				...topology.marker,
+				payload
+			});
+			this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	trimClip(input) {
+		this.transact((draft) => {
+			this.normalizeMainSequential(draft);
+			const topology = requireClipOnRole(draft, input.clipEntityId, "video_clip");
+			const content = requireSequenceContent(draft, otherEndpoint(topology.contentRelation, topology.clip.entityId));
+			if (content.entityKind !== "video" && content.entityKind !== "image") throw new Error("Clip trimming is supported only for Video or Image content");
+			const window = requireWindow(input.inMs, input.outMs);
+			const payload = {
+				...structuredClone(topology.marker.payload),
+				...window
+			};
+			const duration = markerDuration({
+				...fieldsOf(draft, topology.marker.entityId, "sequence-marker"),
+				...window
+			});
+			if (duration <= 0 || !Number.isSafeInteger(duration)) throw new Error("Trim produces an invalid duration");
+			replaceEntity(draft, topology.marker.entityId, {
+				...topology.marker,
+				payload
+			});
+			this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	replaceSequentialClips(input) {
+		if (input.oldClipEntityIds.length === 0 || input.newClips.length === 0) throw new Error("Replacement requires at least one old and one new Clip");
+		return this.transact((draft) => {
+			this.normalizeMainSequential(draft);
+			const before = resolveEntityTimelineLayout(draft);
+			const oldIds = new Set(input.oldClipEntityIds);
+			if (oldIds.size !== input.oldClipEntityIds.length) throw new Error("Old Clip ids must be unique");
+			const track = this.ensureRoleTrack(draft, input.timelineEntityId, "video_clip");
+			const ordered = before.tracks.find((candidate) => candidate.entityId === track.entityId)?.clips.filter((clip) => clip.mode === "sequential").map((clip) => clip.clipEntityId);
+			if (ordered === void 0) throw new Error("The video_clip Track is not present in the current layout");
+			const indexes = input.oldClipEntityIds.map((id) => ordered.indexOf(id));
+			if (indexes.some((index) => index < 0)) throw new Error("Every replaced Clip must be sequential on video_clip");
+			const sortedIndexes = [...indexes].sort((left, right) => left - right);
+			if (sortedIndexes.some((index, offset) => index !== sortedIndexes[0] + offset)) throw new Error("Replaced Clips must form one contiguous timeline run");
+			if (input.oldClipEntityIds.some((id, index) => id !== ordered[sortedIndexes[0] + index])) throw new Error("Replaced Clip ids must be listed in timeline order");
+			const insertOrder = sortedIndexes[0];
+			const temporaryOrder = ordered.length;
+			const created = [];
+			for (const [offset, replacement] of input.newClips.entries()) {
+				if (replacement.clipEntityId !== void 0 && oldIds.has(replacement.clipEntityId)) throw new Error("A replacement Clip id cannot reuse an Entity being removed");
+				const imported = importMediaAsset(draft, replacement.media, this.idFactory);
+				replaceRows(draft, imported.rows);
+				const window = requireWindow(replacement.inMs, replacement.outMs);
+				created.push(this.insertPlacedClipIntoDraft(draft, {
+					trackEntityId: track.entityId,
+					contentEntityId: imported.contentEntityId,
+					...window,
+					placement: {
+						kind: "sequential",
+						order: temporaryOrder + offset
+					},
+					...replacement.clipEntityId === void 0 ? {} : { clipEntityId: replacement.clipEntityId },
+					...replacement.volume === void 0 ? {} : { clipPayload: { volume: requireVolume(replacement.volume) } }
+				}));
+			}
+			for (const [index, oldId] of input.oldClipEntityIds.entries()) {
+				const children = directAnchorChildren(draft, oldId);
+				if (input.onAnchored === "remap" && created[index] !== void 0) for (const childId of children) this.replaceAnchorHost(draft, childId, created[index]);
+				else {
+					const scheduled = /* @__PURE__ */ new Set();
+					for (const childId of children) {
+						scheduled.add(childId);
+						this.removeAnchoredDescendants(draft, childId, scheduled);
+						this.removeClipGraph(draft, childId);
+					}
+				}
+			}
+			for (const oldId of input.oldClipEntityIds) this.removeClipGraph(draft, oldId);
+			[
+				...ordered.slice(0, insertOrder),
+				...created,
+				...ordered.slice(insertOrder + input.oldClipEntityIds.length)
+			].forEach((clipId, order) => setClipOrder(draft, clipId, order));
+			this.resolveOneVoiceoverOverlap(draft);
+			return created;
+		});
+	}
+	deleteClip(input) {
+		this.transact((draft) => {
+			const topology = requireClipTopology(draft, input.clipEntityId);
+			assertOnlyStructuralIncidents(draft, topology.clip.entityId, new Set(["contain", "marker"]));
+			assertOnlyStructuralIncidents(draft, topology.marker.entityId, new Set(["marker"]));
+			const markerIsExclusive = incidentRelations(draft, topology.marker.entityId).filter((relation) => relation.relationKind === "marker").length === 1;
+			const removedRelationIds = new Set([
+				topology.trackRelation.relationId,
+				topology.clipMarkerRelation.relationId,
+				topology.contentRelation.relationId
+			]);
+			if (markerIsExclusive) for (const relation of incidentRelations(draft, topology.marker.entityId)) removedRelationIds.add(relation.relationId);
+			draft.relations = draft.relations.filter((relation) => !removedRelationIds.has(relation.relationId));
+			draft.entities = draft.entities.filter((entity) => entity.entityId !== topology.clip.entityId && (!markerIsExclusive || entity.entityId !== topology.marker.entityId));
+		});
+	}
+	deleteClipTree(input) {
+		if (input.clipEntityIds.length === 0) throw new Error("At least one Clip is required");
+		this.transact((draft) => {
+			const targets = new Set(input.clipEntityIds);
+			if (targets.size !== input.clipEntityIds.length) throw new Error("Clip ids must be unique");
+			for (const target of targets) requireEntityKind(draft, target, "clip");
+			const includesVisual = [...targets].some((target) => clipRole(draft, target) === "video_clip");
+			const original = resolveEntityTimelineLayout(draft);
+			if (includesVisual) this.normalizeMainSequential(draft);
+			if (input.onAnchored === "detach") for (const childId of outgoingAnchorChildren(draft, targets)) {
+				if (targets.has(childId)) continue;
+				const placement = original.clips.get(childId);
+				if (placement === void 0) throw new Error(`Anchored child Clip "${childId}" is not placed`);
+				this.applyClipPlacement(draft, childId, {
+					kind: "absolute",
+					startMs: placement.start
+				});
+			}
+			else for (const target of targets) this.removeAnchoredDescendants(draft, target, targets);
+			for (const target of targets) this.removeClipGraph(draft, target);
+			if (includesVisual) this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	updateClip(input) {
+		this.transact((draft) => {
+			const clip = requireEntityKind(draft, input.clipEntityId, "clip");
+			replaceEntity(draft, clip.entityId, {
+				...clip,
+				payload: structuredClone(input.payload)
+			});
+		});
+	}
+	upsertVoiceoverTake(input) {
+		return this.transact((draft) => {
+			this.normalizeMainSequential(draft);
+			const placement = input.placement ?? {
+				kind: "anchored",
+				hostClipEntityId: input.hostClipEntityId,
+				startMs: input.startMs
+			};
+			if (input.placement !== void 0 && (input.hostClipEntityId !== void 0 || input.startMs !== void 0)) throw new Error("Specify voiceover placement or hostClipEntityId/startMs, not both");
+			requireVolume(input.volume);
+			const imported = importMediaAsset(draft, input.media, this.idFactory);
+			replaceRows(draft, imported.rows);
+			const voiceover = requireEntityKind(draft, imported.contentEntityId, "voiceover-recording");
+			const phonetic = this.requireComposedPhoneticScript(draft, input.phoneticScriptEntityId);
+			this.ensurePhoneticRender(draft, voiceover.entityId, phonetic.entityId);
+			const speechTrack = this.ensureRoleTrack(draft, input.timelineEntityId, "speech");
+			const existing = draft.entities.find((row) => row.entityId === input.voiceoverClipEntityId);
+			let voiceoverClipEntityId;
+			if (existing === void 0) voiceoverClipEntityId = this.insertPlacedClipIntoDraft(draft, {
+				clipEntityId: input.voiceoverClipEntityId,
+				trackEntityId: speechTrack.entityId,
+				contentEntityId: voiceover.entityId,
+				inMs: 0,
+				outMs: wholeLength(input.media),
+				placement,
+				clipPayload: { volume: input.volume }
+			});
+			else {
+				const topology = requireClipOnRole(draft, input.voiceoverClipEntityId, "speech");
+				voiceoverClipEntityId = topology.clip.entityId;
+				replaceEntity(draft, topology.clip.entityId, {
+					...topology.clip,
+					payload: {
+						...topology.clip.payload,
+						volume: input.volume
+					}
+				});
+				this.relinkRelation(draft, topology.contentRelation, {
+					endpoint0EntityId: topology.clip.entityId,
+					endpoint1EntityId: voiceover.entityId
+				});
+				this.applyClipPlacement(draft, topology.clip.entityId, placement);
+				const placed = requireClipTopology(draft, topology.clip.entityId);
+				replaceEntity(draft, placed.marker.entityId, {
+					...placed.marker,
+					payload: {
+						...placed.marker.payload,
+						inMs: 0,
+						outMs: wholeLength(input.media)
+					}
+				});
+			}
+			this.reconcileVoiceoverCaptions(draft, voiceoverClipEntityId, voiceover.entityId, phonetic.entityId, input.captions);
+			this.resolveOneVoiceoverOverlap(draft);
+			return {
+				voiceoverClipEntityId,
+				voiceoverAudioEntityId: voiceover.entityId,
+				...imported.voiceEntityId === void 0 ? {} : { voiceEntityId: imported.voiceEntityId },
+				phoneticScriptEntityId: phonetic.entityId,
+				audioScriptEntityId: requireComposedAudioScript(draft, phonetic.entityId),
+				captionClipEntityIds: input.captions.map((caption) => caption.captionClipEntityId)
+			};
+		});
+	}
+	moveVoiceover(input) {
+		this.transact((draft) => {
+			requireClipOnRole(draft, input.voiceoverClipEntityId, "speech");
+			this.normalizeMainSequential(draft);
+			const layout = resolveEntityTimelineLayout(draft);
+			this.reanchorAtAbsolute(draft, input.voiceoverClipEntityId, finiteNonNegative(input.newStartMs, "newStartMs"), layout);
+			this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	deleteVoiceover(input) {
+		this.transact((draft) => {
+			this.normalizeMainSequential(draft);
+			const targets = new Set(input.voiceoverClipEntityIds);
+			if (targets.size !== input.voiceoverClipEntityIds.length) throw new Error("Voiceover Clip ids must be unique");
+			for (const clipId of targets) {
+				requireClipOnRole(draft, clipId, "speech");
+				this.removeAnchoredDescendants(draft, clipId, targets);
+			}
+			for (const clipId of targets) this.removeClipGraph(draft, clipId);
+			this.resolveOneVoiceoverOverlap(draft);
+		});
+	}
+	setBgm(input) {
+		return this.transact((draft) => {
+			const imported = importMediaAsset(draft, input.media, this.idFactory);
+			replaceRows(draft, imported.rows);
+			const track = this.ensureRoleTrack(draft, input.timelineEntityId, "bgm");
+			const existing = clipsOnTrack(draft, track.entityId);
+			for (const clip of existing) this.removeClipGraph(draft, clip.entityId);
+			const clipId = this.insertPlacedClipIntoDraft(draft, {
+				clipEntityId: input.bgmClipEntityId,
+				trackEntityId: track.entityId,
+				contentEntityId: imported.contentEntityId,
+				inMs: 0,
+				outMs: wholeLength(input.media),
+				placement: {
+					kind: "sequential",
+					order: 0
+				},
+				clipPayload: { volume: requireVolume(input.volume) }
+			});
+			const topology = requireClipTopology(draft, clipId);
+			replaceEntity(draft, topology.marker.entityId, {
+				...topology.marker,
+				payload: {
+					...topology.marker.payload,
+					fillTimeline: true
+				}
+			});
+			return clipId;
+		});
+	}
+	deleteBgm(input) {
+		this.transact((draft) => {
+			const track = findRoleTrack(draft, input.timelineEntityId, "bgm");
+			if (track === void 0) return;
+			for (const clip of clipsOnTrack(draft, track.entityId)) this.removeClipGraph(draft, clip.entityId);
+		});
+	}
+	setCaptionVisibility(input) {
+		this.transact((draft) => {
+			const track = this.ensureRoleTrack(draft, input.timelineEntityId, "caption");
+			replaceEntity(draft, track.entityId, {
+				...track,
+				payload: {
+					...track.payload,
+					hidden: input.hidden
+				}
+			});
+		});
+	}
+	patchCaptionStyle(input) {
+		this.transact((draft) => {
+			const track = findRoleTrack(draft, input.timelineEntityId, "caption");
+			if (track === void 0) return;
+			const patch = structuredClone(input.style);
+			const assembled = new EntityProjectionGraph(draft);
+			for (const clip of clipsOnTrack(draft, track.entityId)) {
+				const topology = requireClipTopology(draft, clip.entityId);
+				const caption = requireEntityKind(draft, otherEndpoint(topology.contentRelation, topology.clip.entityId), "caption");
+				const style = assembled.entity(caption.entityId, "caption").payload.style ?? {};
+				for (const updated of updateEntityFields(draft, caption.entityId, { style: {
+					...style,
+					...patch
+				} })) replaceEntity(draft, updated.entityId, updated);
+			}
+		});
+	}
+	/**
+	* Place a Caption as a composed variant of an existing AudioScript: the
+	* entity stores bases, selection, optional style, and inherent cue-bounded
+	* Sequence. This helper does not copy base text. The Clip and its display Marker describe this use;
+	* moving or stretching the returned Clip later changes the Clip/Marker,
+	* never the Caption entity or the AudioScript.
+	*/
+	insertCaptionClip(input) {
+		return this.transact((draft) => {
+			const durationMs = finitePositive(input.durationMs, "Caption durationMs");
+			const selection = captionSelection(input.selection);
+			const track = this.ensureRoleTrack(draft, input.timelineEntityId, "caption");
+			const content = {
+				entityId: input.captionEntityId === void 0 ? this.mintEntityId(draft) : requireAvailableEntityId(draft, input.captionEntityId),
+				entityKind: "caption",
+				payload: {
+					durationMs,
+					bases: captionBaseIds(input.bases),
+					selection,
+					...input.style === void 0 ? {} : { style: structuredClone(input.style) }
+				}
+			};
+			draft.entities.push(content);
+			selectedSegment(assembleEntityContent(draft, content.entityId));
+			return this.insertPlacedClipIntoDraft(draft, {
+				trackEntityId: track.entityId,
+				contentEntityId: content.entityId,
+				inMs: 0,
+				outMs: durationMs,
+				placement: input.placement,
+				...input.captionClipEntityId === void 0 ? {} : { clipEntityId: input.captionClipEntityId }
+			});
+		});
+	}
+	insertPlacedClipIntoDraft(draft, input) {
+		const track = requireEntityKind(draft, input.trackEntityId, "track");
+		requireTrackTimeline(draft, track.entityId);
+		const content = requireSequenceContent(draft, input.contentEntityId);
+		const clipId = input.clipEntityId === void 0 ? this.mintEntityId(draft) : requireAvailableEntityId(draft, input.clipEntityId);
+		const markerId = this.mintEntityId(draft);
+		const clipPayload = structuredClone(input.clipPayload ?? {});
+		const markerPlacement = applyPlacementPayload(input.placement);
+		const clip = {
+			entityId: clipId,
+			entityKind: "clip",
+			payload: clipPayload
+		};
+		const marker = {
+			entityId: markerId,
+			entityKind: "sequence-marker",
+			payload: {
+				...requireWindow(input.inMs, input.outMs),
+				...markerPlacement
+			}
+		};
+		draft.entities.push(clip, marker);
+		draft.relations.push(this.createRelation(draft, "contain", track.entityId, clipId), this.createRelation(draft, "marker", clipId, markerId), this.createRelation(draft, "contain", clipId, content.entityId));
+		if (input.placement.kind === "anchored") {
+			const host = requireEntityKind(draft, input.placement.hostClipEntityId, "clip");
+			if (host.entityId === clipId) throw new Error("A Clip cannot anchor to itself");
+			draft.relations.push(this.createRelation(draft, "clip-anchor", clipId, host.entityId));
+		}
+		return clipId;
+	}
+	ensureRoleTrack(draft, timelineEntityId, role) {
+		const existing = findRoleTrack(draft, timelineEntityId, role);
+		if (existing !== void 0) return existing;
+		const timeline = requireEntityKind(draft, timelineEntityId, "timeline");
+		const track = {
+			entityId: this.mintEntityId(draft),
+			entityKind: "track",
+			payload: { role }
+		};
+		draft.entities.push(track);
+		draft.relations.push(this.createRelation(draft, "contain", timeline.entityId, track.entityId));
+		return track;
+	}
+	/** The existing pronunciation variant a voiceover consumes; composition is required. */
+	requireComposedPhoneticScript(draft, phoneticScriptEntityId) {
+		const phonetic = requireEntityKind(draft, phoneticScriptEntityId, "phonetic-script");
+		requireComposedAudioScript(draft, phonetic.entityId);
+		return phonetic;
+	}
+	/** Preserve the factual synthesis input, regardless of persisted endpoint positions. */
+	ensurePhoneticRender(draft, voiceoverAudioEntityId, phoneticScriptEntityId) {
+		const renders = draft.relations.filter((relation) => relation.relationKind === "derived-from" && (relation.endpoint0EntityId === voiceoverAudioEntityId || relation.endpoint1EntityId === voiceoverAudioEntityId));
+		if (renders.length > 1) throw new Error(`Voiceover "${voiceoverAudioEntityId}" has multiple PhoneticScript render relations`);
+		if (renders[0] !== void 0) {
+			if (otherEndpoint(renders[0], voiceoverAudioEntityId) === phoneticScriptEntityId) return;
+			throw new Error(`Voiceover "${voiceoverAudioEntityId}" already has a different PhoneticScript synthesis input`);
+		}
+		draft.relations.push(this.createRelation(draft, "derived-from", voiceoverAudioEntityId, phoneticScriptEntityId));
+	}
+	reconcileVoiceoverCaptions(draft, voiceoverClipEntityId, voiceoverAudioEntityId, phoneticScriptEntityId, captions) {
+		const audioScriptEntityId = requireComposedAudioScript(draft, phoneticScriptEntityId);
+		const requested = new Set(captions.map((caption) => caption.captionClipEntityId));
+		if (requested.size !== captions.length) throw new Error("Caption Clip ids must be unique within a voiceover take");
+		const existing = directAnchorChildren(draft, voiceoverClipEntityId).filter((clipId) => clipRole(draft, clipId) === "caption");
+		for (const clipId of existing) if (!requested.has(clipId)) this.removeCaptionClipGraph(draft, clipId);
+		const captionTrack = captions.length === 0 ? void 0 : this.ensureRoleTrackForClip(draft, voiceoverClipEntityId, "caption");
+		for (const caption of captions) {
+			const startMs = finiteNonNegative(caption.startMs, "Caption startMs");
+			const durationMs = finitePositive(caption.durationMs, "Caption durationMs");
+			const selection = captionSelection(caption.selection);
+			const bases = captionBaseIds(caption.bases);
+			if (draft.entities.find((entity) => entity.entityId === caption.captionClipEntityId) === void 0) {
+				const content = {
+					entityId: this.mintEntityId(draft),
+					entityKind: "caption",
+					payload: {
+						durationMs,
+						bases,
+						selection,
+						...caption.style === void 0 ? {} : { style: structuredClone(caption.style) }
+					}
+				};
+				draft.entities.push(content);
+				assertCaptionScript(draft, content.entityId, audioScriptEntityId);
+				draft.relations.push(this.createRelation(draft, "caption-alignment", content.entityId, voiceoverAudioEntityId));
+				this.insertPlacedClipIntoDraft(draft, {
+					clipEntityId: caption.captionClipEntityId,
+					trackEntityId: captionTrack.entityId,
+					contentEntityId: content.entityId,
+					inMs: 0,
+					outMs: durationMs,
+					placement: {
+						kind: "anchored",
+						hostClipEntityId: voiceoverClipEntityId,
+						startMs
+					}
+				});
+				continue;
+			}
+			const topology = requireClipOnRole(draft, caption.captionClipEntityId, "caption");
+			const content = requireEntityKind(draft, otherEndpoint(topology.contentRelation, topology.clip.entityId), "caption");
+			const priorStyle = fieldsOf(draft, content.entityId, "caption").style ?? {};
+			const style = caption.style === void 0 ? priorStyle : {
+				...priorStyle,
+				...structuredClone(caption.style)
+			};
+			replaceEntity(draft, content.entityId, {
+				...content,
+				payload: {
+					...content.payload,
+					bases,
+					selection,
+					...Object.keys(style).length === 0 ? {} : { style }
+				}
+			});
+			assertCaptionScript(draft, content.entityId, audioScriptEntityId);
+			this.applyClipPlacement(draft, topology.clip.entityId, {
+				kind: "anchored",
+				hostClipEntityId: voiceoverClipEntityId,
+				startMs
+			});
+			const placed = requireClipTopology(draft, topology.clip.entityId);
+			const window = markerWindow(fieldsOf(draft, placed.marker.entityId, "sequence-marker"));
+			const rate = (window.outMs - window.inMs) / durationMs;
+			replaceEntity(draft, placed.marker.entityId, {
+				...placed.marker,
+				payload: {
+					...placed.marker.payload,
+					...rate === 1 ? {} : { rate }
+				}
+			});
+			this.replaceCaptionAlignment(draft, content.entityId, voiceoverAudioEntityId);
+		}
+	}
+	ensureRoleTrackForClip(draft, clipEntityId, role) {
+		const topology = requireClipTopology(draft, clipEntityId);
+		const track = requireEntityKind(draft, otherEndpoint(topology.trackRelation, topology.clip.entityId), "track");
+		const timeline = requireEntityKind(draft, otherEndpoint(requireOneContain(draft, track.entityId, "contained"), track.entityId), "timeline");
+		return this.ensureRoleTrack(draft, timeline.entityId, role);
+	}
+	/** A Caption follows one take; it is relinked only when that take changes. */
+	replaceCaptionAlignment(draft, captionEntityId, voiceoverAudioEntityId) {
+		const existing = incidentRelations(draft, captionEntityId).filter((relation) => relation.relationKind === "caption-alignment");
+		if (existing.length === 1 && existing[0].endpoint1EntityId === voiceoverAudioEntityId) return;
+		const removed = new Set(existing.map((relation) => relation.relationId));
+		draft.relations = draft.relations.filter((relation) => !removed.has(relation.relationId));
+		draft.relations.push(this.createRelation(draft, "caption-alignment", captionEntityId, voiceoverAudioEntityId));
+	}
+	/**
+	* Remove one placed Caption use. The composed AudioScript outlives the
+	* caption: it may anchor further captions and remains the text owner.
+	*/
+	removeCaptionClipGraph(draft, clipEntityId) {
+		const topology = requireClipOnRole(draft, clipEntityId, "caption");
+		const caption = requireEntityKind(draft, otherEndpoint(topology.contentRelation, topology.clip.entityId), "caption");
+		const contentRelations = incidentRelations(draft, caption.entityId);
+		const allowed = new Set(["caption-alignment", "contain"]);
+		const unsupported = contentRelations.filter((relation) => !allowed.has(relation.relationKind));
+		if (unsupported.length > 0) throw new Error(`Cannot delete Caption with unsupported Relation ${unsupported[0].relationId}`);
+		this.removeClipGraph(draft, clipEntityId);
+		if (containing(draft, caption.entityId, "contained").length > 0) return;
+		const removed = new Set(incidentRelations(draft, caption.entityId).map((relation) => relation.relationId));
+		draft.relations = draft.relations.filter((relation) => !removed.has(relation.relationId));
+		draft.entities = draft.entities.filter((entity) => entity.entityId !== caption.entityId);
+	}
+	replaceAnchorHost(draft, childClipEntityId, hostClipEntityId) {
+		const anchors = draft.relations.filter((relation) => relation.relationKind === "clip-anchor" && relation.endpoint0EntityId === childClipEntityId);
+		if (anchors.length !== 1) throw new Error(`Clip "${childClipEntityId}" must have exactly one host`);
+		this.relinkRelation(draft, anchors[0], {
+			endpoint0EntityId: createEntityId(childClipEntityId),
+			endpoint1EntityId: createEntityId(hostClipEntityId)
+		});
+	}
+	/** Rebuild the legacy edit baseline from current visual order before a high-level cascade. */
+	normalizeMainSequential(draft) {
+		const videoTrack = resolveEntityTimelineLayout(draft).tracks.find((track) => track.role === "video_clip");
+		if (videoTrack === void 0) return;
+		videoTrack.clips.forEach((clip, order) => {
+			this.applyClipPlacement(draft, clip.clipEntityId, {
+				kind: "sequential",
+				order
+			});
+		});
+	}
+	resolveOneVoiceoverOverlap(draft) {
+		const layout = resolveEntityTimelineLayout(draft);
+		const speechTrack = layout.tracks.find((track) => track.role === "speech");
+		if (speechTrack === void 0) return;
+		const ranges = speechTrack.clips.map((speech) => {
+			const captions = directAnchorChildren(draft, speech.clipEntityId).filter((clipId) => clipRole(draft, clipId) === "caption").map((clipId) => layout.clips.get(clipId)).filter((value) => value !== void 0);
+			return {
+				speech,
+				start: Math.min(speech.start, ...captions.map((caption) => caption.start)),
+				end: Math.max(speech.start + speech.duration, ...captions.map((caption) => caption.start + caption.duration))
+			};
+		}).sort((left, right) => left.start - right.start || left.speech.clipEntityId.localeCompare(right.speech.clipEntityId));
+		for (let index = 1; index < ranges.length; index += 1) {
+			const prior = ranges[index - 1];
+			const current = ranges[index];
+			if (current.start >= prior.end) continue;
+			const hostId = current.speech.anchorClipEntityId;
+			if (hostId === void 0) continue;
+			const videoTrack = layout.tracks.find((track) => track.role === "video_clip");
+			const hostIndex = videoTrack?.clips.findIndex((clip) => clip.clipEntityId === hostId) ?? -1;
+			if (videoTrack === void 0 || hostIndex < 0) continue;
+			const overlapMs = Math.round(prior.end - current.start);
+			for (const [visualIndex, clip] of videoTrack.clips.entries()) this.applyClipPlacement(draft, clip.clipEntityId, {
+				kind: "absolute",
+				startMs: clip.start + (visualIndex >= hostIndex ? overlapMs : 0)
+			});
+			return;
+		}
+	}
+	applyClipPlacement(draft, clipEntityId, placement) {
+		const topology = requireClipTopology(draft, clipEntityId);
+		const clipPayload = structuredClone(topology.clip.payload);
+		const markerPayloadValue = { ...structuredClone(topology.marker.payload) };
+		delete markerPayloadValue.startMs;
+		const outgoingAnchors = draft.relations.filter((relation) => relation.relationKind === "clip-anchor" && relation.endpoint0EntityId === topology.clip.entityId);
+		const removed = new Set(outgoingAnchors.map((relation) => relation.relationId));
+		draft.relations = draft.relations.filter((relation) => !removed.has(relation.relationId));
+		if (placement.kind === "sequential") setClipOrder(draft, topology.clip.entityId, placement.order);
+		else if (placement.kind === "absolute") markerPayloadValue.startMs = finiteNonNegative(placement.startMs, "startMs");
+		else {
+			const host = requireEntityKind(draft, placement.hostClipEntityId, "clip");
+			if (host.entityId === topology.clip.entityId) throw new Error("A Clip cannot anchor to itself");
+			markerPayloadValue.startMs = finiteNonNegative(placement.startMs, "startMs");
+			draft.relations.push(this.createRelation(draft, "clip-anchor", topology.clip.entityId, host.entityId));
+		}
+		replaceEntity(draft, topology.clip.entityId, {
+			...topology.clip,
+			payload: clipPayload
+		});
+		replaceEntity(draft, topology.marker.entityId, {
+			...topology.marker,
+			payload: markerPayloadValue
+		});
+	}
+	reanchorAtAbsolute(draft, childClipEntityId, absoluteStart, layout) {
+		const hosts = layout.tracks.find((track) => track.role === "video_clip")?.clips.filter((clip) => clip.mode === "sequential") ?? [];
+		if (hosts.length === 0) {
+			if (layout.clips.get(childClipEntityId) === void 0) throw new Error(`Clip "${childClipEntityId}" is not placed`);
+			this.applyClipPlacement(draft, childClipEntityId, {
+				kind: "absolute",
+				startMs: absoluteStart
+			});
+			return;
+		}
+		const host = hosts.find((candidate) => candidate.start <= absoluteStart && absoluteStart < candidate.start + candidate.duration) ?? (absoluteStart < hosts[0].start ? hosts[0] : hosts.at(-1));
+		this.applyClipPlacement(draft, childClipEntityId, {
+			kind: "anchored",
+			hostClipEntityId: host.clipEntityId,
+			startMs: Math.max(0, Math.round(absoluteStart - host.start))
+		});
+	}
+	removeAnchoredDescendants(draft, hostClipEntityId, scheduled) {
+		const children = draft.relations.filter((relation) => relation.relationKind === "clip-anchor" && relation.endpoint1EntityId === hostClipEntityId).map((relation) => String(relation.endpoint0EntityId));
+		for (const child of children) {
+			if (scheduled.has(child)) continue;
+			const descendants = new Set(scheduled);
+			descendants.add(child);
+			this.removeAnchoredDescendants(draft, child, descendants);
+			if (clipRole(draft, child) === "caption") this.removeCaptionClipGraph(draft, child);
+			else this.removeClipGraph(draft, child);
+		}
+	}
+	removeClipGraph(draft, clipEntityId) {
+		const topology = requireClipTopology(draft, clipEntityId);
+		assertOnlyStructuralIncidents(draft, topology.clip.entityId, new Set([
+			"contain",
+			"marker",
+			"clip-anchor"
+		]));
+		assertOnlyStructuralIncidents(draft, topology.marker.entityId, new Set(["marker"]));
+		const markerIsExclusive = incidentRelations(draft, topology.marker.entityId).filter((relation) => relation.relationKind === "marker").length === 1;
+		const removed = new Set(incidentRelations(draft, topology.clip.entityId).map((relation) => relation.relationId));
+		if (markerIsExclusive) for (const relation of incidentRelations(draft, topology.marker.entityId)) removed.add(relation.relationId);
+		draft.relations = draft.relations.filter((relation) => !removed.has(relation.relationId));
+		draft.entities = draft.entities.filter((entity) => entity.entityId !== topology.clip.entityId && (!markerIsExclusive || entity.entityId !== topology.marker.entityId));
+	}
+	transact(edit) {
+		const draft = cloneRows(this.state);
+		const result = edit(draft);
+		validateFinalRows(draft);
+		assertMediaAssetWritePolicy(this.state, draft);
+		this.state = draft;
+		return result;
+	}
+	mintEntityId(draft) {
+		const entityId = createEntityId(this.idFactory("entity"));
+		if (draft.entities.some((entity) => entity.entityId === entityId)) throw new Error(`Entity id "${entityId}" already exists`);
+		return entityId;
+	}
+	createRelation(draft, relationKind, endpoint0EntityId, endpoint1EntityId) {
+		return {
+			relationId: this.mintRelationId(draft),
+			relationKind,
+			endpoint0EntityId,
+			endpoint1EntityId
+		};
+	}
+	relinkRelation(draft, relation, endpoints) {
+		const relationId = this.mintRelationId(draft);
+		const index = draft.relations.findIndex((candidate) => candidate.relationId === relation.relationId);
+		if (index < 0) throw new Error(`Relation id "${relation.relationId}" does not exist`);
+		draft.relations[index] = {
+			...relation,
+			...endpoints,
+			relationId
+		};
+	}
+	mintRelationId(draft) {
+		const relationId = createRelationId(this.idFactory("relation"));
+		if (draft.relations.some((relation) => relation.relationId === relationId)) throw new Error(`Relation id "${relationId}" already exists`);
+		return relationId;
+	}
+};
+function validateFinalRows(rows) {
+	compile(rows);
+	assertCanonicalEditorResources(rows);
+	validateTimelineHierarchy(rows);
+}
+function validateTimelineHierarchy(rows) {
+	for (const entity of rows.entities) {
+		if (entity.entityKind === "track") requireTrackTimeline(rows, entity.entityId);
+		if (entity.entityKind !== "clip") continue;
+		const trackRelations = containing(rows, entity.entityId, "contained");
+		if (trackRelations.length !== 1) throw new Error(`Clip Entity "${entity.entityId}" must belong to exactly one Track`);
+		requireEntityKind(rows, otherEndpoint(trackRelations[0], entity.entityId), "track");
+	}
+}
+function requireTrackTimeline(rows, trackEntityId) {
+	const timelineRelations = containing(rows, createEntityId(trackEntityId), "contained");
+	if (timelineRelations.filter((relation) => {
+		const otherId = otherEndpoint(relation, trackEntityId);
+		return rows.entities.some((entity) => entity.entityId === otherId && entity.entityKind === "timeline");
+	}).length !== 1 || timelineRelations.length !== 1) throw new Error(`Track Entity "${trackEntityId}" must belong to exactly one Timeline`);
+}
+function requireClipTopology(rows, clipEntityId) {
+	const clip = requireEntityKind(rows, clipEntityId, "clip");
+	const trackRelation = requireOneContain(rows, clip.entityId, "contained");
+	requireEntityKind(rows, otherEndpoint(trackRelation, clip.entityId), "track");
+	const clipMarkerRelation = requireOneRelation(rows, clip.entityId, "marker");
+	const marker = requireEntityKind(rows, otherEndpoint(clipMarkerRelation, clip.entityId), "sequence-marker");
+	const contentRelation = requireOneContain(rows, clip.entityId, "container");
+	requireSequenceContent(rows, otherEndpoint(contentRelation, clip.entityId));
+	return {
+		clip,
+		marker,
+		trackRelation,
+		clipMarkerRelation,
+		contentRelation
+	};
+}
+/**
+* One `contain` Relation with this entity on the stated side.
+*
+* A Clip is contained by its Track and contains its content; a Track is
+* contained by the Timeline and contains its Clips. Both are `contain`, so the
+* endpoint position is the only thing that tells them apart.
+*/
+function requireOneContain(rows, entityId, side) {
+	const matches = containing(rows, entityId, side);
+	if (matches.length !== 1) throw new Error(`Entity "${entityId}" must be the ${side} of exactly one contain Relation`);
+	return matches[0];
+}
+/** `contain` is ordered, so a lookup says which side it wants. */
+function containing(rows, entityId, side) {
+	return (side === "container" ? relationsFrom : relationsTo)(rows.relations, "contain", entityId);
+}
+function requireOneRelation(rows, entityId, relationKind) {
+	const matches = incidentRelations(rows, entityId).filter((relation) => relation.relationKind === relationKind);
+	if (matches.length !== 1) throw new Error(`Entity "${entityId}" must have exactly one ${relationKind} Relation`);
+	return matches[0];
+}
+function requireEntityKind(rows, entityIdValue, entityKind) {
+	const entityId = createEntityId(entityIdValue);
+	const entity = rows.entities.find((candidate) => candidate.entityId === entityId);
+	if (entity == null) throw new Error(`Entity id "${entityId}" does not exist`);
+	if (entity.entityKind !== entityKind) throw new Error(`Entity "${entityId}" must have kind "${entityKind}", got "${entity.entityKind}"`);
+	return entity;
+}
+function requireSequenceContent(rows, entityIdValue) {
+	if (/^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(entityIdValue)) throw new Error("Timeline content must reference an existing Sequence media Entity id; a URL is not allowed");
+	const entityId = createEntityId(entityIdValue);
+	const row = rows.entities.find((candidate) => candidate.entityId === entityId);
+	if (row == null) throw new Error(`Timeline content must reference an existing Sequence media Entity; "${entityId}" was not found`);
+	if (!hasSequence({
+		...row.payload,
+		entityId: row.entityId,
+		entityKind: row.entityKind
+	})) throw new Error(`Timeline content must reference a Sequence media Entity, but "${entityId}" has kind "${row.entityKind}"`);
+	return row;
+}
+function assertOnlyStructuralIncidents(rows, entityId, allowedKinds) {
+	const unsupported = incidentRelations(rows, entityId).filter((relation) => !allowedKinds.has(relation.relationKind));
+	if (unsupported.length === 0) return;
+	throw new Error(`Cannot delete Clip graph: Entity "${entityId}" has unsupported incident Relation id(s): ${unsupported.map((relation) => relation.relationId).sort().join(", ")}`);
+}
+function incidentRelations(rows, entityId) {
+	return rows.relations.filter((relation) => relation.endpoint0EntityId === entityId || relation.endpoint1EntityId === entityId);
+}
+function hasOutgoingClipAnchor(rows, clipEntityId) {
+	return rows.relations.some((relation) => relation.relationKind === "clip-anchor" && relation.endpoint0EntityId === clipEntityId);
+}
+function outgoingAnchorChildren(rows, hostIds) {
+	return rows.relations.filter((relation) => relation.relationKind === "clip-anchor" && hostIds.has(relation.endpoint1EntityId)).map((relation) => String(relation.endpoint0EntityId));
+}
+/** What the placement puts on the Marker; a sequential one puts nothing there. */
+function applyPlacementPayload(placement) {
+	if (placement.kind === "sequential") return {};
+	return { startMs: finiteNonNegative(placement.startMs, "startMs") };
+}
+function requireAvailableEntityId(rows, value) {
+	const entityId = createEntityId(value);
+	if (rows.entities.some((entity) => entity.entityId === entityId)) throw new Error(`Entity id "${entityId}" already exists`);
+	return entityId;
+}
+/**
+* Put a Clip at `order` among the Clips its Track contains.
+*
+* Where a Clip sits is the position of its membership Relation, so moving one
+* is moving that Relation — nothing on the Clip changes, and there are no
+* sibling positions left to keep in step.
+*/
+function setClipOrder(rows, clipEntityId, order) {
+	const membership = relationsTo(rows.relations, "contain", clipEntityId)[0];
+	if (membership === void 0) throw new Error(`Clip "${clipEntityId}" is contained by no Track`);
+	const slots = [];
+	const siblings = [];
+	for (const [index, relation] of rows.relations.entries()) {
+		if (relation.relationKind !== "contain" || relation.endpoint0EntityId !== membership.endpoint0EntityId) continue;
+		slots.push(index);
+		siblings.push(relation);
+	}
+	const from = siblings.indexOf(membership);
+	const moved = siblings.filter((relation) => relation !== membership);
+	moved.splice(Math.max(0, Math.min(order, moved.length)), 0, membership);
+	if (from < 0) return;
+	slots.forEach((slot, at) => rows.relations[slot] = moved[at]);
+}
+function findRoleTrack(rows, timelineEntityId, role) {
+	const timeline = requireEntityKind(rows, timelineEntityId, "timeline");
+	const tracks = containing(rows, timeline.entityId, "container").map((relation) => requireEntityKind(rows, otherEndpoint(relation, timeline.entityId), "track")).filter((track) => fieldsOf(rows, track.entityId, "track").role === role);
+	if (tracks.length > 1) throw new Error(`Timeline "${timelineEntityId}" has multiple ${role} Tracks`);
+	return tracks[0];
+}
+function clipsOnTrack(rows, trackEntityId) {
+	return containing(rows, trackEntityId, "container").map((relation) => requireEntityKind(rows, otherEndpoint(relation, trackEntityId), "clip"));
+}
+function clipRole(rows, clipEntityId) {
+	const topology = requireClipTopology(rows, clipEntityId);
+	return fieldsOf(rows, otherEndpoint(topology.trackRelation, topology.clip.entityId), "track").role;
+}
+function directAnchorChildren(rows, hostClipEntityId) {
+	return rows.relations.filter((relation) => relation.relationKind === "clip-anchor" && relation.endpoint1EntityId === hostClipEntityId).map((relation) => String(relation.endpoint0EntityId));
+}
+function requireSupportedRole(rows, topology) {
+	const { role } = fieldsOf(rows, otherEndpoint(topology.trackRelation, topology.clip.entityId), "track");
+	if (role !== "video_clip" && role !== "speech" && role !== "caption" && role !== "bgm") throw new Error(`Clip "${topology.clip.entityId}" is not on a supported timeline Track`);
+	return role;
+}
+function requireClipOnRole(rows, clipEntityId, role) {
+	const topology = requireClipTopology(rows, clipEntityId);
+	if (fieldsOf(rows, otherEndpoint(topology.trackRelation, topology.clip.entityId), "track").role !== role) throw new Error(`Clip "${clipEntityId}" must belong to the ${role} Track`);
+	return topology;
+}
+function finiteNumber(value, label) {
+	if (!Number.isFinite(value)) throw new Error(`${label} must be finite`);
+	return value;
+}
+function finitePositive(value, label) {
+	const result = finiteNumber(value, label);
+	if (result <= 0) throw new Error(`${label} must be positive`);
+	return result;
+}
+function requireVolume(value) {
+	const volume = finiteNumber(value, "Clip volume");
+	if (volume < -60 || volume > 20) throw new Error("Clip volume must be between -60 and 20 dB");
+	return volume;
+}
+function requireWindow(inMs, outMs, label = "Sequence Marker") {
+	const start = finiteNonNegative(inMs, `${label} inMs`);
+	const end = finitePositive(outMs, `${label} outMs`);
+	if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || end <= start) throw new Error(`${label} must state a positive whole-millisecond window`);
+	return {
+		inMs: start,
+		outMs: end
+	};
+}
+/** An entity's fields read through its bases: what a read sees when the row may be a variant. */
+function fieldsOf(rows, entityId, kind) {
+	return assembleEntityContent(rows, createEntityId(entityId), kind).payload;
+}
+function markerWindow(payload) {
+	return requireWindow(payload.inMs, payload.outMs);
+}
+/**
+* How long the Clip runs. The window and the rate are the only stored facts;
+* the played length follows from them rather than being kept in step by hand.
+*/
+function markerDuration(payload, window = markerWindow(payload)) {
+	return Math.round((window.outMs - window.inMs) / markerRate(payload));
+}
+function markerRate(payload) {
+	return payload.rate === void 0 ? 1 : finitePositive(payload.rate, "linear speed rate");
+}
+function replaceRows(rows, replacement) {
+	rows.entities = structuredClone([...replacement.entities]);
+	rows.relations = structuredClone([...replacement.relations]);
+}
+function finiteNonNegative(value, label) {
+	const result = finiteNumber(value, label);
+	if (result < 0) throw new Error(`${label} must be non-negative`);
+	return result;
+}
+/** How many Clips the Track already holds — the index a new one lands at. */
+function nextSequentialOrder(rows, trackEntityId) {
+	return relationsFrom(rows.relations, "contain", trackEntityId).length;
+}
+function otherEndpoint(relation, entityId) {
+	if (relation.endpoint0EntityId === entityId) return relation.endpoint1EntityId;
+	if (relation.endpoint1EntityId === entityId) return relation.endpoint0EntityId;
+	throw new Error(`Relation "${relation.relationId}" is not incident to Entity "${entityId}"`);
+}
+function replaceEntity(rows, entityId, replacement) {
+	const index = rows.entities.findIndex((entity) => entity.entityId === entityId);
+	if (index < 0) throw new Error(`Entity id "${entityId}" does not exist`);
+	rows.entities[index] = replacement;
+}
+function cloneRows(rows) {
+	return {
+		entities: rows.entities.map((entity) => structuredClone(entity)),
+		relations: rows.relations.map((relation) => structuredClone(relation))
+	};
+}
+//#endregion
+//#region src/editor/id-gen.ts
+/**
+* Part-id generation, aligned with the online ecosystem.
+*
+* The authoritative online producers — agent-harness (`@harness/shared`
+* `genObjId`) and director.v2 (`common/obj_id.py` `gen_obj_id`) — both mint part
+* ids as `` `${prefix}_${ulid()}` ``, and real captured drafts use exactly that
+* shape (`clip_…` / `spe_…` / `cap_…` / `bgm_…`, each a 26-char ULID). The engine
+* previously emitted `vc_<base36 timestamp><6 random>`, a different prefix AND a
+* different encoding — the sole cross-repo id divergence. This module removes it
+* by emitting the same `<prefix>_<ULID>` bytes.
+*
+* The ULID is generated inline (Crockford Base32, 48-bit time + 80-bit random)
+* rather than pulling the `ulid` npm package: the randomness class matches the
+* old generator (both `Math.random`-based) and it keeps `@mengine/medeo-client`
+* dependency-free for a purely mechanical id string. Part ids only need to be
+* unique and lexicographically time-sortable, which this satisfies.
+*/
+/** Crockford Base32 alphabet (no I, L, O, U), per the ULID spec. */
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const TIME_LEN = 10;
+const RANDOM_LEN = 16;
+function encodeTime(now) {
+	let out = "";
+	let ms = now;
+	for (let i = TIME_LEN - 1; i >= 0; i--) {
+		const mod = ms % 32;
+		out = CROCKFORD[mod] + out;
+		ms = (ms - mod) / 32;
+	}
+	return out;
+}
+function encodeRandom() {
+	let out = "";
+	for (let i = 0; i < RANDOM_LEN; i++) out += CROCKFORD[Math.floor(Math.random() * 32)];
+	return out;
+}
+/** A 26-char Crockford Base32 ULID (10-char time + 16-char random). */
+function ulid() {
+	return encodeTime(Date.now()) + encodeRandom();
+}
+function generatePartId(prefix) {
+	return `${prefix}_${ulid()}`;
+}
+//#endregion
+//#region src/legacy/manual-sync-doc.ts
+/** Legacy entity tools only. The retired timeline document has no editing or reading adapter. */
+var ManualSyncDoc = class ManualSyncDoc extends ManualSyncTransport {
+	constructor(client, doc, watermark) {
+		super(client, doc, watermark);
+		if (!Object.hasOwn(doc.getShallowValue(), "medeo") || doc.getMap("medeo").get("schema") !== "medeo.entities.loro.v1") throw new Error("Legacy tools require an Entity document");
+		readEntityDocument(doc);
+	}
+	static open(options) {
+		return openManualDocument(options, (doc, watermark) => new ManualSyncDoc(options.client, doc, watermark));
+	}
+	isEntityDocument() {
+		this.assertActive();
+		return true;
+	}
+	content() {
+		this.assertActive();
+		return projectEntityTimeline(readEntityDocument(this.doc).rows);
+	}
+};
+//#endregion
+export { EntityGraphHttpClient, EntityProjectionGraph, EntityTimelineEditor, EntityTimelineProjectionError, LORO_ENTITY_SCHEMA, LoroEntityDocument, LoroEntityDraft, ManualSyncDoc, MedeoHttpDocStorage, MemoryDocStorage, MengineHttpClient, MengineHttpRequestError, MenginePushRejectedError, ScriptCompositionError, apply, applyFieldChanges, assembleEntityContent, assembleScriptText, assertCanonicalEditorResources, assertFieldChanges, assertMediaAssetWritePolicy, assetBytes, assetDigest, audioScriptAssetContent, base64ToBytes, bytesToBase64, decodeDocVersionMark, encodeDocVersionMark, ensureEditorFoundation, generatePartId, importMediaAsset, isJsonObject, phoneticScriptAssetContent, prepareCaptionContent, projectEntityTimeline, readDocumentAudioScript, readEntityDocument, readMengineEventStream, resolveEntityFieldOwner, resolveEntityTimelineLayout, resolveFieldPath, resolveGraphLayout, scriptAssetContent, scriptSnapshotAssetOf, scriptSnapshotIsCurrent, scriptSourceAssetOf, segmentsOf, selectedSegment };