@mengine/medeo-client 2.0.1 → 2.1.1-dsl.0

package/dist/dsl-Dkecq_2c.js

@@ -0,0 +1,2814 @@
+import { C as resourceId, S as relationId, _ as relationTables, b as assertResourceIdentity, c as isInvalidAtomic, d as assertEntityPatch, f as assertId, g as mergeFields, h as isRecord, m as entityTables, n as textStyles, o as medeoDslLoroShape, p as assertRelation, s as captionContentCodec, t as DEFAULT_UNIT_TIME_MS, u as assertEntity, v as validLanguage, x as defaultIdFactory, y as assertRelationIdentity } from "./video-draft-types-DTXxvPt-.js";
+import { Cursor, LoroDoc, LoroText, isContainer } from "loro-crdt";
+import { Mirror } from "loro-mirror";
+//#region ../medeo-dsl/src/text.ts
+function assertTextOffset(text, at) {
+	if (!Number.isSafeInteger(at) || at < 0 || at > text.length) throw new Error("Invalid UTF-16 text offset");
+	const left = text.charCodeAt(at - 1), right = text.charCodeAt(at);
+	if (left >= 55296 && left <= 56319 && right >= 56320 && right <= 57343) throw new Error("Offset splits a surrogate pair");
+}
+function range(text, start, end) {
+	assertTextOffset(text, start);
+	assertTextOffset(text, end);
+	if (start >= end) throw new Error("Expected a nonempty text range");
+}
+function assertMark(key, value, selected) {
+	if (key !== "language" && key !== "pauseMs") throw new Error(`Unsupported mark: ${key}`);
+	if (value === null) return;
+	if (key === "language" && !validLanguage(value)) throw new Error("Invalid language");
+	if (key === "pauseMs" && (selected !== " " || typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)) throw new Error("pauseMs requires a nonnegative integer on one ordinary space");
+}
+function attributes(attrs, selected) {
+	if (!attrs) return;
+	const result = {};
+	for (const [key, value] of Object.entries(attrs)) {
+		assertMark(key, value, selected);
+		result[key] = key === "pauseMs" && value === 0 ? null : value;
+	}
+	return result;
+}
+function previewDelta(text, delta) {
+	let offset = 0;
+	const normalized = [];
+	for (const op of delta) {
+		const keys = Object.keys(op);
+		if (keys.filter((key) => [
+			"insert",
+			"retain",
+			"delete"
+		].includes(key)).length !== 1 || keys.some((key) => ![
+			"insert",
+			"retain",
+			"delete",
+			"attributes"
+		].includes(key))) throw new Error("Invalid text Delta operation");
+		if ("insert" in op) {
+			if (typeof op.insert !== "string") throw new Error("Only text insertions are supported");
+			const attrs = attributes(op.attributes, op.insert);
+			text = text.slice(0, offset) + op.insert + text.slice(offset);
+			normalized.push({
+				insert: op.insert,
+				...attrs ? { attributes: attrs } : {}
+			});
+			offset += op.insert.length;
+		} else {
+			const length = "retain" in op ? op.retain : op.delete;
+			if (!Number.isSafeInteger(length) || length < 0) throw new Error("Invalid Delta length");
+			assertTextOffset(text, offset + length);
+			if ("retain" in op) {
+				const attrs = attributes(op.attributes, text.slice(offset, offset + length));
+				normalized.push({
+					retain: length,
+					...attrs ? { attributes: attrs } : {}
+				});
+				offset += length;
+			} else {
+				if ("attributes" in op) throw new Error("Delete cannot have attributes");
+				text = text.slice(0, offset) + text.slice(offset + length);
+				normalized.push({ delete: length });
+			}
+		}
+	}
+	return {
+		text,
+		delta: normalized
+	};
+}
+function prepareTextEdits(text, edits) {
+	return {
+		edits: edits.map((edit) => {
+			switch (edit.type) {
+				case "insert":
+					assertTextOffset(text, edit.at);
+					if (typeof edit.text !== "string") throw new Error("Expected text");
+					text = text.slice(0, edit.at) + edit.text + text.slice(edit.at);
+					break;
+				case "delete":
+					assertTextOffset(text, edit.at);
+					if (!Number.isSafeInteger(edit.length) || edit.length < 0) throw new Error("Invalid delete length");
+					assertTextOffset(text, edit.at + edit.length);
+					text = text.slice(0, edit.at) + text.slice(edit.at + edit.length);
+					break;
+				case "mark":
+					range(text, edit.start, edit.end);
+					assertMark(edit.key, edit.value, text.slice(edit.start, edit.end));
+					break;
+				case "unmark":
+					range(text, edit.start, edit.end);
+					assertMark(edit.key, null, "");
+					break;
+				case "delta": {
+					const result = previewDelta(text, edit.delta);
+					text = result.text;
+					return {
+						type: "delta",
+						delta: result.delta
+					};
+				}
+				default: throw new Error("Unknown text edit");
+			}
+			return edit;
+		}),
+		body: text
+	};
+}
+//#endregion
+//#region ../medeo-dsl/src/relations.ts
+/** The row an endpoint names; refused when it is missing. */
+function requireEntity(rows, table, id) {
+	if (typeof id !== "string" || !Object.hasOwn(rows[table], id)) throw new Error(`Missing ${table} endpoint: ${String(id)}`);
+	const row = rows[table][id];
+	if (!isRecord(row)) throw new Error(`Missing ${table} endpoint: ${id}`);
+	return row;
+}
+/**
+* Whether one relation row may stand among these rows: its fields, its derived ID, and what
+* its kind requires of each end. A row being linked need not be in `rows` yet. Caption content
+* selects text, so its range is checked against the body with {@link assertCaptionSelection}.
+*/
+function assertRelationAdmitted(rows, table, id, value) {
+	assertId(id);
+	assertRelation(table, value);
+	assertRelationIdentity(table, id, value);
+	const v = value;
+	const require = (endpoint, id) => requireEntity(rows, endpoint, id);
+	switch (table) {
+		case "clip-source-relations":
+			require("clip-entities", v.clipId);
+			if (!rows["media-entities"][v.sourceId] && !rows["caption-entities"][v.sourceId]) throw new Error("Invalid Clip source");
+			break;
+		case "time-anchor-relations": {
+			require("clip-entities", v.from);
+			if (rows["timeline-entities"][v.to]) {
+				if (v.offsetMs < 0) throw new Error("Absolute offset must be nonnegative");
+			} else require("clip-entities", v.to);
+			const visited = /* @__PURE__ */ new Set();
+			let from = v.from;
+			while (true) {
+				if (visited.has(from)) throw new Error("Time anchor cycle");
+				visited.add(from);
+				const anchor = from === v.from ? v : rows["time-anchor-relations"][`ta:${from}`];
+				if (!isRecord(anchor) || typeof anchor.to !== "string") break;
+				from = anchor.to;
+			}
+			break;
+		}
+		case "caption-content-relations":
+			assertCaptionEndpoints(rows, v);
+			break;
+		case "caption-alignment-relations": {
+			require("caption-entities", v.captionId);
+			const media = require("media-entities", v.mediaId);
+			if (media.kind === "image" || v.startMs >= v.endMs || v.endMs > media.durationMs) throw new Error("Invalid source alignment");
+			break;
+		}
+		case "voice-timbre-relations":
+			if (require("media-entities", v.recordingId).kind !== "voiceover-recording") throw new Error("Timbre requires a voiceover recording");
+			require("voice-entities", v.voiceId);
+			break;
+		case "derived-from-relations":
+			for (const end of [v.entityId, v.sourceId]) if (!entityTables.some((t) => Object.hasOwn(rows[t], end))) throw new Error("Missing provenance endpoint");
+			break;
+		case "from-asset-relations":
+		case "to-asset-relations": {
+			require("audio-script-entities", v.audioScriptId);
+			const asset = require("asset-entities", v.assetId);
+			if (table === "to-asset-relations" && !asset.digest) throw new Error("Export Asset requires digest");
+			break;
+		}
+	}
+}
+/** Both ends of a caption's selection exist: the caption and the script it selects from. */
+function assertCaptionEndpoints(rows, selection) {
+	requireEntity(rows, "caption-entities", selection.captionId);
+	requireEntity(rows, "audio-script-entities", selection.audioScriptId);
+}
+/** A caption selects a nonempty run of its script's current body, in UTF-16 offsets. */
+function assertCaptionSelection(rows, selection, body) {
+	assertCaptionEndpoints(rows, selection);
+	assertTextOffset(body, selection.start);
+	assertTextOffset(body, selection.end);
+	if (selection.start >= selection.end) throw new Error("Expected a nonempty range in the current body");
+}
+/** A caption's text comes from a selection of a script or from its own text, never both. */
+function assertCaptionSource(caption, selected) {
+	if (caption?.text !== void 0 && selected) throw new Error("Caption must have only one content source");
+}
+//#endregion
+//#region ../medeo-dsl/src/contain.ts
+/** Whether an entity may sit here: a root is a Track, and a root Track holds Clips. */
+function containAdmits(rows, parentId, entityId) {
+	return parentId === void 0 ? Object.hasOwn(rows["track-entities"], entityId) : Object.hasOwn(rows["track-entities"], parentId) && Object.hasOwn(rows["clip-entities"], entityId);
+}
+function locate(tree) {
+	const placed = /* @__PURE__ */ new Map();
+	const walk = (nodes, parentId, depth) => {
+		for (const node of nodes) {
+			if (placed.has(node.entityId)) throw new Error(`Duplicate containment: ${node.entityId}`);
+			placed.set(node.entityId, {
+				parentId,
+				depth,
+				children: node.children?.length ?? 0
+			});
+			walk(node.children ?? [], node.entityId, depth + 1);
+		}
+	};
+	walk(tree, void 0, 0);
+	return placed;
+}
+/** One containment edit against the current tree, refused before anything moves. */
+function assertContainChange(rows, tree, mutation) {
+	if (![
+		"insert-node",
+		"move-node",
+		"delete-node"
+	].includes(mutation.type)) throw new Error("Unknown Tree mutation");
+	const placed = locate(tree);
+	const current = placed.get(mutation.entityId);
+	if (mutation.type === "delete-node") {
+		if (!current) throw new Error("Containment node does not exist");
+		return;
+	}
+	const parent = mutation.parentId === void 0 ? void 0 : placed.get(mutation.parentId);
+	if (mutation.parentId !== void 0 && (!parent || !rows["track-entities"][mutation.parentId] || parent.parentId !== void 0)) throw new Error("Expected a live root Track parent");
+	if (!(parent ? rows["clip-entities"][mutation.entityId] : rows["track-entities"][mutation.entityId])) throw new Error("Containment must be Track → Clip");
+	if (mutation.type === "insert-node" && current) throw new Error("Entity is already contained");
+	if (mutation.type === "move-node" && !current) throw new Error("Containment node does not exist");
+	const siblings = parent ? parent.children : tree.length;
+	const length = current && current.parentId === mutation.parentId ? siblings - 1 : siblings;
+	const at = mutation.index ?? length;
+	if (!Number.isSafeInteger(at) || at < 0 || at > length) throw new Error("Invalid insertion index");
+}
+/** The whole tree: Track roots holding Clips, every entity contained once. */
+function assertContainTree(rows, tree) {
+	for (const [entityId, at] of locate(tree)) {
+		if (at.parentId === void 0) {
+			requireEntity(rows, "track-entities", entityId);
+			continue;
+		}
+		requireEntity(rows, "track-entities", at.parentId);
+		requireEntity(rows, "clip-entities", entityId);
+		if (at.children || at.depth !== 1) throw new Error("Containment must be Track → Clip");
+	}
+}
+//#endregion
+//#region ../medeo-dsl/src/plan.ts
+/** Include removed nested keys: a partial merge alone would conceal a deleted required field. */
+function replacementPatch(before, after) {
+	if (!isRecord(before) || !isRecord(after)) return after;
+	return Object.fromEntries([...new Set([...Object.keys(before), ...Object.keys(after)])].map((key) => [key, replacementPatch(before[key], after[key])]));
+}
+/**
+* Admission of one whole change, asked once before it is published. Only what the change touched
+* is checked, so an unrelated edit still lands in a merged document that holds invalid rows.
+* Containment and caption selections are checked by whoever holds the tree and the script bodies,
+* with `assertContainTree` and `assertCaptionSelection`.
+*/
+function assertChangeAdmitted(change) {
+	const { before, after } = change;
+	for (const [table, rows] of change.entities) for (const [id, fields] of rows) {
+		const value = after[table][id];
+		if (value === void 0) continue;
+		const old = before[table][id];
+		if (!old) {
+			assertEntity(table, value);
+			if (entityTables.some((t) => t !== table && Object.hasOwn(after[t], id))) throw new Error("Entity ID is already used in another table");
+			assertResourceIdentity(table, id, value);
+		} else {
+			if (!isRecord(value)) throw new Error("Expected an entity object");
+			assertEntityPatch(table, Object.fromEntries([...fields].map((field) => [field, replacementPatch(old[field], value[field])])), old);
+		}
+		const marker = value.seqMarker;
+		if (table === "clip-entities" && (!old || fields.has("seqMarker")) && marker?.outMs <= marker?.inMs) throw new Error("Clip window must be nonempty");
+	}
+	if (change.entities.has("timeline-entities") && Object.keys(after["timeline-entities"]).length > 1) throw new Error("Document already has a Timeline");
+	for (const [table, ids] of change.relations) {
+		if (table === "caption-content-relations") continue;
+		for (const id of ids) {
+			const value = after[table][id];
+			if (value !== void 0) assertRelationAdmitted(after, table, id, value);
+		}
+	}
+}
+//#endregion
+//#region src/dsl/projection/types.ts
+/** Unsupported legacy representations fail explicitly; recoverable CRDT state is returned as diagnostics. */
+var DslProjectionError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues.map((issue) => `${issue.path}: ${issue.message}`).join("; "));
+		this.issues = issues;
+		this.name = "DslProjectionError";
+	}
+};
+function projectionError(code, path, message) {
+	throw new DslProjectionError([{
+		code,
+		path,
+		message
+	}]);
+}
+//#endregion
+//#region src/dsl/projection/layout.ts
+/** Pure deterministic solve. Constraints only move sequential roots; anchors retain their exact offsets. */
+function resolveDslLayout(snapshot) {
+	const timelines = Object.keys(snapshot["timeline-entities"]);
+	if (timelines.length !== 1) projectionError("invalid-timeline", "timeline-entities", "Expected exactly one Timeline");
+	const result = {
+		timelineId: timelines[0],
+		tracks: [],
+		clips: {},
+		durationMs: 0,
+		diagnostics: [...snapshot.diagnostics]
+	};
+	const diagnose = (code, id, message) => result.diagnostics.push({
+		code,
+		path: `clip-entities/${id}`,
+		message
+	});
+	for (const node of snapshot["contain-relations"]) {
+		const track = snapshot["track-entities"][node.entityId];
+		const clips = [];
+		for (const child of node.children) {
+			const id = child.entityId, clip = snapshot["clip-entities"][id];
+			const sourceId = snapshot["clip-source-relations"][`cs:${id}`]?.sourceId;
+			const media = sourceId === void 0 ? void 0 : snapshot["media-entities"][sourceId];
+			const caption = sourceId === void 0 ? void 0 : snapshot["caption-entities"][sourceId];
+			const marker = clip.seqMarker;
+			let inMs = marker.inMs, outMs = marker.outMs;
+			const present = media !== void 0 || caption !== void 0;
+			if (media?.kind !== "image" && media?.durationMs !== void 0) {
+				inMs = Math.min(inMs, media.durationMs);
+				outMs = Math.min(outMs, media.durationMs);
+			}
+			if (inMs !== marker.inMs || outMs !== marker.outMs) diagnose("clamped-window", id, "Window intersects the available source range");
+			if (!present) diagnose("missing-source", id, "Missing source; placement has zero duration");
+			if (outMs <= inMs) diagnose("empty-window", id, "Window is empty; endpoints are not swapped");
+			const rate = marker.rate ?? 1;
+			const duration = present ? Math.max(0, Math.round((outMs - inMs) / rate)) : 0;
+			if (!Number.isSafeInteger(duration)) projectionError("time-overflow", `clip-entities/${id}`, "Duration exceeds safe integer milliseconds");
+			const anchor = snapshot["time-anchor-relations"][`ta:${id}`];
+			const placement = {
+				clipId: id,
+				trackId: node.entityId,
+				sourceId,
+				inMs,
+				outMs,
+				rate,
+				volume: clip.volume ?? 0,
+				startMs: 0,
+				durationMs: duration,
+				fillTimeline: present && duration > 0 && marker.fillTimeline === true,
+				mode: anchor ? anchor.to === result.timelineId ? "absolute" : "anchored" : "sequential"
+			};
+			if (placement.fillTimeline) placement.durationMs = 0;
+			clips.push(placement);
+			result.clips[id] = placement;
+		}
+		result.tracks.push({
+			trackId: node.entityId,
+			role: track.role,
+			hidden: track.hidden ?? false,
+			clips
+		});
+	}
+	const cycle = /* @__PURE__ */ new Set(), done = /* @__PURE__ */ new Set();
+	for (const id of Object.keys(result.clips)) {
+		const path = [], seen = /* @__PURE__ */ new Map();
+		let current = id;
+		while (current && result.clips[current] && !done.has(current)) {
+			const at = seen.get(current);
+			if (at !== void 0) {
+				for (const member of path.slice(at)) cycle.add(member);
+				break;
+			}
+			seen.set(current, path.length);
+			path.push(current);
+			current = snapshot["time-anchor-relations"][`ta:${current}`]?.to;
+		}
+		for (const member of path) done.add(member);
+	}
+	const positions = /* @__PURE__ */ new Map(), roots = /* @__PURE__ */ new Map();
+	const movable = /* @__PURE__ */ new Set();
+	const position = (id) => {
+		const known = positions.get(id);
+		if (known) return known;
+		const clip = result.clips[id], anchor = snapshot["time-anchor-relations"][`ta:${id}`];
+		let value;
+		if (anchor && clip.mode === "anchored" && !cycle.has(id) && result.clips[anchor.to]) {
+			const parent = position(anchor.to);
+			value = {
+				root: parent.root,
+				offset: parent.offset + anchor.offsetMs,
+				floor: Math.max(0, parent.floor + anchor.offsetMs)
+			};
+			clip.anchorClipId = anchor.to;
+		} else {
+			let start = 0;
+			if (anchor) if (clip.mode === "absolute") start = Math.max(0, anchor.offsetMs);
+			else {
+				clip.mode = "fallback";
+				start = anchor.fallback_abs_ms;
+				diagnose(cycle.has(id) ? "anchor-cycle" : "missing-anchor", id, "Using the recorded fallback position");
+			}
+			else movable.add(id);
+			roots.set(id, start);
+			value = {
+				root: id,
+				offset: 0,
+				floor: 0
+			};
+		}
+		positions.set(id, value);
+		return value;
+	};
+	for (const id of Object.keys(result.clips)) position(id);
+	const edges = [];
+	for (const track of result.tracks) {
+		let previous;
+		for (const clip of track.clips) if (clip.mode === "sequential") {
+			if (previous) edges.push({
+				from: previous.clipId,
+				to: clip.clipId,
+				distance: previous.durationMs
+			});
+			previous = clip;
+		}
+	}
+	const solve = (constraints) => {
+		const values = new Map(roots);
+		for (let pass = 0; pass <= roots.size; pass++) {
+			let changed = false;
+			for (const edge of constraints) {
+				const bound = (edge.from === void 0 ? 0 : values.get(edge.from)) + edge.distance;
+				if (bound > values.get(edge.to)) {
+					values.set(edge.to, bound);
+					changed = true;
+				}
+			}
+			if (!changed) return values;
+		}
+	};
+	const apply = (values) => {
+		for (const [id, p] of positions) {
+			const start = Math.max(p.floor, values.get(p.root) + p.offset);
+			if (!Number.isSafeInteger(start)) projectionError("time-overflow", `clip-entities/${id}`, "Position exceeds safe integer milliseconds");
+			result.clips[id].startMs = start;
+		}
+	};
+	apply(solve(edges));
+	const pairs = result.tracks.flatMap((track) => {
+		const sorted = track.clips.filter((c) => !c.fillTimeline && c.durationMs > 0).toSorted((a, b) => a.startMs - b.startMs);
+		return sorted.flatMap((left, i) => sorted.slice(i + 1).map((right) => ({
+			left,
+			right,
+			attempted: false
+		})));
+	});
+	let added;
+	do {
+		added = false;
+		for (const pair of pairs) {
+			const { left, right } = pair;
+			if (pair.attempted || !overlap(left, right)) continue;
+			pair.attempted = true;
+			const a = positions.get(left.clipId), b = positions.get(right.clipId);
+			if (a.root === b.root || !movable.has(b.root)) continue;
+			const candidate = [
+				...edges,
+				{
+					from: a.root,
+					to: b.root,
+					distance: a.offset + left.durationMs - b.offset
+				},
+				{
+					to: b.root,
+					distance: a.floor + left.durationMs - b.offset
+				}
+			];
+			const solved = solve(candidate);
+			if (!solved) continue;
+			edges.push(...candidate.slice(edges.length));
+			apply(solved);
+			added = true;
+		}
+	} while (added);
+	for (const clip of Object.values(result.clips)) if (!clip.fillTimeline && clip.durationMs > 0) result.durationMs = Math.max(result.durationMs, clip.startMs + clip.durationMs);
+	if (!Number.isSafeInteger(result.durationMs)) projectionError("time-overflow", "timeline", "Timeline exceeds safe integer milliseconds");
+	for (const clip of Object.values(result.clips)) if (clip.fillTimeline) clip.durationMs = Math.max(0, result.durationMs - clip.startMs);
+	for (const track of result.tracks) for (let i = 0; i < track.clips.length; i++) {
+		const a = track.clips[i];
+		for (const b of track.clips.slice(i + 1)) if (overlap(a, b)) diagnose("unresolved-overlap", b.clipId, `Overlaps ${a.clipId}; fixed positions, anchors and complete windows are retained`);
+	}
+	for (const [id, relation] of Object.entries(snapshot["caption-alignment-relations"])) {
+		const media = snapshot["media-entities"][relation.mediaId];
+		if (!media || media.kind === "image" || relation.endMs <= relation.startMs || relation.endMs > media.durationMs) result.diagnostics.push({
+			code: "invalid-caption-alignment",
+			path: `caption-alignment-relations/${id}`,
+			message: "No valid source alignment; the placed display window is retained"
+		});
+	}
+	return result;
+}
+function overlap(a, b) {
+	return a.durationMs > 0 && b.durationMs > 0 && a.startMs < b.startMs + b.durationMs && b.startMs < a.startMs + a.durationMs;
+}
+//#endregion
+//#region src/dsl/action-context.ts
+function requireClip(s, id) {
+	const clip = s["clip-entities"][id];
+	if (!clip) throw new Error(`Missing Clip: ${id}`);
+	return clip;
+}
+function requireTrack(s, id) {
+	const track = s["track-entities"][id];
+	if (!track || !s["contain-relations"].some((n) => n.entityId === id)) throw new Error(`Missing placed Track: ${id}`);
+	return track;
+}
+function requireSource(s, id, role) {
+	if (role === "caption" && s["caption-entities"][id]) return s["caption-entities"][id];
+	const media = s["media-entities"][id];
+	assertMediaRole(media, role);
+	return media;
+}
+function assertMediaRole(media, role) {
+	if (!media || !{
+		video_clip: ["video", "image"],
+		speech: ["audio", "voiceover-recording"],
+		bgm: ["audio"],
+		caption: []
+	}[role].includes(media.kind)) throw new Error(`Source is not allowed on ${role} Track`);
+}
+function validateWindow(window, duration) {
+	if (!Number.isSafeInteger(window.inMs) || !Number.isSafeInteger(window.outMs) || window.inMs < 0 || window.outMs <= window.inMs || duration !== void 0 && window.outMs > duration) throw new Error("Invalid Clip window");
+}
+function trackOf(s, id) {
+	requireClip(s, id);
+	const track = s["contain-relations"].find((n) => n.children.some((c) => c.entityId === id));
+	if (!track) throw new Error(`Clip is not placed: ${id}`);
+	return track.entityId;
+}
+function children(s, trackId) {
+	requireTrack(s, trackId);
+	return s["contain-relations"].find((n) => n.entityId === trackId).children.map((n) => n.entityId);
+}
+function uniqueIds(ids) {
+	if (new Set(ids).size !== ids.length) throw new Error("Duplicate Clip IDs");
+}
+function timelineId(s) {
+	const ids = Object.keys(s["timeline-entities"]);
+	if (ids.length !== 1) throw new Error("Expected exactly one Timeline");
+	return ids[0];
+}
+/** Placement facts are authored only by explicit actions; projection never writes them back. */
+function placementMutations(s, clipId, placement) {
+	if (placement.kind === "sequential") return [{
+		type: "delete-relation",
+		table: "time-anchor-relations",
+		id: `ta:${clipId}`
+	}];
+	const offset = placement.kind === "absolute" ? placement.startMs : placement.offsetMs;
+	if (!Number.isSafeInteger(offset) || placement.kind === "absolute" && offset < 0) throw new Error("Invalid placement time");
+	const target = placement.kind === "absolute" ? timelineId(s) : placement.clipId;
+	let fallback = offset;
+	if (placement.kind === "anchored") {
+		trackOf(s, target);
+		const visited = new Set([clipId]);
+		let next = target;
+		while (next && s["clip-entities"][next]) {
+			if (visited.has(next)) throw new Error("Cyclic time anchor");
+			visited.add(next);
+			next = s["time-anchor-relations"][`ta:${next}`]?.to;
+		}
+		fallback = Math.max(0, resolveDslLayout(s).clips[target].startMs + offset);
+	}
+	if (!Number.isSafeInteger(fallback)) throw new Error("Invalid fallback time");
+	return [{
+		type: "set-relation",
+		table: "time-anchor-relations",
+		value: {
+			from: clipId,
+			to: target,
+			offsetMs: offset,
+			fallback_abs_ms: fallback
+		}
+	}];
+}
+function detachChildren(s, ids) {
+	const layout = resolveDslLayout(s);
+	return Object.values(s["time-anchor-relations"]).flatMap((r) => ids.has(r.to) && !ids.has(r.from) && layout.clips[r.from] ? placementMutations(s, r.from, {
+		kind: "absolute",
+		startMs: layout.clips[r.from].startMs
+	}) : []);
+}
+function deleteClips(s, ids, policy) {
+	if (!["cascade", "detach"].includes(policy)) throw new Error("Invalid anchored deletion policy");
+	uniqueIds(ids);
+	ids.forEach((id) => trackOf(s, id));
+	const removed = new Set(ids);
+	if (policy === "cascade") {
+		const queue = [...ids];
+		for (let i = 0; i < queue.length; i++) for (const r of Object.values(s["time-anchor-relations"])) if (r.to === queue[i] && s["clip-entities"][r.from] && !removed.has(r.from)) {
+			removed.add(r.from);
+			queue.push(r.from);
+		}
+	}
+	const mutations = policy === "detach" ? detachChildren(s, removed) : [];
+	for (const id of removed) {
+		if (s["contain-relations"].some((n) => n.children.some((c) => c.entityId === id))) mutations.push({
+			type: "delete-node",
+			entityId: id
+		});
+		mutations.push({
+			type: "delete-relation",
+			table: "time-anchor-relations",
+			id: `ta:${id}`
+		}, {
+			type: "delete-relation",
+			table: "clip-source-relations",
+			id: `cs:${id}`
+		}, {
+			type: "delete-entity",
+			table: "clip-entities",
+			id
+		});
+	}
+	return mutations;
+}
+//#endregion
+//#region src/dsl/clip-actions.ts
+/** Batch edits validate against preceding prepared facts without touching the live document. */
+function updateClipsPlan(base, updates) {
+	uniqueIds(updates.map((update) => update.clipId));
+	const clips = { ...base["clip-entities"] }, anchors = { ...base["time-anchor-relations"] };
+	const preview = {
+		...base,
+		"clip-entities": clips,
+		"time-anchor-relations": anchors
+	};
+	const mutations = [];
+	for (const update of updates) {
+		const clip = requireClip(preview, update.clipId);
+		const marker = {};
+		if (Object.hasOwn(update, "inMs")) marker.inMs = update.inMs;
+		if (Object.hasOwn(update, "outMs")) marker.outMs = update.outMs;
+		if (Object.hasOwn(update, "speed")) marker.rate = update.speed?.rate;
+		const patch = {};
+		if (Object.keys(marker).length) patch.seqMarker = marker;
+		if (Object.hasOwn(update, "volume")) patch.volume = update.volume;
+		const windowChanged = Object.hasOwn(marker, "inMs") || Object.hasOwn(marker, "outMs");
+		if (clip.seqMarker.fillTimeline && (windowChanged || Object.hasOwn(marker, "rate"))) throw new Error("BGM trim and speed are not enabled");
+		const next = mergeFields(clip, patch);
+		if (windowChanged) {
+			const sourceId = preview["clip-source-relations"][`cs:${update.clipId}`]?.sourceId;
+			if (!sourceId) throw new Error("Missing Clip source");
+			const source = requireSource(preview, sourceId, requireTrack(preview, trackOf(preview, update.clipId)).role);
+			validateWindow(next.seqMarker, "durationMs" in source ? source.durationMs : void 0);
+		}
+		if (Object.keys(patch).length) mutations.push({
+			type: "patch-entity",
+			table: "clip-entities",
+			id: update.clipId,
+			patch
+		});
+		clips[update.clipId] = next;
+		if (update.placement) {
+			trackOf(preview, update.clipId);
+			const changes = placementMutations(preview, update.clipId, update.placement);
+			mutations.push(...changes);
+			for (const change of changes) if (change.type === "set-relation" && change.table === "time-anchor-relations") anchors[`ta:${update.clipId}`] = change.value;
+			else if (change.type === "delete-relation") delete anchors[change.id];
+		}
+	}
+	return mutations;
+}
+function sourcePlan(s, input, trackId) {
+	const role = requireTrack(s, trackId).role;
+	if (input.media) {
+		assertMediaRole(input.media, role);
+		const id = resourceId("media", input.media.system, input.media.key);
+		return {
+			id,
+			source: input.media,
+			mutations: [{
+				type: "create-entity",
+				table: "media-entities",
+				id,
+				value: input.media
+			}]
+		};
+	}
+	return {
+		id: input.sourceId,
+		source: requireSource(s, input.sourceId, role),
+		mutations: []
+	};
+}
+function addClipsPlan(s, input, ids) {
+	const length = children(s, input.trackId).length;
+	const index = input.index ?? length;
+	if (!Number.isSafeInteger(index) || index < 0 || index > length) throw new Error("Invalid insertion index");
+	return input.clips.flatMap((item, offset) => {
+		const source = sourcePlan(s, item, input.trackId);
+		const duration = "durationMs" in source.source ? source.source.durationMs : void 0;
+		const outMs = item.outMs ?? duration;
+		if (outMs === void 0) throw new Error("Image and Caption require an explicit display window");
+		const marker = {
+			inMs: item.inMs ?? 0,
+			outMs
+		};
+		if (item.speed !== void 0) marker.rate = item.speed.rate;
+		if (item.fillTimeline) {
+			if (!("kind" in source.source) || !["audio", "voiceover-recording"].includes(source.source.kind)) throw new Error("Timeline fill requires audio");
+			if (item.inMs !== void 0 || item.outMs !== void 0 || item.speed !== void 0) throw new Error("BGM trim and speed are not enabled");
+			marker.fillTimeline = true;
+		}
+		validateWindow(marker, duration);
+		const clip = { seqMarker: marker };
+		if (item.volume !== void 0) clip.volume = item.volume;
+		const id = ids[offset];
+		const result = [
+			...source.mutations,
+			{
+				type: "create-entity",
+				table: "clip-entities",
+				id,
+				value: clip
+			},
+			{
+				type: "set-relation",
+				table: "clip-source-relations",
+				value: {
+					clipId: id,
+					sourceId: source.id
+				}
+			},
+			{
+				type: "insert-node",
+				entityId: id,
+				parentId: input.trackId,
+				index: index + offset
+			}
+		];
+		if (item.placement) result.push(...placementMutations(s, id, item.placement));
+		return result;
+	});
+}
+function moveClipsPlan(s, input) {
+	if (!["follow", "keepAbsolute"].includes(input.onAnchored)) throw new Error("Invalid anchored movement policy");
+	uniqueIds(input.clipIds);
+	const moved = new Set(input.clipIds);
+	const target = children(s, input.trackId).filter((id) => !moved.has(id));
+	if (!Number.isSafeInteger(input.index) || input.index < 0 || input.index > target.length) throw new Error("Invalid insertion index");
+	for (const id of input.clipIds) {
+		trackOf(s, id);
+		if (s["time-anchor-relations"][`ta:${id}`]) throw new Error("Sequential reorder requires sequential Clips");
+		const source = s["clip-source-relations"][`cs:${id}`];
+		if (!source) throw new Error("Missing Clip source");
+		requireSource(s, source.sourceId, requireTrack(s, input.trackId).role);
+	}
+	const mutations = input.onAnchored === "keepAbsolute" ? detachChildren(s, moved) : [];
+	const order = [...target];
+	order.splice(input.index, 0, ...input.clipIds);
+	for (let index = 0; index < order.length; index++) mutations.push({
+		type: "move-node",
+		entityId: order[index],
+		parentId: input.trackId,
+		index
+	});
+	return mutations;
+}
+function replaceSequencePlan(s, input, ids) {
+	if (!["remap", "cascade"].includes(input.onAnchored)) throw new Error("Invalid anchored replacement policy");
+	uniqueIds(input.clipIds);
+	if (!input.clipIds.length || !input.clips.length) throw new Error("Replacement requires nonempty runs");
+	const trackId = trackOf(s, input.clipIds[0]), order = children(s, trackId), index = order.indexOf(input.clipIds[0]);
+	if (input.clipIds.some((id, i) => order[index + i] !== id || s["time-anchor-relations"][`ta:${id}`])) throw new Error("Expected an ordered contiguous sequential run");
+	if (input.clips.some((c) => c.placement && c.placement.kind !== "sequential")) throw new Error("Replacement Clips must be sequential");
+	const mutations = addClipsPlan(s, {
+		trackId,
+		clips: input.clips,
+		index
+	}, ids);
+	const removed = new Set(input.clipIds);
+	const anchors = { ...s["time-anchor-relations"] };
+	if (input.onAnchored === "remap") {
+		const begin = resolveDslLayout(s).clips[input.clipIds[0]].startMs;
+		const starts = [];
+		let end = begin;
+		for (const id of ids) {
+			const creation = mutations.find((m) => m.type === "create-entity" && m.table === "clip-entities" && m.id === id);
+			if (!creation || creation.type !== "create-entity" || creation.table !== "clip-entities") throw new Error("Missing replacement");
+			starts.push(end);
+			const marker = creation.value.seqMarker;
+			end += Math.round((marker.outMs - marker.inMs) / (marker.rate ?? 1));
+		}
+		for (const r of Object.values(s["time-anchor-relations"])) if (removed.has(r.to) && !removed.has(r.from)) {
+			const slot = input.clipIds.indexOf(r.to);
+			if (slot >= ids.length) continue;
+			const value = {
+				from: r.from,
+				to: ids[slot],
+				offsetMs: r.offsetMs,
+				fallback_abs_ms: Math.max(0, starts[slot] + r.offsetMs)
+			};
+			mutations.push({
+				type: "set-relation",
+				table: "time-anchor-relations",
+				value
+			});
+			anchors[`ta:${r.from}`] = value;
+		}
+	}
+	mutations.push(...deleteClips({
+		...s,
+		"time-anchor-relations": anchors
+	}, input.clipIds, "cascade"));
+	return mutations;
+}
+function replaceSourcePlan(s, clipId, input) {
+	if (requireClip(s, clipId).seqMarker.fillTimeline) throw new Error("Use setBgm to replace a fill Clip");
+	const source = sourcePlan(s, input, trackOf(s, clipId));
+	validateWindow(input, "durationMs" in source.source ? source.source.durationMs : void 0);
+	return [
+		...source.mutations,
+		{
+			type: "patch-entity",
+			table: "clip-entities",
+			id: clipId,
+			patch: { seqMarker: {
+				inMs: input.inMs,
+				outMs: input.outMs
+			} }
+		},
+		{
+			type: "set-relation",
+			table: "clip-source-relations",
+			value: {
+				clipId,
+				sourceId: source.id
+			}
+		}
+	];
+}
+//#endregion
+//#region src/dsl/document/read.ts
+/** Looking up a missing root must not create it. */
+function rootMap(doc, name) {
+	const id = doc.getShallowValue()[name];
+	if (typeof id !== "string") return;
+	const value = doc.getContainerById(id);
+	return value?.kind() === "Map" ? value : void 0;
+}
+function liveText(doc, scriptId, caption = false) {
+	const row = rootMap(doc, caption ? "caption-entities" : "audio-script-entities")?.get(scriptId);
+	if (!isContainer(row) || row.kind() !== "Map") return;
+	const body = row.get(caption ? "text" : "body");
+	return isContainer(body) && body.kind() === "Text" && !body.isDeleted() ? body : void 0;
+}
+function readContainNodes(nodes) {
+	const read = (nodes) => nodes.map((node) => ({
+		treeId: node.id,
+		entityId: node.data.entityId,
+		children: read(node.children ?? [])
+	}));
+	return read(nodes);
+}
+function resolveContent(doc, content) {
+	const text = liveText(doc, content.audioScriptId);
+	if (!text || content.start.containerId() !== text.id || content.end.containerId() !== text.id) return;
+	const start = doc.getCursorPos(content.start)?.offset;
+	const end = doc.getCursorPos(content.end)?.offset;
+	if (start === void 0 || end === void 0 || start > end) return;
+	return {
+		text: text.toString().slice(start, end),
+		start,
+		end,
+		bodyId: text.id
+	};
+}
+function readMedeoDsl(doc, state) {
+	const diagnostics = [];
+	const diagnostic = (code, path, error) => diagnostics.push({
+		code,
+		path,
+		message: String(error)
+	});
+	const entities = Object.fromEntries(entityTables.map((t) => [t, {}]));
+	const relations = Object.fromEntries(relationTables.map((t) => [t, {}]));
+	const richText = {};
+	for (const table of entityTables) for (const [id, raw] of Object.entries(state[table] ?? {})) try {
+		assertId(id);
+		assertEntity(table, raw);
+		const v = raw;
+		assertResourceIdentity(table, id, v);
+		entities[table][id] = raw;
+		if (table === "audio-script-entities" || table === "caption-entities" && v.text !== void 0) {
+			const text = liveText(doc, id, table === "caption-entities");
+			if (!text) throw new Error("Missing live LoroText body");
+			richText[id] = {
+				bodyId: text.id,
+				plainText: text.toString(),
+				delta: text.toDelta().flatMap((run) => typeof run.insert === "string" ? [{
+					insert: run.insert,
+					...run.attributes ? { attributes: run.attributes } : {}
+				}] : [])
+			};
+		}
+	} catch (error) {
+		delete entities[table][id];
+		diagnostic("invalid-entity", `${table}/${id}`, error);
+	}
+	const entityIds = new Set(entityTables.flatMap((t) => Object.keys(entities[t])));
+	for (const table of relationTables) for (const [id, value] of Object.entries(state[table] ?? {})) try {
+		if (isInvalidAtomic(value)) throw new Error(value.reason);
+		assertRelation(table, value);
+		assertRelationIdentity(table, id, value);
+		relations[table][id] = value;
+		for (const key of [
+			"clipId",
+			"sourceId",
+			"from",
+			"to",
+			"captionId",
+			"audioScriptId",
+			"mediaId",
+			"recordingId",
+			"voiceId",
+			"entityId",
+			"assetId"
+		]) {
+			const endpoint = value[key];
+			if (typeof endpoint === "string" && !entityIds.has(endpoint)) diagnostic("dangling-reference", `${table}/${id}/${key}`, `Missing entity ${endpoint}`);
+		}
+	} catch (error) {
+		diagnostic("invalid-relation", `${table}/${id}`, error);
+	}
+	const treeNodes = readContainNodes(state["contain-relations"] ?? []);
+	const occurrences = /* @__PURE__ */ new Map();
+	const count = (nodes) => {
+		for (const node of nodes) {
+			occurrences.set(node.entityId, (occurrences.get(node.entityId) ?? 0) + 1);
+			count(node.children);
+		}
+	};
+	count(treeNodes);
+	const validTree = (nodes, parentId) => nodes.flatMap((node) => {
+		if (!containAdmits(entities, parentId, node.entityId) || occurrences.get(node.entityId) > 1) {
+			diagnostic(occurrences.get(node.entityId) > 1 ? "duplicate-containment" : "invalid-containment", `contain-relations/${node.treeId}`, node.entityId);
+			return [];
+		}
+		return [{
+			...node,
+			children: validTree(node.children, node.entityId)
+		}];
+	});
+	const captionText = {};
+	for (const [id, content] of Object.entries(relations["caption-content-relations"])) try {
+		const resolved = resolveContent(doc, content);
+		if (resolved) captionText[content.captionId] = resolved;
+		else diagnostic("invalid-caption-content", `caption-content-relations/${id}`, "Cursor does not resolve in the current body");
+	} catch (error) {
+		diagnostic("invalid-caption-content", `caption-content-relations/${id}`, error);
+	}
+	for (const [id, caption] of Object.entries(entities["caption-entities"])) {
+		const hasReference = Object.hasOwn(relations["caption-content-relations"], `cc:${id}`) || Object.hasOwn(state["caption-content-relations"] ?? {}, `cc:${id}`);
+		if (hasReference && caption.text !== void 0) diagnostic("multiple-caption-sources", `caption-entities/${id}`, "Content reference takes precedence over inline text");
+		if (!hasReference && caption.text !== void 0 && richText[id]) captionText[id] = {
+			text: caption.text,
+			start: 0,
+			end: caption.text.length,
+			bodyId: richText[id].bodyId
+		};
+	}
+	return freezeSnapshot({
+		...entities,
+		...relations,
+		"contain-relations": validTree(treeNodes),
+		richText,
+		captionText,
+		diagnostics
+	});
+}
+function freezeSnapshot(value) {
+	if (value && typeof value === "object" && !(value instanceof Cursor)) {
+		for (const child of Object.values(value)) freezeSnapshot(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+//#endregion
+//#region src/dsl/document/draft.ts
+const entities = new Set(entityTables);
+const relations = new Set(relationTables);
+const reserved = new Set([
+	"$cid",
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/** Copy caller-owned inputs so later aliases cannot bypass draft validation or change queued edits. */
+function copyInput(value, unwrap = (v) => v, seen = /* @__PURE__ */ new Set()) {
+	if (!value || typeof value !== "object") return value;
+	const object = unwrap(value);
+	if (object instanceof Cursor) return Cursor.decode(object.encode());
+	if (seen.has(object)) throw new Error("Cyclic draft input");
+	if (!Array.isArray(object) && ![Object.prototype, null].includes(Object.getPrototypeOf(object))) throw new Error("Expected plain draft data");
+	seen.add(object);
+	const result = Array.isArray(object) ? [] : {};
+	for (const key of Object.keys(object)) {
+		if (reserved.has(key)) throw new Error(`Reserved field: ${key}`);
+		result[key] = copyInput(object[key], unwrap, seen);
+	}
+	seen.delete(object);
+	return result;
+}
+/** Wrap the live Immer draft, tracking attempted writes as well as final values. */
+var TransactionDraft = class {
+	raw;
+	before;
+	draft;
+	entities = /* @__PURE__ */ new Map();
+	relations = /* @__PURE__ */ new Map();
+	deleted = /* @__PURE__ */ new Set();
+	textPreviews = /* @__PURE__ */ new Map();
+	dirtyCaptions = /* @__PURE__ */ new Set();
+	removedCaptionTexts = /* @__PURE__ */ new Set();
+	treeChanged = false;
+	active = true;
+	failure;
+	wrappers = /* @__PURE__ */ new WeakMap();
+	originals = /* @__PURE__ */ new WeakMap();
+	constructor(raw, before) {
+		this.raw = raw;
+		this.before = before;
+		this.draft = this.wrap(raw, []);
+	}
+	run(fn) {
+		if (!this.active) throw new Error("DSL transaction context has expired");
+		if (this.failure) throw this.failure.error;
+		try {
+			return fn();
+		} catch (error) {
+			return this.fail(error);
+		}
+	}
+	fail(error) {
+		this.failure ??= { error };
+		throw error;
+	}
+	assertValid() {
+		if (this.failure) throw this.failure.error;
+	}
+	close() {
+		this.active = false;
+	}
+	wrap(value, path) {
+		if (!value || typeof value !== "object" || value instanceof Cursor) return value;
+		const cached = this.wrappers.get(value);
+		if (cached) return cached;
+		const proxy = new Proxy(value, {
+			get: (target, key) => this.run(() => {
+				if ((path[0] === "audio-script-entities" && key === "body" || path[0] === "caption-entities" && key === "text") && path.length === 2 && this.textPreviews.has(path[1])) return this.textPreviews.get(path[1]);
+				if (!path.length && key === "contain-relations" && target[key] === void 0) target[key] = [];
+				return this.wrap(Reflect.get(target, key), [...path, String(key)]);
+			}),
+			set: (target, key, next) => this.run(() => {
+				this.changing(path, String(key), next, target, false);
+				const unwrap = (v) => this.originals.get(v) ?? v;
+				const copied = path[0] === "contain-relations" && next && typeof next === "object" && this.originals.has(next) ? unwrap(next) : copyInput(next, unwrap);
+				return Reflect.set(target, key, copied);
+			}),
+			deleteProperty: (target, key) => this.run(() => {
+				this.changing(path, String(key), void 0, target, true);
+				return Reflect.deleteProperty(target, key);
+			}),
+			ownKeys: (target) => this.run(() => Reflect.ownKeys(target)),
+			has: (target, key) => this.run(() => Reflect.has(target, key)),
+			getOwnPropertyDescriptor: (target, key) => this.run(() => {
+				const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+				if (descriptor && "value" in descriptor) return {
+					...descriptor,
+					value: this.wrap(descriptor.value, [...path, String(key)])
+				};
+				return descriptor;
+			}),
+			defineProperty: () => this.fail(/* @__PURE__ */ new Error("Define draft fields by assignment, not descriptors")),
+			setPrototypeOf: () => this.fail(/* @__PURE__ */ new Error("Cannot change draft prototypes")),
+			preventExtensions: () => this.fail(/* @__PURE__ */ new Error("Cannot freeze a transaction draft"))
+		});
+		this.wrappers.set(value, proxy);
+		this.originals.set(proxy, value);
+		return proxy;
+	}
+	changing(path, key, next, target, remove) {
+		if (reserved.has(key)) throw new Error(`Reserved field: ${key}`);
+		if (!path.length) {
+			if (key !== "contain-relations" || remove) throw new Error("Cannot replace or delete a DSL root");
+			this.treeChanged = true;
+			return;
+		}
+		const [table, id] = path;
+		if (table === "contain-relations") {
+			this.treeChanged = true;
+			if (key === "id" || key === "entityId" && target[key] !== void 0 && next !== target[key]) throw new Error("Containment identity cannot be changed");
+			return;
+		}
+		if (!entities.has(table) && !relations.has(table)) throw new Error(`Unknown writable root: ${table}`);
+		const rowId = path.length === 1 ? key : id;
+		assertId(rowId);
+		if (entities.has(table)) {
+			const typed = table;
+			const initial = this.before[typed][rowId];
+			const lifetime = rowId;
+			if (path.length === 1 && (remove || next === void 0)) this.deleted.add(lifetime);
+			else if (this.deleted.has(lifetime)) throw new Error("Recreate an entity in a separate transaction");
+			if (table === "audio-script-entities") {
+				if (path.length === 2 && key === "body" && (initial || this.textPreviews.has(rowId))) throw new Error("Edit body through the Text adapter");
+				if (path.length === 1 && initial && isRecord(next) && next.body !== initial.body) throw new Error("Edit body through the Text adapter");
+				if (path.length === 1 && this.textPreviews.has(rowId)) throw new Error("Cannot delete or replace a body used in this transaction");
+			}
+			if (table === "caption-entities") {
+				const changesText = path.length === 1 || path.length === 2 && key === "text";
+				const nextText = path.length === 1 ? isRecord(next) ? next.text : void 0 : next;
+				if (changesText) {
+					if (this.textPreviews.has(rowId)) throw new Error("Cannot delete or replace a body used in this transaction");
+					if (nextText !== void 0 && (this.removedCaptionTexts.has(rowId) || initial?.text !== void 0 && nextText !== initial.text)) throw new Error("Edit Caption text through the Text adapter");
+					if (initial?.text !== void 0 && nextText === void 0) this.removedCaptionTexts.add(rowId);
+				}
+			}
+			if (initial && [
+				"media-entities",
+				"asset-entities",
+				"voice-entities"
+			].includes(table)) {
+				for (const field of [
+					"system",
+					"key",
+					"kind"
+				]) if (path.length === 2 && key === field && next !== initial[field] || path.length === 1 && isRecord(next) && next[field] !== initial[field]) throw new Error(`Resource identity field is immutable: ${field}`);
+			}
+			let rows = this.entities.get(typed);
+			if (!rows) this.entities.set(typed, rows = /* @__PURE__ */ new Map());
+			let fields = rows.get(rowId);
+			if (!fields) rows.set(rowId, fields = /* @__PURE__ */ new Set());
+			if (path.length === 1) for (const field of [...Object.keys(initial ?? {}), ...Object.keys(isRecord(next) ? next : {})]) {
+				if ((field === "body" && table === "audio-script-entities" || field === "text" && table === "caption-entities") && initial && isRecord(next) && next[field] === initial[field]) continue;
+				fields.add(field);
+			}
+			else fields.add(path[2] ?? key);
+		} else {
+			let ids = this.relations.get(table);
+			if (!ids) this.relations.set(table, ids = /* @__PURE__ */ new Set());
+			ids.add(rowId);
+			if (table === "caption-content-relations") this.dirtyCaptions.add(rowId);
+		}
+	}
+};
+//#endregion
+//#region src/dsl/document/draft-operations.ts
+function nodeIndex(nodes) {
+	const result = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const walk = (siblings, parent) => {
+		if (!Array.isArray(siblings)) throw new Error("Expected containment children");
+		for (const node of siblings) {
+			if (!node || !isRecord(node.data) || seen.has(node)) throw new Error("Invalid or cyclic containment");
+			seen.add(node);
+			if (result.has(node.data.entityId)) throw new Error(`Duplicate containment: ${node.data.entityId}`);
+			result.set(node.data.entityId, {
+				node,
+				siblings,
+				parent
+			});
+			walk(node.children ?? [], node);
+		}
+	};
+	walk(nodes);
+	return result;
+}
+function applyPatch(target, patch) {
+	for (const [key, value] of Object.entries(patch)) if (value === void 0) delete target[key];
+	else if (isRecord(value)) {
+		if (!isRecord(target[key])) target[key] = {};
+		applyPatch(target[key], value);
+	} else target[key] = value;
+}
+/** The draft tree as plain nodes, for the DSL's containment constraints. */
+function plainTree(nodes) {
+	return nodes.map((node) => ({
+		entityId: node.data.entityId,
+		children: plainTree(node.children ?? [])
+	}));
+}
+function changeTree(nodes, mutation, rows) {
+	const index = nodeIndex(nodes);
+	assertContainChange(rows, plainTree(nodes), mutation);
+	const current = index.get(mutation.entityId);
+	if (current) current.siblings.splice(current.siblings.indexOf(current.node), 1);
+	if (mutation.type === "delete-node") return;
+	const parent = mutation.parentId === void 0 ? void 0 : index.get(mutation.parentId);
+	const siblings = parent ? parent.node.children ??= [] : nodes;
+	siblings.splice(mutation.index ?? siblings.length, 0, current?.node ?? {
+		data: { entityId: mutation.entityId },
+		children: []
+	});
+}
+//#endregion
+//#region src/dsl/document/mutations.ts
+/** Mutations are a convenience vocabulary over the same guarded draft and native command queue. */
+function applyMutations(tx, mutations) {
+	const rows = tx.draft;
+	for (const m of mutations) {
+		if ("id" in m) assertId(m.id);
+		switch (m.type) {
+			case "create-entity": {
+				assertEntity(m.table, m.value);
+				const old = rows[m.table][m.id];
+				if (old && ![
+					"media-entities",
+					"voice-entities",
+					"asset-entities"
+				].includes(m.table)) throw new Error(`Entity already exists: ${m.id}`);
+				if (old) {
+					assertEntityPatch(m.table, m.value, old);
+					applyPatch(old, m.value);
+				} else rows[m.table][m.id] = m.value;
+				break;
+			}
+			case "patch-entity": {
+				const current = rows[m.table][m.id];
+				if (!current) throw new Error(`Missing entity: ${m.id}`);
+				assertEntityPatch(m.table, m.patch, current);
+				if (m.table === "clip-entities" && Object.hasOwn(m.patch, "seqMarker")) {
+					const { seqMarker, ...rest } = m.patch;
+					current.seqMarker = mergeFields(current.seqMarker, seqMarker ?? {});
+					applyPatch(current, rest);
+				} else applyPatch(current, m.patch);
+				break;
+			}
+			case "delete-entity":
+				delete rows[m.table][m.id];
+				break;
+			case "set-relation": {
+				assertRelation(m.table, m.value);
+				const id = relationId(m.table, m.value);
+				if (m.table === "time-anchor-relations" || m.table === "caption-content-relations") tx.draft[m.table][id] = m.value;
+				else {
+					rows[m.table][id] ??= {};
+					applyPatch(rows[m.table][id], m.value);
+				}
+				break;
+			}
+			case "delete-relation":
+				delete rows[m.table][m.id];
+				break;
+			case "edit-text":
+				tx.editText(m.audioScriptId, m.edits, m.expectedBodyId);
+				break;
+			case "edit-caption-text":
+				tx.editCaptionText(m.captionId, m.edits, m.expectedBodyId);
+				break;
+			case "set-caption-content":
+				tx.setCaptionContent(m);
+				break;
+			default: changeTree(tx.draft["contain-relations"], m, tx.draft);
+		}
+	}
+}
+//#endregion
+//#region src/dsl/document/native-text.ts
+function applyTextEdits(text, edits) {
+	for (const edit of edits) switch (edit.type) {
+		case "insert":
+			text.insert(edit.at, edit.text);
+			break;
+		case "delete":
+			text.delete(edit.at, edit.length);
+			break;
+		case "mark":
+			if (edit.key === "pauseMs" && edit.value === 0) text.unmark({
+				start: edit.start,
+				end: edit.end
+			}, edit.key);
+			else text.mark({
+				start: edit.start,
+				end: edit.end
+			}, edit.key, edit.value);
+			break;
+		case "unmark":
+			text.unmark({
+				start: edit.start,
+				end: edit.end
+			}, edit.key);
+			break;
+		case "delta":
+			text.applyDelta(edit.delta);
+			break;
+	}
+}
+//#endregion
+//#region src/dsl/document/validation.ts
+/** One relation row by the DSL's rules; caption content must also resolve in the live body. */
+function validateRelation(doc, state, table, id, value) {
+	assertRelationAdmitted(state, table, id, value);
+	if (table !== "caption-content-relations") return;
+	const resolved = resolveContent(doc, value);
+	if (!resolved || resolved.start === resolved.end) throw new Error("Expected a nonempty range in the current body");
+	captionContentCodec.encode(value);
+}
+/**
+* The DSL's admission of the whole draft, then what only this document can check: containment
+* nodes keep their Tree identities, and Mirror cannot yet move a node under a parent it creates.
+*/
+function validateDraft(tracked) {
+	const state = tracked.raw, before = tracked.before;
+	assertChangeAdmitted({
+		before,
+		after: state,
+		entities: tracked.entities,
+		relations: tracked.relations
+	});
+	if (!tracked.treeChanged) return;
+	const oldNodes = nodeIndex(before["contain-relations"] ?? []);
+	const nodes = state["contain-relations"] ?? [];
+	for (const [entityId, { node, parent }] of nodeIndex(nodes)) {
+		assertId(entityId);
+		if (Object.keys(node).some((k) => ![
+			"id",
+			"data",
+			"children"
+		].includes(k)) || Object.keys(node.data).some((k) => k !== "entityId")) throw new Error("Unknown containment field");
+		const old = oldNodes.get(entityId)?.node;
+		if (old && node.id !== old.id || !old && node.id !== void 0) throw new Error("Containment identity cannot be changed");
+		if (node.id && parent && !parent.id) throw new Error("Moving an existing node into a new parent requires a native Action");
+	}
+	assertContainTree(state, plainTree(nodes));
+}
+//#endregion
+//#region src/dsl/document/transact.ts
+/** Serialization happens before preparing any writes, so invalid/cyclic audit data cannot partly commit. */
+function auditOptions(audit) {
+	if (!audit || typeof audit.semantic_op !== "string" || !audit.semantic_op.length || !Object.hasOwn(audit, "payload")) throw new Error("A structured DSL audit is required");
+	if (audit.actor != null && (typeof audit.actor.user_id !== "string" || !audit.actor.user_id.length || !["user", "agent"].includes(audit.actor.role))) throw new Error("Invalid audit actor");
+	return {
+		origin: "mengine.semantic_editor",
+		message: JSON.stringify({
+			semantic_op: audit.semantic_op,
+			payload: audit.payload ?? null,
+			intent: audit.intent ?? null,
+			actor: audit.actor ?? null
+		})
+	};
+}
+/** The only bridge from a prepared DSL edit to Mirror's single native commit. */
+function runTransaction(doc, mirror, edit, options, setReject) {
+	const steps = [];
+	const newCaptionTexts = /* @__PURE__ */ new Map();
+	const bodies = /* @__PURE__ */ new Map();
+	const before = mirror.getState();
+	mirror.setState((raw) => {
+		const tracked = new TransactionDraft(raw, before);
+		setReject((error) => tracked.fail(error));
+		const useBody = (scriptId, caption = false) => {
+			assertId(scriptId);
+			const entity = requireEntity(tracked.draft, caption ? "caption-entities" : "audio-script-entities", scriptId);
+			if (tracked.deleted.has(scriptId)) throw new Error("Cannot use a deleted body");
+			const body = entity[caption ? "text" : "body"];
+			if (typeof body !== "string") throw new Error("Missing Text body");
+			if (caption && tracked.removedCaptionTexts.has(scriptId)) throw new Error("Cannot edit a removed Text");
+			tracked.textPreviews.set(scriptId, body);
+			return body;
+		};
+		const flushCaptions = () => {
+			for (const id of tracked.dirtyCaptions) {
+				const value = raw["caption-content-relations"][id];
+				if (value !== void 0) {
+					validateRelation(doc, raw, "caption-content-relations", id, value);
+					useBody(value.audioScriptId);
+				}
+				steps.push({
+					type: "caption",
+					id,
+					value: copyInput(value)
+				});
+			}
+			tracked.dirtyCaptions.clear();
+		};
+		const editBody = (scriptId, edits, expectedBodyId, caption) => {
+			tracked.run(() => {
+				flushCaptions();
+				const body = useBody(scriptId, caption);
+				if (!bodies.has(scriptId)) bodies.set(scriptId, liveText(doc, scriptId, caption));
+				const native = bodies.get(scriptId);
+				if (expectedBodyId !== void 0 && native?.id !== expectedBodyId) throw new Error("Stale or missing Text body");
+				if ((caption ? before["caption-entities"][scriptId]?.text : before["audio-script-entities"][scriptId]?.body) !== void 0 && !native) throw new Error("Missing live Text body");
+				const prepared = prepareTextEdits(body, copyInput(edits));
+				tracked.textPreviews.set(scriptId, prepared.body);
+				steps.push({
+					type: "text",
+					scriptId,
+					caption,
+					expectedBodyId: native?.id,
+					edits: prepared.edits
+				});
+			});
+		};
+		const tx = Object.freeze({
+			get draft() {
+				return tracked.run(() => tracked.draft);
+			},
+			applyMutations(mutations) {
+				tracked.run(() => applyMutations(tx, mutations));
+			},
+			editText(scriptId, edits, expectedBodyId) {
+				editBody(scriptId, edits, expectedBodyId, false);
+			},
+			editCaptionText(captionId, edits, expectedBodyId) {
+				editBody(captionId, edits, expectedBodyId, true);
+			},
+			setCaptionContent(selection) {
+				tracked.run(() => {
+					flushCaptions();
+					const { captionId, audioScriptId, start, end } = selection;
+					assertId(captionId);
+					assertCaptionEndpoints(raw, selection);
+					assertCaptionSelection(raw, selection, useBody(audioScriptId));
+					steps.push({
+						type: "range",
+						selection: {
+							captionId,
+							audioScriptId,
+							start,
+							end
+						}
+					});
+				});
+			}
+		});
+		try {
+			tracked.run(() => {
+				if (Object.prototype.toString.call(edit) === "[object AsyncFunction]") throw new Error("DSL transact must be synchronous");
+				const result = edit(tx);
+				if (result && typeof result === "object" && "then" in result) {
+					Promise.resolve(result).catch(() => {});
+					throw new Error("DSL transact must be synchronous");
+				}
+				tracked.assertValid();
+				if (doc.getPendingTxnLength()) throw new Error("Native writes are not allowed during transaction preparation");
+				flushCaptions();
+				for (const id of tracked.entities.get("caption-entities")?.keys() ?? []) {
+					const caption = tracked.draft["caption-entities"][id];
+					if (caption) caption.style ??= {};
+				}
+				validateDraft(tracked);
+				for (const step of steps) if (step.type === "text") requireEntity(raw, step.caption ? "caption-entities" : "audio-script-entities", step.scriptId);
+				const referenceIds = new Set(Object.keys(raw["caption-content-relations"]).map((id) => id.slice(3)));
+				const changedCaptions = /* @__PURE__ */ new Set();
+				for (const [id, fields] of tracked.entities.get("caption-entities") ?? []) if (fields.has("text")) changedCaptions.add(id);
+				for (const step of steps) {
+					if (step.type === "range") {
+						referenceIds.add(step.selection.captionId);
+						changedCaptions.add(step.selection.captionId);
+					}
+					if (step.type === "caption") {
+						const id = step.id.slice(3);
+						changedCaptions.add(id);
+						if (step.value) referenceIds.add(id);
+						else referenceIds.delete(id);
+					}
+					if (step.type === "text" && step.caption) changedCaptions.add(step.scriptId);
+				}
+				for (const id of changedCaptions) assertCaptionSource(raw["caption-entities"][id], referenceIds.has(id));
+				for (const step of steps) if (step.type === "range") assertCaptionEndpoints(raw, step.selection);
+				else if (step.type === "caption" && step.value) assertCaptionEndpoints(raw, step.value);
+				for (const [id, fields] of tracked.entities.get("caption-entities") ?? []) {
+					const row = raw["caption-entities"][id];
+					if (fields.has("text") && row?.text !== void 0 && before["caption-entities"][id]?.text === void 0) {
+						newCaptionTexts.set(id, row.text);
+						delete row.text;
+					}
+				}
+				for (const id of tracked.relations.get("caption-content-relations") ?? []) if (before["caption-content-relations"][id] === void 0) delete raw["caption-content-relations"][id];
+				else raw["caption-content-relations"][id] = before["caption-content-relations"][id];
+			});
+		} finally {
+			tracked.close();
+			setReject(void 0);
+		}
+	}, {
+		...options,
+		applyNative: (doc) => {
+			const bodyFor = (scriptId, caption = false) => {
+				let text = bodies.get(scriptId);
+				if (!text) {
+					text = liveText(doc, scriptId, caption);
+					bodies.set(scriptId, text);
+				}
+				if (!text || text.isDeleted()) throw new Error("Prepared Text body is missing");
+				return text;
+			};
+			for (const [id, value] of newCaptionTexts) {
+				const body = doc.getMap("caption-entities").get(id).setContainer("text", new LoroText());
+				if (value.length) body.insert(0, value);
+				bodies.set(id, body);
+			}
+			for (const step of steps) if (step.type === "text") {
+				const text = bodyFor(step.scriptId, step.caption);
+				if (step.expectedBodyId && text.id !== step.expectedBodyId) throw new Error("Stale Text body");
+				applyTextEdits(text, step.edits);
+			} else if (step.type === "range") {
+				const { captionId, audioScriptId, start, end } = step.selection;
+				const text = bodyFor(audioScriptId);
+				const from = text?.getCursor(start, 0), to = text?.getCursor(end, 0);
+				if (!from || !to) throw new Error("Unable to construct prepared range");
+				doc.getMap("caption-content-relations").set(`cc:${captionId}`, captionContentCodec.encode({
+					captionId,
+					audioScriptId,
+					start: from,
+					end: to
+				}));
+			} else {
+				const relations = doc.getMap("caption-content-relations");
+				if (step.value === void 0) {
+					if (relations.get(step.id) !== void 0) relations.delete(step.id);
+				} else relations.set(step.id, captionContentCodec.encode(step.value));
+			}
+		}
+	});
+}
+//#endregion
+//#region src/dsl/document/medeo-dsl.ts
+const contentRoots = new Set([
+	...entityTables,
+	...relationTables,
+	"contain-relations"
+]);
+/** One live DSL document. Business Actions belong to medeo-client, not this storage interface. */
+var MedeoDsl = class MedeoDsl {
+	doc;
+	options;
+	disposed = false;
+	writing = false;
+	rejectTransaction;
+	listeners = /* @__PURE__ */ new Set();
+	changeSource = "remote";
+	snapshot;
+	dirty = false;
+	notifying = false;
+	mirror;
+	unsubscribe;
+	ownsDoc = false;
+	/** Opens a borrowed LoroDoc; dispose releases subscriptions but does not free the caller's doc. */
+	constructor(doc, options = {}) {
+		this.doc = doc;
+		this.options = options;
+		const roots = doc.getShallowValue();
+		if ([
+			"medeo",
+			"timeline",
+			"tracks",
+			"part_library"
+		].some((key) => Object.hasOwn(roots, key))) throw new Error("Expected a new DSL document, not a legacy content model");
+		doc.configTextStyle(textStyles);
+		this.mirror = new Mirror({
+			doc,
+			schema: medeoDslLoroShape,
+			validateUpdates: false,
+			ignoreUnknownProperties: true
+		});
+		this.unsubscribe = doc.subscribe((event) => {
+			if (!event.events.some((change) => contentRoots.has(String(change.path[0])))) return;
+			this.snapshot = void 0;
+			this.changeSource = event.by === "local" ? "local" : "remote";
+			this.dirty = true;
+			if (!this.writing) this.notify();
+		});
+	}
+	/** Creates and owns a fresh document; this handle frees it on dispose. */
+	static create(options = {}) {
+		const doc = new LoroDoc();
+		if (options.peerId !== void 0) doc.setPeerId(options.peerId);
+		const dsl = new MedeoDsl(doc);
+		dsl.ownsDoc = true;
+		try {
+			dsl.mutate(() => runTransaction(doc, dsl.mirror, (tx) => tx.applyMutations([{
+				type: "create-entity",
+				table: "timeline-entities",
+				id: options.timelineId ?? (options.idFactory ?? defaultIdFactory)("timeline"),
+				value: {}
+			}]), { origin: "medeo.dsl.initialize" }, (reject) => {
+				dsl.rejectTransaction = reject;
+			}));
+			return dsl;
+		} catch (error) {
+			dsl.dispose();
+			throw error;
+		}
+	}
+	getSnapshot() {
+		this.assertActive();
+		return this.snapshot ??= readMedeoDsl(this.doc, this.mirror.getState());
+	}
+	subscribe(listener) {
+		this.assertActive();
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	/** One synchronous, audited edit. Preparation errors discard the whole draft before native writes. */
+	transact(edit, audit) {
+		this.mutate(() => runTransaction(this.doc, this.mirror, edit, auditOptions(audit), (reject) => {
+			this.rejectTransaction = reject;
+		}));
+	}
+	/** Preferred vocabulary for ordinary entity/relation/Tree edits and serializable native commands. */
+	applyMutations(mutations, audit) {
+		this.transact((tx) => tx.applyMutations(mutations), audit);
+	}
+	editText(scriptId, expectedBodyId, edits, audit) {
+		this.transact((tx) => tx.editText(scriptId, edits, expectedBodyId), audit);
+	}
+	editCaptionText(captionId, expectedBodyId, edits, audit) {
+		this.transact((tx) => tx.editCaptionText(captionId, edits, expectedBodyId), audit);
+	}
+	/** Local ranges exclude insertions at their start and include insertions at their end. K01 remains deferred. */
+	textRange(scriptId, start, end) {
+		this.assertActive();
+		const text = liveText(this.doc, scriptId);
+		if (!text) throw new Error("Missing AudioScript body");
+		assertTextOffset(text.toString(), start);
+		assertTextOffset(text.toString(), end);
+		if (start >= end) throw new Error("Expected a nonempty range");
+		const from = text.getCursor(start, 0), to = text.getCursor(end, 0);
+		if (!from || !to) throw new Error("Unable to construct text range");
+		return {
+			audioScriptId: scriptId,
+			start: from,
+			end: to
+		};
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.unsubscribe();
+		this.mirror.dispose();
+		this.listeners.clear();
+		if (this.ownsDoc) this.doc.free();
+	}
+	mutate(run) {
+		this.assertActive();
+		if (this.writing || this.notifying) {
+			const error = /* @__PURE__ */ new Error("A DSL mutation is already running");
+			this.rejectTransaction?.(error);
+			throw error;
+		}
+		if (this.doc.getPendingTxnLength() !== 0) throw new Error("Commit external native edits before a DSL mutation");
+		const apply = () => {
+			this.writing = true;
+			try {
+				run();
+			} finally {
+				this.rejectTransaction = void 0;
+				this.writing = false;
+				if (this.dirty) this.snapshot = void 0;
+				this.notify();
+			}
+		};
+		if (this.options.mutationGuard) this.options.mutationGuard.run(apply);
+		else apply();
+	}
+	notify() {
+		if (this.disposed || !this.dirty) return;
+		this.dirty = false;
+		this.notifying = true;
+		try {
+			for (const listener of this.listeners) listener(this.changeSource);
+		} finally {
+			this.notifying = false;
+		}
+	}
+	assertActive() {
+		if (this.disposed) throw new Error("MedeoDsl is disposed");
+	}
+};
+//#endregion
+//#region src/dsl/voiceover-actions.ts
+function voiceoverPlan(s, input, result) {
+	if (requireTrack(s, input.trackId).role !== "speech" || input.media.kind !== "voiceover-recording") throw new Error("Voiceover requires a speech Track and a recording");
+	if (input.captions.length && (!input.captionTrackId || requireTrack(s, input.captionTrackId).role !== "caption")) throw new Error("Caption Track is required");
+	const existing = s["clip-entities"][result.clipId];
+	if (existing && requireTrack(s, trackOf(s, result.clipId)).role !== "speech") throw new Error("Expected a speech Clip");
+	const mutations = [{
+		type: "create-entity",
+		table: "media-entities",
+		id: result.mediaId,
+		value: input.media
+	}];
+	if (input.script.body !== void 0) mutations.push({
+		type: "create-entity",
+		table: "audio-script-entities",
+		id: result.audioScriptId,
+		value: {
+			body: input.script.body,
+			..."defaultLanguage" in input.script && input.script.defaultLanguage !== void 0 ? { defaultLanguage: input.script.defaultLanguage } : {}
+		}
+	});
+	else if (!s["audio-script-entities"][result.audioScriptId]) throw new Error("Missing AudioScript");
+	validateWindow({
+		inMs: 0,
+		outMs: input.media.durationMs
+	}, input.media.durationMs);
+	mutations.push({
+		type: "set-relation",
+		table: "derived-from-relations",
+		value: {
+			entityId: result.mediaId,
+			sourceId: result.audioScriptId
+		}
+	});
+	if (input.voice) {
+		const id = resourceId("voice", input.voice.system, input.voice.key);
+		mutations.push({
+			type: "create-entity",
+			table: "voice-entities",
+			id,
+			value: input.voice
+		}, {
+			type: "set-relation",
+			table: "voice-timbre-relations",
+			value: {
+				recordingId: result.mediaId,
+				voiceId: id
+			}
+		});
+	}
+	mutations.push(existing ? {
+		type: "patch-entity",
+		table: "clip-entities",
+		id: result.clipId,
+		patch: {
+			seqMarker: {
+				inMs: 0,
+				outMs: input.media.durationMs,
+				rate: void 0,
+				fillTimeline: void 0
+			},
+			...input.volume === void 0 ? {} : { volume: input.volume }
+		}
+	} : {
+		type: "create-entity",
+		table: "clip-entities",
+		id: result.clipId,
+		value: {
+			seqMarker: {
+				inMs: 0,
+				outMs: input.media.durationMs
+			},
+			...input.volume === void 0 ? {} : { volume: input.volume }
+		}
+	}, {
+		type: "set-relation",
+		table: "clip-source-relations",
+		value: {
+			clipId: result.clipId,
+			sourceId: result.mediaId
+		}
+	});
+	if (!existing || trackOf(s, result.clipId) !== input.trackId) mutations.push({
+		type: existing ? "move-node" : "insert-node",
+		entityId: result.clipId,
+		parentId: input.trackId
+	});
+	mutations.push(...placementMutations(s, result.clipId, input.placement));
+	uniqueIds(result.captionClipIds);
+	const retained = new Set(result.captionClipIds);
+	const oldCaptions = Object.values(s["time-anchor-relations"]).filter((r) => r.to === result.clipId && s["clip-entities"][r.from] && requireTrack(s, trackOf(s, r.from)).role === "caption").map((r) => r.from);
+	mutations.push(...deleteClips(s, oldCaptions.filter((id) => !retained.has(id)), "cascade"));
+	const anchor = mutations.find((m) => m.type === "set-relation" && m.table === "time-anchor-relations" && m.value.from === result.clipId);
+	const trackClips = resolveDslLayout(s).tracks.find((track) => track.trackId === input.trackId).clips;
+	const slot = trackClips.findIndex((clip) => clip.clipId === result.clipId);
+	const predecessor = trackClips.slice(0, slot < 0 ? trackClips.length : slot).findLast((clip) => clip.mode === "sequential" && !clip.fillTimeline);
+	const speechStart = anchor?.type === "set-relation" && anchor.table === "time-anchor-relations" ? anchor.value.fallback_abs_ms : predecessor ? predecessor.startMs + predecessor.durationMs : 0;
+	input.captions.forEach((caption, i) => {
+		const clipId = result.captionClipIds[i], captionId = result.captionIds[i];
+		validateWindow({
+			inMs: caption.startMs,
+			outMs: caption.startMs + caption.durationMs
+		}, input.media.durationMs);
+		const previous = s["clip-entities"][clipId];
+		if (previous && !oldCaptions.includes(clipId)) throw new Error("Cannot overwrite another use’s Caption Clip");
+		const previousSource = s["clip-source-relations"][`cs:${clipId}`]?.sourceId;
+		const style = caption.style ?? (previousSource ? s["caption-entities"][previousSource]?.style : void 0);
+		mutations.push({
+			type: "create-entity",
+			table: "caption-entities",
+			id: captionId,
+			value: style ? { style } : {}
+		}, {
+			type: "set-caption-content",
+			captionId,
+			audioScriptId: result.audioScriptId,
+			start: caption.range.start,
+			end: caption.range.end
+		}, {
+			type: "set-relation",
+			table: "caption-alignment-relations",
+			value: {
+				captionId,
+				mediaId: result.mediaId,
+				startMs: caption.startMs,
+				endMs: caption.startMs + caption.durationMs
+			}
+		}, previous ? {
+			type: "patch-entity",
+			table: "clip-entities",
+			id: clipId,
+			patch: { seqMarker: {
+				inMs: 0,
+				outMs: caption.durationMs
+			} }
+		} : {
+			type: "create-entity",
+			table: "clip-entities",
+			id: clipId,
+			value: { seqMarker: {
+				inMs: 0,
+				outMs: caption.durationMs
+			} }
+		}, {
+			type: "set-relation",
+			table: "clip-source-relations",
+			value: {
+				clipId,
+				sourceId: captionId
+			}
+		}, {
+			type: "set-relation",
+			table: "time-anchor-relations",
+			value: {
+				from: clipId,
+				to: result.clipId,
+				offsetMs: caption.startMs,
+				fallback_abs_ms: speechStart + caption.startMs
+			}
+		});
+		if (!previous || trackOf(s, clipId) !== input.captionTrackId) mutations.push({
+			type: previous ? "move-node" : "insert-node",
+			entityId: clipId,
+			parentId: input.captionTrackId
+		});
+	});
+	return mutations;
+}
+//#endregion
+//#region src/dsl/dsl-editor.ts
+/** Business edits write DSL facts in one audited transaction; layout is derived on read. */
+var DslEditor = class {
+	dsl;
+	idFactory;
+	constructor(dsl, idFactory = defaultIdFactory) {
+		this.dsl = dsl;
+		this.idFactory = idFactory;
+	}
+	createTrack(role, options) {
+		const id = this.idFactory("track");
+		this.write("createTrack", {
+			id,
+			role
+		}, [{
+			type: "create-entity",
+			table: "track-entities",
+			id,
+			value: { role }
+		}, {
+			type: "insert-node",
+			entityId: id
+		}], options);
+		return id;
+	}
+	registerMedia(media, options) {
+		const id = resourceId("media", media.system, media.key);
+		this.write("registerMedia", {
+			id,
+			media
+		}, [{
+			type: "create-entity",
+			table: "media-entities",
+			id,
+			value: media
+		}], options);
+		return id;
+	}
+	addClips(input, options) {
+		const ids = input.clips.map(() => this.idFactory("clip"));
+		this.write("addClips", {
+			...input,
+			ids
+		}, addClipsPlan(this.dsl.getSnapshot(), input, ids), options);
+		return ids;
+	}
+	/** index is measured in the target's children after removing the moved Clip. */
+	moveClip(clipId, trackId, index, options) {
+		const snapshot = this.dsl.getSnapshot();
+		requireClip(snapshot, clipId);
+		const track = snapshot["track-entities"][trackId];
+		const source = snapshot["clip-source-relations"][`cs:${clipId}`];
+		if (!track || !source) throw new Error("Missing target Track or Clip source");
+		requireSource(snapshot, source.sourceId, track.role);
+		this.write("moveClip", {
+			clipId,
+			trackId,
+			index
+		}, [{
+			type: "move-node",
+			entityId: clipId,
+			parentId: trackId,
+			index
+		}], options);
+	}
+	trimClip(clipId, window, options) {
+		const snapshot = this.dsl.getSnapshot(), clip = requireClip(snapshot, clipId);
+		if (clip.seqMarker.fillTimeline) throw new Error("BGM trim is not enabled");
+		const sourceId = snapshot["clip-source-relations"][`cs:${clipId}`]?.sourceId;
+		const source = sourceId ? snapshot["media-entities"][sourceId] ?? snapshot["caption-entities"][sourceId] : void 0;
+		if (!source) throw new Error("Cannot trim a Clip with a missing source");
+		const patch = {};
+		if (window.inMs !== void 0) patch.inMs = window.inMs;
+		if (window.outMs !== void 0) patch.outMs = window.outMs;
+		validateWindow({
+			...clip.seqMarker,
+			...patch
+		}, "durationMs" in source ? source.durationMs : void 0);
+		this.write("trimClip", {
+			clipId,
+			window: patch
+		}, [{
+			type: "patch-entity",
+			table: "clip-entities",
+			id: clipId,
+			patch: { seqMarker: patch }
+		}], options);
+	}
+	setClipSpeed(clipId, speed, options) {
+		if (requireClip(this.dsl.getSnapshot(), clipId).seqMarker.fillTimeline) throw new Error("BGM speed is not enabled");
+		this.write("setClipSpeed", {
+			clipId,
+			speed: speed ?? null
+		}, [{
+			type: "patch-entity",
+			table: "clip-entities",
+			id: clipId,
+			patch: { seqMarker: { rate: speed?.rate } }
+		}], options);
+	}
+	setClipVolume(clipId, volume, options) {
+		requireClip(this.dsl.getSnapshot(), clipId);
+		this.write("setClipVolume", {
+			clipId,
+			volume: volume ?? null
+		}, [{
+			type: "patch-entity",
+			table: "clip-entities",
+			id: clipId,
+			patch: { volume }
+		}], options);
+	}
+	createAudioScript(body, defaultLanguage, options) {
+		const id = this.idFactory("audio-script");
+		this.write("createAudioScript", {
+			id,
+			body,
+			defaultLanguage
+		}, [{
+			type: "create-entity",
+			table: "audio-script-entities",
+			id,
+			value: {
+				body,
+				...defaultLanguage === void 0 ? {} : { defaultLanguage }
+			}
+		}], options);
+		return id;
+	}
+	editAudioScript(scriptId, expectedBodyId, edits, options) {
+		this.dsl.editText(scriptId, expectedBodyId, edits, audit("editAudioScript", {
+			scriptId,
+			expectedBodyId,
+			edits
+		}, options));
+	}
+	createCaption(input, options) {
+		const id = this.idFactory("caption");
+		this.write("createCaption", {
+			id,
+			...input
+		}, [{
+			type: "create-entity",
+			table: "caption-entities",
+			id,
+			value: {
+				...input.style === void 0 ? {} : { style: input.style },
+				...input.text === void 0 ? {} : { text: input.text }
+			}
+		}, ...input.text !== void 0 ? [] : [{
+			type: "set-caption-content",
+			captionId: id,
+			audioScriptId: input.audioScriptId,
+			start: input.start,
+			end: input.end
+		}]], options);
+		return id;
+	}
+	setCaptionContent(captionId, audioScriptId, start, end, options) {
+		this.write("setCaptionContent", {
+			captionId,
+			audioScriptId,
+			start,
+			end
+		}, [{
+			type: "patch-entity",
+			table: "caption-entities",
+			id: captionId,
+			patch: { text: void 0 }
+		}, {
+			type: "set-caption-content",
+			captionId,
+			audioScriptId,
+			start,
+			end
+		}], options);
+	}
+	setCaptionText(captionId, text, options) {
+		const caption = this.dsl.getSnapshot()["caption-entities"][captionId];
+		if (!caption) throw new Error("Missing Caption");
+		this.dsl.transact((tx) => {
+			tx.applyMutations([{
+				type: "delete-relation",
+				table: "caption-content-relations",
+				id: `cc:${captionId}`
+			}]);
+			if (caption.text === void 0) tx.draft["caption-entities"][captionId].text = text;
+			else if (caption.text !== text) tx.editCaptionText(captionId, [...caption.text.length ? [{
+				type: "delete",
+				at: 0,
+				length: caption.text.length
+			}] : [], ...text.length ? [{
+				type: "insert",
+				at: 0,
+				text
+			}] : []]);
+		}, audit("setCaptionText", {
+			captionId,
+			text
+		}, options));
+	}
+	editCaptionText(captionId, expectedBodyId, edits, options) {
+		this.dsl.editCaptionText(captionId, expectedBodyId, edits, audit("editCaptionText", {
+			captionId,
+			expectedBodyId,
+			edits
+		}, options));
+	}
+	moveTrack(trackId, index, options) {
+		requireTrack(this.dsl.getSnapshot(), trackId);
+		this.write("moveTrack", {
+			trackId,
+			index
+		}, [{
+			type: "move-node",
+			entityId: trackId,
+			index
+		}], options);
+	}
+	setTrackHidden(trackId, hidden, options) {
+		requireTrack(this.dsl.getSnapshot(), trackId);
+		this.write("setTrackHidden", {
+			trackId,
+			hidden: hidden ?? null
+		}, [{
+			type: "patch-entity",
+			table: "track-entities",
+			id: trackId,
+			patch: { hidden }
+		}], options);
+	}
+	deleteTrack(trackId, onAnchored, options) {
+		const s = this.dsl.getSnapshot();
+		this.write("deleteTrack", {
+			trackId,
+			onAnchored
+		}, [
+			...deleteClips(s, children(s, trackId), onAnchored),
+			{
+				type: "delete-node",
+				entityId: trackId
+			},
+			{
+				type: "delete-entity",
+				table: "track-entities",
+				id: trackId
+			}
+		], options);
+	}
+	setClipPlacement(clipId, placement, options) {
+		const s = this.dsl.getSnapshot();
+		trackOf(s, clipId);
+		this.write("setClipPlacement", {
+			clipId,
+			placement
+		}, placementMutations(s, clipId, placement), options);
+	}
+	moveClips(input, options) {
+		this.write("moveClips", input, moveClipsPlan(this.dsl.getSnapshot(), input), options);
+	}
+	deleteClips(clipIds, onAnchored, options) {
+		this.write("deleteClips", {
+			clipIds,
+			onAnchored
+		}, deleteClips(this.dsl.getSnapshot(), clipIds, onAnchored), options);
+	}
+	replaceClipSource(clipId, input, options) {
+		this.write("replaceClipSource", {
+			clipId,
+			...input
+		}, replaceSourcePlan(this.dsl.getSnapshot(), clipId, input), options);
+	}
+	replaceClips(input, options) {
+		const ids = input.clips.map(() => this.idFactory("clip"));
+		this.write("replaceClips", {
+			...input,
+			ids
+		}, replaceSequencePlan(this.dsl.getSnapshot(), input, ids), options);
+		return ids;
+	}
+	updateClips(updates, options) {
+		this.write("updateClips", { updates }, updateClipsPlan(this.dsl.getSnapshot(), updates), options);
+	}
+	patchCaptionStyle(captionIds, patch, options) {
+		this.write("patchCaptionStyle", {
+			captionIds,
+			patch
+		}, captionIds.map((id) => ({
+			type: "patch-entity",
+			table: "caption-entities",
+			id,
+			patch: { style: patch }
+		})), options);
+	}
+	applyVoiceover(input, options) {
+		const result = {
+			clipId: input.clipId ?? this.idFactory("clip"),
+			mediaId: resourceId("media", input.media.system, input.media.key),
+			audioScriptId: input.script.audioScriptId ?? this.idFactory("audio-script"),
+			captionClipIds: input.captions.map((c) => c.clipId ?? this.idFactory("clip")),
+			captionIds: input.captions.map(() => this.idFactory("caption"))
+		};
+		this.write("applyVoiceover", {
+			input,
+			result
+		}, voiceoverPlan(this.dsl.getSnapshot(), input, result), options);
+		return result;
+	}
+	setBgm(input, options) {
+		const s = this.dsl.getSnapshot();
+		if (requireTrack(s, input.trackId).role !== "bgm") throw new Error("Expected a BGM Track");
+		const id = input.clipId ?? this.idFactory("clip");
+		const old = s["clip-entities"][id];
+		if (old && trackOf(s, id) !== input.trackId) throw new Error("BGM use belongs to another Track");
+		const source = sourcePlan(s, input, input.trackId);
+		if (!("durationMs" in source.source)) throw new Error("BGM requires full source duration");
+		validateWindow({
+			inMs: 0,
+			outMs: source.source.durationMs
+		}, source.source.durationMs);
+		const seqMarker = {
+			inMs: 0,
+			outMs: source.source.durationMs,
+			fillTimeline: true
+		};
+		const volume = input.volume === void 0 ? {} : { volume: input.volume };
+		const mutations = [
+			...source.mutations,
+			old ? {
+				type: "patch-entity",
+				table: "clip-entities",
+				id,
+				patch: {
+					seqMarker: {
+						...seqMarker,
+						rate: void 0
+					},
+					...volume
+				}
+			} : {
+				type: "create-entity",
+				table: "clip-entities",
+				id,
+				value: {
+					seqMarker,
+					...volume
+				}
+			},
+			{
+				type: "set-relation",
+				table: "clip-source-relations",
+				value: {
+					clipId: id,
+					sourceId: source.id
+				}
+			}
+		];
+		if (!old) mutations.push({
+			type: "insert-node",
+			entityId: id,
+			parentId: input.trackId
+		});
+		this.write("setBgm", {
+			...input,
+			clipId: id
+		}, mutations, options);
+		return id;
+	}
+	write(action, payload, mutations, options) {
+		this.dsl.applyMutations(mutations, audit(action, payload, options));
+	}
+};
+function audit(action, payload, options) {
+	return {
+		semantic_op: action,
+		payload: JSON.parse(JSON.stringify(payload, (_key, value) => value === void 0 ? null : value)),
+		intent: options?.intent ?? null,
+		actor: options?.actor ?? null
+	};
+}
+//#endregion
+//#region src/dsl/initial-document.ts
+/** One server/host creates the foundation; peers import its binary identity instead of initializing independently. */
+function createInitialMedeoDsl(options = {}) {
+	const dsl = MedeoDsl.create(options);
+	try {
+		const tracks = [
+			["caption_track", "caption"],
+			["main_track", "video_clip"],
+			["speech_track", "speech"],
+			["bgm_track", "bgm"]
+		];
+		dsl.applyMutations(tracks.flatMap(([id, role]) => [{
+			type: "create-entity",
+			table: "track-entities",
+			id,
+			value: { role }
+		}, {
+			type: "insert-node",
+			entityId: id
+		}]), {
+			semantic_op: "initializeDocument",
+			payload: { tracks: tracks.map(([id]) => id) }
+		});
+		return dsl;
+	} catch (error) {
+		dsl.dispose();
+		throw error;
+	}
+}
+//#endregion
+//#region src/dsl/projection/caption-style.ts
+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"
+};
+function toDraftStyle(style) {
+	if (style === void 0) return;
+	return {
+		...Object.fromEntries(Object.entries(fields).flatMap(([key, legacy]) => {
+			const value = style[key];
+			return value === void 0 ? [] : [[legacy, value]];
+		})),
+		...style.font ? { font_id: style.font.key } : {}
+	};
+}
+function fromDraftStyle(style) {
+	if (style === void 0) return;
+	return {
+		...Object.fromEntries(Object.entries(fields).flatMap(([key, legacy]) => {
+			const value = style[legacy];
+			return value === void 0 ? [] : [[key, value]];
+		})),
+		...style.font_id ? { font: {
+			system: "font-library",
+			key: style.font_id
+		} } : {}
+	};
+}
+//#endregion
+//#region src/dsl/projection/to-video-draft.ts
+/** A content read view, not an archive of authoring identities, rich-text marks or provenance. */
+function toVideoDraft(snapshot) {
+	const layout = resolveDslLayout(snapshot), diagnostics = [...layout.diagnostics];
+	const visual = layout.tracks.filter((t) => t.role === "video_clip");
+	if (visual.length > 1) projectionError("unsupported-visual-tracks", "contain-relations", "VideoDraft has only one main visual Track");
+	const parts = {};
+	const tracks = layout.tracks.map((track) => {
+		const items = [];
+		for (const clip of track.clips) {
+			if (!clip.durationMs) continue;
+			const path = `clip-entities/${clip.clipId}`, sourceId = clip.sourceId;
+			const source = snapshot["media-entities"][sourceId];
+			const fail = (message) => projectionError("unsupported-legacy-content", path, message);
+			const common = {
+				id: clip.clipId,
+				kind: track.role,
+				duration_ms: clip.durationMs
+			};
+			if (track.role === "video_clip") {
+				if (!source || !["image", "video"].includes(source.kind) || source.system !== "memota") fail("Visual playback requires a memota Image or Video");
+				if (clip.fillTimeline) fail("VideoDraft cannot express timeline-filling visual content");
+				parts[clip.clipId] = { video_clip: {
+					...common,
+					play_in: clip.inMs,
+					play_out: clip.outMs,
+					origin_media_id: source.key,
+					volume: clip.volume,
+					...snapshot["clip-entities"][clip.clipId].seqMarker.rate === void 0 ? {} : { speed_shift: {
+						category: "linear",
+						mode: void 0,
+						config: { linear: { speed: clip.rate } }
+					} }
+				} };
+			} else if (track.role === "speech") {
+				if (!source || source.kind !== "voiceover-recording" || source.system !== "memota-speech") fail("Legacy Speech requires a memota-speech VoiceoverRecording");
+				requireWholeAudio(source, clip, fail);
+				if (clip.fillTimeline) fail("Legacy Speech cannot express timeline fill");
+				const voices = Object.values(snapshot["voice-timbre-relations"]).filter((r) => r.recordingId === sourceId).flatMap((r) => snapshot["voice-entities"][r.voiceId] ? [snapshot["voice-entities"][r.voiceId]] : []);
+				if (voices.length > 1) diagnostics.push({
+					code: "multiple-voice-summary",
+					path,
+					message: "Multiple Voices retained in DSL; the singular legacy summary is omitted"
+				});
+				const voice = voices.length === 1 ? voices[0] : void 0;
+				const captionIds = layout.tracks.filter((t) => t.role === "caption").flatMap((t) => t.clips).filter((c) => c.durationMs > 0 && c.anchorClipId === clip.clipId).map((c) => c.clipId);
+				parts[clip.clipId] = { speech: {
+					...common,
+					media_duration_ms: source.durationMs,
+					audio_storage_key: source.storageKey,
+					origin_speech_id: source.key,
+					volume: clip.volume,
+					audio_script: spokenText(snapshot, sourceId),
+					voice: voice ? {
+						id: voice.key,
+						name: voice.name
+					} : void 0,
+					caption_ids: captionIds
+				} };
+			} else if (track.role === "caption") {
+				const caption = snapshot["caption-entities"][sourceId];
+				if (!caption) fail("Caption Track requires Caption content");
+				if (clip.fillTimeline) fail("Legacy Caption cannot express timeline fill");
+				const anchor = clip.anchorClipId ? layout.clips[clip.anchorClipId] : void 0;
+				const speechAnchor = anchor && layout.tracks.find((t) => t.trackId === anchor.trackId)?.role === "speech" && anchor.durationMs > 0 ? anchor : void 0;
+				parts[clip.clipId] = { caption: {
+					...common,
+					text: snapshot.captionText[sourceId]?.text ?? "",
+					speech_part_id: speechAnchor?.clipId,
+					start_ms: speechAnchor ? clip.startMs - speechAnchor.startMs : 0,
+					...caption.style === void 0 ? {} : { style: toDraftStyle(caption.style) }
+				} };
+			} else {
+				if (!source || source.kind !== "audio" || source.system !== "memota") fail("Legacy BGM requires memota Audio");
+				requireWholeAudio(source, clip, fail);
+				if (!clip.fillTimeline) fail("Legacy BGM requires explicit fillTimeline intent");
+				if (clip.startMs !== 0) diagnostics.push({
+					code: "legacy-consumer-bgm-start",
+					path,
+					message: "Some existing players ignore BGM start; the VideoDraft position is preserved"
+				});
+				parts[clip.clipId] = { bgm: {
+					...common,
+					audio_storage_key: source.storageKey,
+					origin_media_id: source.key,
+					volume: clip.volume
+				} };
+			}
+			items.push({
+				part_id: clip.clipId,
+				abs_time_position: clip.startMs
+			});
+		}
+		return {
+			id: track.trackId,
+			parts_kind: track.role,
+			is_hidden: track.hidden,
+			items
+		};
+	});
+	const aggregations = visual.flatMap((t) => t.clips).filter((c) => parts[c.clipId]).flatMap((host) => {
+		const attachments = layout.tracks.filter((t) => t.role === "speech").flatMap((t) => t.clips).filter((c) => c.anchorClipId === host.clipId && parts[c.clipId]).map((c) => ({
+			part_id: c.clipId,
+			relative_time_position: c.startMs - host.startMs
+		}));
+		return attachments.length ? [{
+			body_part_id: host.clipId,
+			attachments
+		}] : [];
+	});
+	for (const role of [
+		"caption",
+		"speech",
+		"bgm"
+	]) if (tracks.filter((t) => t.parts_kind === role).length > 1) diagnostics.push({
+		code: "legacy-consumer-multiple-tracks",
+		path: "contain-relations",
+		message: `All ${role} Tracks are preserved; some existing consumers read only the first`
+	});
+	return {
+		content: {
+			timeline: {
+				duration_ms: layout.durationMs,
+				unit_time_ms: DEFAULT_UNIT_TIME_MS
+			},
+			main_track: tracks.find((t) => t.parts_kind === "video_clip"),
+			above_main_tracks: tracks.filter((t) => t.parts_kind === "caption"),
+			below_main_tracks: tracks.filter((t) => t.parts_kind === "speech" || t.parts_kind === "bgm"),
+			part_library: parts,
+			part_aggregations: aggregations
+		},
+		diagnostics
+	};
+}
+function requireWholeAudio(media, clip, fail) {
+	if (media.kind === "image" || clip.inMs !== 0 || clip.outMs !== media.durationMs || clip.rate !== 1) fail("VideoDraft audio has no trim or speed fields");
+}
+function spokenText(snapshot, recordingId) {
+	const relations = Object.values(snapshot["derived-from-relations"]);
+	const scripts = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (seen.has(id)) return;
+		seen.add(id);
+		if (snapshot["audio-script-entities"][id]) {
+			scripts.add(id);
+			return;
+		}
+		for (const r of relations) if (r.entityId === id) visit(r.sourceId);
+	};
+	visit(recordingId);
+	if (!scripts.size) {
+		for (const r of relations) if (r.sourceId === recordingId && snapshot["audio-script-entities"][r.entityId]) scripts.add(r.entityId);
+	}
+	if (scripts.size > 1) projectionError("ambiguous-script", `media-entities/${recordingId}`, "Multiple scripts cannot be silently concatenated into audio_script");
+	const id = [...scripts][0];
+	return id ? snapshot.richText[id]?.plainText ?? "" : "";
+}
+//#endregion
+//#region src/dsl/projection/from-video-draft.ts
+/** One-time import into a newly owned document; never reverse-diff a live collaborative document. */
+function fromVideoDraft(input, options) {
+	const { timelineId, mutations, diagnostics } = prepare(input, options);
+	const dsl = MedeoDsl.create({
+		...options,
+		timelineId
+	});
+	try {
+		dsl.applyMutations(mutations, options.audit);
+		return {
+			dsl,
+			diagnostics
+		};
+	} catch (error) {
+		dsl.dispose();
+		throw error;
+	}
+}
+function prepare(input, options) {
+	const diagnostics = [], mutations = [];
+	const ids = /* @__PURE__ */ new Set(), mint = options.idFactory ?? defaultIdFactory;
+	const claim = (id) => {
+		try {
+			assertId(id);
+		} catch {
+			projectionError("invalid-id", id, "Expected a non-reserved entity ID");
+		}
+		if (ids.has(id)) projectionError("duplicate-id", id, "Entity identity appears more than once");
+		ids.add(id);
+		return id;
+	};
+	const timelineId = claim(options.timelineId ?? mint("timeline"));
+	const fail = (path, message) => projectionError("invalid-video-draft", path, message);
+	if (!input || typeof input !== "object") fail("video_draft", "Expected content");
+	const library = input.part_library ?? {}, placements = /* @__PURE__ */ new Map();
+	const tracks = [
+		...input.above_main_tracks ?? [],
+		...input.main_track ? [input.main_track] : [],
+		...input.below_main_tracks ?? []
+	];
+	for (const track of tracks) {
+		const role = track.parts_kind;
+		if (!role || ![
+			"video_clip",
+			"speech",
+			"caption",
+			"bgm"
+		].includes(role)) fail("tracks", "Unknown Track role");
+		if (role === "video_clip" && track !== input.main_track) fail("tracks", "Legacy visual content must use main_track");
+		const trackId = claim(track.id ?? mint("track"));
+		mutations.push({
+			type: "create-entity",
+			table: "track-entities",
+			id: trackId,
+			value: {
+				role,
+				...track.is_hidden === void 0 ? {} : { hidden: track.is_hidden }
+			}
+		}, {
+			type: "insert-node",
+			entityId: trackId
+		});
+		for (const item of track.items ?? []) {
+			const partId = claim(item.part_id ?? "");
+			if (!Object.hasOwn(library, partId)) fail(`part_library/${partId}`, "Missing placed part");
+			placements.set(partId, {
+				partId,
+				trackId,
+				role,
+				abs: milliseconds(item.abs_time_position ?? 0, `tracks/${trackId}/${partId}`)
+			});
+		}
+	}
+	for (const [id, part] of Object.entries(library)) {
+		if (!placements.has(id)) fail(`part_library/${id}`, "Unplaced legacy parts require an explicit placement before import");
+		if (!part || typeof part !== "object" || Object.keys(part).filter((k) => part[k] !== void 0).length !== 1) fail(`part_library/${id}`, "Expected exactly one known part kind");
+		const role = placements.get(id).role, payload = part[role];
+		if (!payload || payload.id !== id || payload.kind !== role) fail(`part_library/${id}`, "Part identity and kind must agree with its placement");
+	}
+	const facts = /* @__PURE__ */ new Map(), imported = /* @__PURE__ */ new Map();
+	for (const fact of options.mediaFacts ?? []) {
+		assertEntity("media-entities", fact);
+		const id = resourceId("media", fact.system, fact.key);
+		if (facts.has(id)) fail("mediaFacts", `Duplicate facts for ${fact.system}/${fact.key}`);
+		facts.set(id, fact);
+	}
+	const register = (media) => {
+		const id = resourceId("media", media.system, media.key), old = imported.get(id);
+		if (old) {
+			for (const key of new Set([...Object.keys(old), ...Object.keys(media)])) if (old[key] !== media[key]) fail(`mediaFacts/${id}`, "Conflicting resource facts");
+			return id;
+		}
+		assertEntity("media-entities", media);
+		claim(id);
+		imported.set(id, media);
+		mutations.push({
+			type: "create-entity",
+			table: "media-entities",
+			id,
+			value: media
+		});
+		return id;
+	};
+	const factFor = (system, key) => {
+		const fact = key ? facts.get(resourceId("media", system, key)) : void 0;
+		if (!fact) return projectionError("missing-media-facts", `mediaFacts/${system}/${key ?? ""}`, "Complete source kind and duration are required");
+		return fact;
+	};
+	const mediaByPart = /* @__PURE__ */ new Map(), scriptByRecording = /* @__PURE__ */ new Map(), scriptsByPart = /* @__PURE__ */ new Map();
+	const voices = /* @__PURE__ */ new Set();
+	for (const [id, p] of Object.entries(library)) if (p.video_clip) {
+		const fact = factFor("memota", p.video_clip.origin_media_id);
+		if (fact.kind !== "image" && fact.kind !== "video") fail(`part_library/${id}`, "Expected Image or Video facts");
+		mediaByPart.set(id, register(fact));
+	} else if (p.bgm) {
+		const fact = factFor("memota", p.bgm.origin_media_id);
+		if (fact.kind !== "audio" || fact.storageKey !== p.bgm.audio_storage_key) fail(`part_library/${id}`, "BGM requires matching Audio facts and storageKey");
+		mediaByPart.set(id, register(fact));
+	} else if (p.speech) {
+		const speech = p.speech;
+		const key = speech.origin_speech_id;
+		if (!key || !speech.audio_storage_key || typeof speech.audio_script !== "string") fail(`part_library/${id}`, "Speech requires its external identity, storageKey and audio_script");
+		const supplied = facts.get(resourceId("media", "memota-speech", key));
+		const intrinsic = speech.media_duration_ms ?? speech.duration_ms;
+		if (speech.duration_ms !== void 0 && intrinsic !== speech.duration_ms) fail(`part_library/${id}/duration_ms`, "Untrimmed Speech duration must agree with its source duration");
+		const fact = supplied ?? {
+			kind: "voiceover-recording",
+			system: "memota-speech",
+			key,
+			storageKey: speech.audio_storage_key,
+			durationMs: milliseconds(intrinsic, `part_library/${id}/duration_ms`, true)
+		};
+		if (fact.kind !== "voiceover-recording" || fact.storageKey !== speech.audio_storage_key || "durationMs" in fact && intrinsic !== void 0 && fact.durationMs !== intrinsic) fail(`part_library/${id}`, "Speech source facts must agree with its untrimmed recording");
+		const recordingId = register(fact);
+		mediaByPart.set(id, recordingId);
+		let script = scriptByRecording.get(recordingId);
+		if (script && script.text !== speech.audio_script) fail(`part_library/${id}/audio_script`, "One recording cannot acquire conflicting source scripts during import");
+		if (!script) {
+			script = {
+				id: claim(mint("audio-script")),
+				text: speech.audio_script
+			};
+			scriptByRecording.set(recordingId, script);
+			mutations.push({
+				type: "create-entity",
+				table: "audio-script-entities",
+				id: script.id,
+				value: { body: script.text }
+			}, {
+				type: "set-relation",
+				table: "derived-from-relations",
+				value: {
+					entityId: recordingId,
+					sourceId: script.id
+				}
+			});
+		}
+		scriptsByPart.set(id, script);
+		if (speech.voice) {
+			if (!speech.voice.id) fail(`part_library/${id}/voice`, "Voice requires its library key");
+			const voiceId = resourceId("voice", "voice-library", speech.voice.id);
+			if (!voices.has(voiceId)) {
+				claim(voiceId);
+				voices.add(voiceId);
+				mutations.push({
+					type: "create-entity",
+					table: "voice-entities",
+					id: voiceId,
+					value: {
+						system: "voice-library",
+						key: speech.voice.id,
+						...speech.voice.name === void 0 ? {} : { name: speech.voice.name }
+					}
+				});
+			}
+			mutations.push({
+				type: "set-relation",
+				table: "voice-timbre-relations",
+				value: {
+					recordingId,
+					voiceId
+				}
+			});
+		}
+	}
+	const owner = /* @__PURE__ */ new Map(), selections = /* @__PURE__ */ new Map();
+	for (const [speechId, script] of scriptsByPart) {
+		let cursor = 0;
+		for (const captionId of library[speechId].speech.caption_ids ?? []) {
+			const caption = library[captionId]?.caption;
+			if (!caption || owner.has(captionId) || caption.speech_part_id !== void 0 && caption.speech_part_id !== speechId) fail(`part_library/${speechId}/caption_ids`, "Caption list must contain unique, consistently owned Caption parts");
+			owner.set(captionId, speechId);
+			const text = caption.text;
+			if (typeof text !== "string") fail(`part_library/${captionId}/text`, "Expected Caption text");
+			const start = text.length ? script.text.indexOf(text, cursor) : -1;
+			if (start >= 0) {
+				cursor = start + text.length;
+				selections.set(captionId, {
+					audioScriptId: script.id,
+					start,
+					end: cursor
+				});
+			} else diagnostics.push({
+				code: "caption-text-unmatched",
+				path: `part_library/${captionId}/text`,
+				message: "No forward exact match; preserved as independent Caption text"
+			});
+		}
+	}
+	const hosts = /* @__PURE__ */ new Map();
+	for (const aggregation of input.part_aggregations ?? []) {
+		const host = aggregation.body_part_id;
+		if (!host || !library[host]?.video_clip) fail("part_aggregations", "Expected a placed visual host");
+		for (const attachment of aggregation.attachments ?? []) {
+			const id = attachment.part_id;
+			if (!id || !library[id]?.speech || hosts.has(id)) fail("part_aggregations", "Expected a uniquely anchored Speech");
+			hosts.set(id, {
+				to: host,
+				offset: milliseconds(attachment.relative_time_position ?? 0, "part_aggregations/offset", false, true)
+			});
+		}
+	}
+	for (const [id, placement] of placements) {
+		const part = library[id];
+		let sourceId = mediaByPart.get(id), inMs = 0, outMs = 0, speed;
+		const volume = part.video_clip?.volume ?? part.speech?.volume ?? part.bgm?.volume;
+		if (part.video_clip) {
+			const clip = part.video_clip;
+			if (clip.speed_shift !== void 0) {
+				const rate = clip.speed_shift.config?.linear?.speed;
+				if (clip.speed_shift.category !== "linear" || typeof rate !== "number" || !Number.isFinite(rate) || rate <= 0) projectionError("unsupported-speed", `part_library/${id}/speed_shift`, "Only positive linear speed is supported");
+				speed = { rate };
+			}
+			inMs = milliseconds(clip.play_in ?? 0, `part_library/${id}/play_in`);
+			const media = imported.get(sourceId);
+			const legacyWindow = clip.duration_ms === void 0 ? void 0 : Math.round(clip.duration_ms * (speed?.rate ?? 1));
+			outMs = milliseconds(clip.play_out ?? (legacyWindow === void 0 ? "durationMs" in media ? media.durationMs : void 0 : inMs + legacyWindow), `part_library/${id}/play_out`);
+			if ("durationMs" in media && outMs > media.durationMs) fail(`part_library/${id}/play_out`, "Window exceeds factual source duration");
+		} else if (part.speech || part.bgm) {
+			const media = imported.get(sourceId);
+			outMs = "durationMs" in media ? media.durationMs : 0;
+		} else if (part.caption) {
+			const caption = part.caption;
+			outMs = milliseconds(caption.duration_ms ?? caption.initial_duration_ms, `part_library/${id}/duration_ms`, true);
+			if (typeof caption.text !== "string") fail(`part_library/${id}/text`, "Expected Caption text");
+			if (caption.display_cues?.length) projectionError("unsupported-caption-cues", `part_library/${id}/display_cues`, "Timed sub-cues require an explicit conversion into separate Captions");
+			if (caption.speech_part_id !== void 0 && owner.get(id) !== caption.speech_part_id) fail(`part_library/${id}/speech_part_id`, "Caption ownership must agree with ordered speech.caption_ids");
+			sourceId = claim(mint("caption"));
+			const selected = selections.get(id), style = fromDraftStyle(caption.style);
+			mutations.push({
+				type: "create-entity",
+				table: "caption-entities",
+				id: sourceId,
+				value: {
+					...style === void 0 ? {} : { style },
+					...selected ? {} : { text: caption.text }
+				}
+			});
+			if (selected) mutations.push({
+				type: "set-caption-content",
+				captionId: sourceId,
+				...selected
+			});
+			const speechId = caption.speech_part_id, mediaId = speechId ? mediaByPart.get(speechId) : void 0;
+			if (mediaId && caption.start_ms !== void 0) {
+				const startMs = milliseconds(caption.start_ms, `part_library/${id}/start_ms`), endMs = startMs + (caption.initial_duration_ms ?? outMs);
+				const media = imported.get(mediaId);
+				if ("durationMs" in media && endMs > startMs && endMs <= media.durationMs) mutations.push({
+					type: "set-relation",
+					table: "caption-alignment-relations",
+					value: {
+						captionId: sourceId,
+						mediaId,
+						startMs,
+						endMs
+					}
+				});
+				else diagnostics.push({
+					code: "invalid-caption-alignment",
+					path: `part_library/${id}`,
+					message: "Source interval is invalid; display window is retained without alignment"
+				});
+			}
+		}
+		if (outMs <= inMs || !sourceId) fail(`part_library/${id}`, "Expected a nonempty source window");
+		mutations.push({
+			type: "create-entity",
+			table: "clip-entities",
+			id,
+			value: {
+				seqMarker: {
+					inMs,
+					outMs,
+					...speed ? { rate: speed.rate } : {},
+					...part.bgm ? { fillTimeline: true } : {}
+				},
+				...volume === void 0 ? {} : { volume }
+			}
+		}, {
+			type: "set-relation",
+			table: "clip-source-relations",
+			value: {
+				clipId: id,
+				sourceId
+			}
+		}, {
+			type: "insert-node",
+			entityId: id,
+			parentId: placement.trackId
+		});
+		if (placement.role !== "video_clip") {
+			const host = hosts.get(id);
+			const speechId = part.caption?.speech_part_id;
+			const to = host?.to ?? speechId ?? timelineId;
+			const offsetMs = host?.offset ?? (speechId ? milliseconds(part.caption?.start_ms ?? 0, `part_library/${id}/start_ms`) : placement.abs);
+			mutations.push({
+				type: "set-relation",
+				table: "time-anchor-relations",
+				value: {
+					from: id,
+					to,
+					offsetMs,
+					fallback_abs_ms: placement.abs
+				}
+			});
+		}
+	}
+	return {
+		timelineId,
+		mutations: orderMutations(mutations),
+		diagnostics
+	};
+}
+function orderMutations(mutations) {
+	const rank = (m) => m.type === "create-entity" ? 0 : m.type === "insert-node" ? 1 : 2;
+	return mutations.toSorted((a, b) => rank(a) - rank(b));
+}
+function milliseconds(value, path, positive = false, signed = false) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || !signed && value < 0 || positive && value <= 0) projectionError("invalid-time", path, "Expected safe integer milliseconds in the valid range");
+	return value;
+}
+//#endregion
+export { MedeoDsl as a, DslEditor as i, toVideoDraft as n, resolveDslLayout as o, createInitialMedeoDsl as r, DslProjectionError as s, fromVideoDraft as t };