@mengine/medeo-client 2.1.1-dsl.8 → 3.0.0

package/dist/{dsl-DbYqFFOb.js → dsl-Cpk8WxcZ.js}

@@ -1,6 +1,333 @@
-import { $ as assertId, A as hardenCidDescriptors, B as safeStringify, C as applySchemaToInferOptions, D as deepEqual, E as decodeNestedJsonValues, F as isObject, G as valuesEqual, H as stripUndefined, I as isObjectLike, J as getChildSchema, K as CID_KEY, L as isStateAndSchemaOfType, M as inferContainerTypeFromValue, N as insertChildToMap, O as defineCidProperty, P as isArrayLike, Q as assertEntityPatch, R as isTreeID, S as applyEncode, T as containerIdToContainerType, U as tryInferContainerType, V as schemaToContainerType, W as tryUpdateToContainer, X as assertCaptionContent, Y as getMapFieldSchema, Z as assertEntity, _ as isLoroTreeSchema, at as isRecord, b as validateSchema, c as isInvalidAtomic, ct as relationTables, d as getDefaultValue, dt as assertResourceIdentity, et as assertPhoneme, f as isContainerSchema, ft as defaultIdFactory, g as isLoroMovableListSchema, h as isLoroMapSchema, it as entityTables, j as hasTransform, k as getRootContainerByType, lt as validLanguage, m as isLoroListSchema, mt as resourceId, n as textStyles, nt as assertTimeAnchor, o as medeoDslLoroShape, ot as mergeFields, p as isListLikeSchema, pt as relationId, q as getChildContainerSchema, rt as atomicFields, s as captionContentCodec, st as patchRow, t as DEFAULT_UNIT_TIME_MS, tt as assertRelation, u as schema, ut as assertRelationIdentity, v as isRootSchemaType, w as cidsEqual, x as applyDecode, y as schemaContainsIgnoreField, z as isValueOfContainerType } from "./video-draft-types-Ce8NDenQ.js";
+import { sha256 } from "@noble/hashes/sha2.js";
 import { Cursor, LoroDoc, LoroList, LoroMap, LoroMovableList, LoroText, LoroTree, isContainer, isContainerId } from "loro-crdt";
-import { Immer, setAutoFreeze } from "immer";
+//#region ../medeo-dsl/src/ids.ts
+function bytesToBase64url(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function base64urlToBytes(value) {
+	if (!/^[A-Za-z0-9_-]+$/.test(value) || value.length % 4 === 1) throw new Error("Invalid base64url");
+	const bytes = Uint8Array.from(atob(value.replaceAll("-", "+").replaceAll("_", "/")), (c) => c.charCodeAt(0));
+	if (bytesToBase64url(bytes) !== value) throw new Error("Non-canonical base64url");
+	return bytes;
+}
+function tupleHash(tuple) {
+	return bytesToBase64url(sha256(new TextEncoder().encode(JSON.stringify(tuple))));
+}
+function resourceId(kind, system, key) {
+	return `${kind}:${tupleHash([system, key])}`;
+}
+function relationId(table, value) {
+	const v = value;
+	switch (table) {
+		case "voice-timbre-relations": return `voice-timbre:${tupleHash([v.recordingId, v.voiceId])}`;
+		case "derived-from-relations": return `derived-from:${tupleHash([v.entityId, v.sourceId])}`;
+	}
+	throw new Error(`Unknown relation table: ${table}`);
+}
+const defaultIdFactory = (kind) => `${kind}_${globalThis.crypto.randomUUID()}`;
+const resourceKinds = {
+	"media-entities": "media",
+	"voice-entities": "voice"
+};
+/** A resource row's ID is derived from its locator, so one external resource is one entity. */
+function assertResourceIdentity(table, id, value) {
+	const kind = resourceKinds[table];
+	if (kind && id !== resourceId(kind, value.system, value.key)) throw new Error("Resource identity does not match locator");
+}
+/** A relation row's ID is derived from its two ends. */
+function assertRelationIdentity(table, id, value) {
+	if (id !== relationId(table, value)) throw new Error("Relation ID does not match endpoints");
+}
+//#endregion
+//#region ../medeo-dsl/src/fields.ts
+const string = (v) => typeof v === "string";
+const nonempty = (v) => string(v) && v.length > 0;
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+const fraction = (v) => finite(v) && v >= 0 && v <= 1;
+const integer = (v) => typeof v === "number" && Number.isSafeInteger(v);
+const nonnegative = (v) => integer(v) && v >= 0;
+const positive = (v) => integer(v) && v > 0;
+const oneOf = (...values) => (v) => values.includes(v);
+const required = (check) => ({ check });
+const optional$1 = (check) => ({
+	check,
+	optional: true
+});
+const reservedIds = [
+	"$cid",
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+const id = (v) => nonempty(v) && !reservedIds.includes(v);
+const cursor = (v) => v instanceof Cursor;
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Cursor);
+}
+function assertId(value) {
+	if (!id(value)) throw new Error("Expected a nonempty, non-reserved ID");
+}
+function validLanguage(value) {
+	if (typeof value !== "string") return false;
+	if (/^x(?:-[a-z0-9]{1,8})+$/i.test(value)) return true;
+	try {
+		return value.length > 0 && Intl.getCanonicalLocales(value).length === 1;
+	} catch {
+		return false;
+	}
+}
+function object(fields) {
+	return (v) => {
+		try {
+			checkFields(v, fields);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+}
+function checkFields(value, fields, partial = false) {
+	if (!isRecord(value)) throw new Error("Expected an object");
+	for (const key of Object.keys(value)) if (!Object.hasOwn(fields, key)) throw new Error(`Unknown field: ${key}`);
+	for (const [key, field] of Object.entries(fields)) {
+		if (partial && !Object.hasOwn(value, key)) continue;
+		const v = value[key];
+		if (v === void 0 && field.optional) continue;
+		if (!field.check(v)) throw new Error(`Invalid or missing field: ${key}`);
+	}
+}
+const styleFields = {
+	font: optional$1(object({
+		system: required(oneOf("font-library")),
+		key: required(nonempty)
+	})),
+	fontSize: optional$1(finite),
+	fontColor: optional$1(string),
+	fontWeight: optional$1(finite),
+	entranceAnimation: optional$1(string),
+	entranceAnimationDurationMs: optional$1(nonnegative),
+	strokeColor: optional$1(string),
+	strokeWidth: optional$1(finite),
+	positionX: optional$1(fraction),
+	positionY: optional$1(fraction)
+};
+const seqMarkerFields = {
+	inMs: required(nonnegative),
+	outMs: required(nonnegative),
+	rate: optional$1((v) => finite(v) && v > 0),
+	fillTimeline: optional$1(oneOf(true))
+};
+/** A sequence marker's own fields; the window being nonempty is checked where it is written. */
+function assertSeqMarker(value) {
+	checkFields(value, seqMarkerFields);
+}
+const timeAnchorFields = {
+	to: required(id),
+	offsetMs: required(integer),
+	fallback_abs_ms: required(nonnegative)
+};
+/** A time anchor's own fields; what it points at is checked by `assertReferenceAdmitted`. */
+function assertTimeAnchor(value) {
+	checkFields(value, timeAnchorFields);
+}
+const selectionFields = {
+	audioScriptId: required(id),
+	segmentId: required(id),
+	start: optional$1(cursor),
+	end: optional$1(cursor)
+};
+/** A whole segment, or a run inside it: both ends or neither. */
+const segmentSelection = (fields) => (v) => object(fields)(v) && v.start === void 0 === (v.end === void 0);
+function assertCaptionContent(value) {
+	if (!segmentSelection(selectionFields)(value)) throw new Error("Invalid segment selection");
+}
+const phonemeFields = {
+	...selectionFields,
+	phonemeScript: optional$1(string)
+};
+function assertPhoneme(value) {
+	if (!segmentSelection(phonemeFields)(value)) throw new Error("Invalid phoneme");
+}
+const segmentFields = {
+	id: required(id),
+	text: required(string),
+	startMs: optional$1(nonnegative),
+	endMs: optional$1(nonnegative)
+};
+/** A segment's time in the medium it was read off: both ends or neither, the end not before the start. */
+const segment = (v) => {
+	if (!object(segmentFields)(v)) return false;
+	const { startMs, endMs } = v;
+	return startMs === void 0 ? endMs === void 0 : endMs !== void 0 && endMs >= startMs;
+};
+/** One segment as a script stores it; a segment added on its own is checked here, not with its row. */
+function assertScriptSegment(value) {
+	if (!segment(value)) throw new Error("A segment is { id, text } with startMs and endMs both or neither, endMs not before startMs");
+}
+/** A script's segments: each with its own id, unique within the script. */
+const segments = (v) => Array.isArray(v) && v.every(segment) && new Set(v.map((s) => s.id)).size === v.length;
+const locator = {
+	system: required(oneOf("memota", "memota-speech")),
+	key: required(nonempty)
+};
+const entityFields = {
+	"timeline-entities": {},
+	"track-entities": {
+		role: required(oneOf("video_clip", "speech", "caption", "bgm")),
+		hidden: optional$1((v) => typeof v === "boolean")
+	},
+	"clip-entities": {
+		seqMarker: required(object(seqMarkerFields)),
+		volume: optional$1(finite),
+		source: required(id),
+		anchor: optional$1(object(timeAnchorFields))
+	},
+	"media-entities": {
+		...locator,
+		kind: required(oneOf("video", "audio", "voiceover-recording", "image")),
+		storageKey: optional$1(nonempty),
+		durationMs: optional$1(positive),
+		digest: optional$1(nonempty)
+	},
+	"audio-script-entities": {
+		segments: required(segments),
+		defaultLanguage: optional$1(validLanguage),
+		system: optional$1(oneOf("memota")),
+		key: optional$1(nonempty),
+		storageKey: optional$1(nonempty),
+		digest: optional$1(nonempty)
+	},
+	"phonetic-script-entities": {
+		phoneme: optional$1(segmentSelection(phonemeFields)),
+		system: optional$1(oneOf("memota")),
+		key: optional$1(nonempty),
+		storageKey: optional$1(nonempty),
+		digest: optional$1(nonempty)
+	},
+	"caption-entities": {
+		selection: optional$1(segmentSelection(selectionFields)),
+		text: optional$1(string),
+		style: optional$1(object(styleFields))
+	},
+	"voice-entities": {
+		system: required(oneOf("voice-library")),
+		key: required(nonempty),
+		name: optional$1(string)
+	}
+};
+const entityTables = Object.keys(entityFields);
+/**
+* Fields stored as one encoded string: written whole, never merged field by field. A patch to one
+* is merged into the current value first, then the whole value is written.
+*/
+const atomicFields = {
+	"clip-entities": ["seqMarker", "anchor"],
+	"phonetic-script-entities": ["phoneme"],
+	"caption-entities": ["selection"]
+};
+const relationFields = {
+	"voice-timbre-relations": {
+		recordingId: required(id),
+		voiceId: required(id)
+	},
+	"derived-from-relations": {
+		entityId: required(id),
+		sourceId: required(id),
+		sourceDigest: optional$1(nonempty)
+	}
+};
+const relationTables = Object.keys(relationFields);
+const fileFields = [
+	"system",
+	"key",
+	"storageKey",
+	"digest"
+];
+const phonemeScriptOf = (row) => isRecord(row.phoneme) ? row.phoneme.phonemeScript : void 0;
+/**
+* A PhoneticScript as a write leaves it: written for a segment (D181), and its phonemeScript is raw
+* content stored as its file (D178) — with text the row names that file and its digest, without
+* text it has no file, and rewritten text is a new file.
+*/
+function assertPhoneticScript(before, after) {
+	if (!isRecord(after.phoneme)) throw new Error("A PhoneticScript is written for a segment of its base script");
+	if (phonemeScriptOf(after) === void 0) {
+		if (fileFields.some((field) => after[field] !== void 0)) throw new Error("A PhoneticScript without text has no file");
+	} else if (after.system === void 0 || after.key === void 0 || after.digest === void 0) throw new Error("A PhoneticScript stores its phonemeScript as a file: name it by system and key with its digest");
+	if (before !== void 0 && phonemeScriptOf(after) !== phonemeScriptOf(before) && after.digest !== void 0 && after.digest === before.digest) throw new Error("A rewritten phonemeScript is stored again: write its new file");
+}
+/** A transcript names the file it was read from by system and key together; its facts come with that name. */
+function assertTranscriptFile(row) {
+	if (row.system === void 0 !== (row.key === void 0)) throw new Error("A transcript names its transcription file by system and key");
+	if (row.key === void 0 && (row.storageKey !== void 0 || row.digest !== void 0)) throw new Error("A script without a transcription file has no file facts");
+}
+function assertEntity(table, value) {
+	checkFields(value, entityFields[table]);
+	if (table === "audio-script-entities") assertTranscriptFile(value);
+	if (table === "media-entities") {
+		if (value.kind === "image" && value.durationMs !== void 0) throw new Error("Image has no intrinsic duration");
+		if (value.kind !== "image" && !positive(value.durationMs)) throw new Error("Finite media requires durationMs");
+		if (["audio", "voiceover-recording"].includes(value.kind) && !nonempty(value.storageKey)) throw new Error("Audio requires storageKey");
+	}
+}
+/** Validate only touched fields, so an unrelated edit can proceed in a merged, invalid document. */
+function assertEntityPatch(table, patch, current) {
+	if (!isRecord(patch)) throw new Error("Expected an entity patch");
+	if (table === "audio-script-entities" && Object.hasOwn(patch, "segments")) throw new Error("Change segments with segment mutations and edit their text through the Text adapter");
+	if (table === "caption-entities" && current.style !== void 0 && Object.hasOwn(patch, "style") && patch.style === void 0) throw new Error("Reset individual style fields; retain the style Map");
+	if (table === "caption-entities" && current.text !== void 0 && patch.text !== void 0) throw new Error("Edit Caption text through the Text adapter");
+	const next = patchRow(table, current, patch);
+	for (const key of Object.keys(patch)) {
+		const field = entityFields[table][key];
+		if (!field || !field.optional && next[key] === void 0 || next[key] !== void 0 && !field.check(next[key])) throw new Error(`Invalid patch field: ${key}`);
+	}
+	if (table === "audio-script-entities" && fileFields.some((field) => Object.hasOwn(patch, field))) {
+		if (current.key !== void 0 && (next.system !== current.system || next.key !== current.key)) throw new Error("A transcript's transcription file is fixed once named");
+		assertTranscriptFile(next);
+	}
+	if (table === "media-entities" || table === "voice-entities") {
+		for (const key of [
+			"system",
+			"key",
+			"kind"
+		]) if (Object.hasOwn(patch, key) && patch[key] !== current[key]) throw new Error(`Resource identity field is immutable: ${key}`);
+	}
+	if (table === "media-entities") {
+		if (Object.hasOwn(patch, "durationMs")) {
+			if (next.kind === "image" ? next.durationMs !== void 0 : !positive(next.durationMs)) throw new Error("durationMs must match the media kind");
+		}
+		if (Object.hasOwn(patch, "storageKey") && ["audio", "voiceover-recording"].includes(next.kind) && !nonempty(next.storageKey)) throw new Error("Audio requires storageKey");
+	}
+}
+function assertRelation(table, value) {
+	checkFields(value, relationFields[table]);
+}
+/**
+* The row after a patch. An atomic field merges into its current value, so a partial patch keeps
+* the rest of it; an unreadable stored value is replaced instead, so writing a whole value repairs it.
+*/
+function patchRow(table, current, patch) {
+	const next = mergeFields(current, patch);
+	for (const key of atomicFields[table] ?? []) {
+		const old = current[key];
+		const value = patch[key];
+		if (value !== void 0 && isRecord(old) && old.invalid === true) next[key] = isRecord(value) ? mergeFields({}, value) : value;
+	}
+	return next;
+}
+/** Undefined deletes; nested patches retain sibling fields and an existing empty style Map. */
+function mergeFields(target, patch) {
+	const result = { ...target };
+	for (const [key, value] of Object.entries(patch)) {
+		if (reservedIds.includes(key)) throw new Error(`Reserved field: ${key}`);
+		if (value === void 0) delete result[key];
+		else result[key] = isRecord(value) ? mergeFields(isRecord(result[key]) ? result[key] : {}, value) : value;
+	}
+	return result;
+}
+//#endregion
 //#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");
@@ -104,42 +431,27 @@ function prepareTextEdits(text, edits) {
 			}
 			return edit;
 		}),
-		body: text
+		text
 	};
 }
-/** An empty body has no segments; otherwise each line, including a trailing empty one, is a segment. */
-function lines(body) {
-	if (body === "") return [];
-	const result = [];
-	let start = 0;
-	for (const text of body.split("\n")) {
-		result.push({
-			text,
-			start,
-			end: start + text.length
-		});
-		start += text.length + 1;
-	}
-	return result;
-}
-/** The language a whole line carries: one shared mark on every unit, else none. */
-function lineLanguage(text, line) {
-	if (line.start === line.end) return void 0;
-	const first = text.langs[line.start];
-	for (let i = line.start + 1; i < line.end; i++) if (text.langs[i] !== first) return void 0;
+/** The language a whole segment carries: one shared mark on every unit, else none. */
+function markedLanguage(text) {
+	if (!text.text.length) return void 0;
+	const first = text.langs[0];
+	for (let i = 1; i < text.text.length; i++) if (text.langs[i] !== first) return void 0;
 	return first;
 }
 /** Read language marks off a rich-text delta. */
 function langsFromDelta(delta) {
-	let body = "";
+	let text = "";
 	const langs = [];
 	for (const run of delta) {
-		body += run.insert;
+		text += run.insert;
 		const language = typeof run.attributes?.language === "string" ? run.attributes.language : void 0;
 		for (let i = 0; i < run.insert.length; i++) langs.push(language);
 	}
 	return {
-		body,
+		text,
 		langs
 	};
 }
@@ -178,16 +490,23 @@ const referenceFields = {
 	"phonetic-script-entities": ["phoneme"],
 	"caption-entities": ["selection"]
 };
+/** The segment a selection names: refused when its script or the segment is missing. */
+function requireSegment(rows, audioScriptId, segmentId) {
+	const script = requireEntity(rows, "audio-script-entities", audioScriptId);
+	const segment = Array.isArray(script.segments) ? script.segments.find((s) => isRecord(s) && s.id === segmentId) : void 0;
+	if (!segment) throw new Error(`Missing segment ${String(segmentId)} of ${String(audioScriptId)}`);
+	return segment;
+}
 /**
 * Whether a single-valued relation, stored as a field of the entity that owns it, may hold this
 * value among these rows. The owner need not be stored yet; an absent value unlinks it.
-* A caption selection's range is checked against the live body by whoever holds it.
+* A selection's run is checked against the segment's live text by whoever holds it.
 */
 function assertReferenceAdmitted(rows, table, id, field, value) {
 	assertId(id);
 	const key = `${table}.${field}`;
 	if (value === void 0) {
-		if (key === "clip-entities.source" || key === "phonetic-script-entities.phoneme") throw new Error(`Missing required relation: ${key}`);
+		if (key === "clip-entities.source") throw new Error(`Missing required relation: ${key}`);
 		return;
 	}
 	switch (key) {
@@ -213,26 +532,49 @@ function assertReferenceAdmitted(rows, table, id, field, value) {
 			break;
 		}
 		case "caption-entities.selection":
-			assertCaptionContent(value);
-			requireEntity(rows, "audio-script-entities", value.audioScriptId);
-			break;
-		case "phonetic-script-entities.phoneme":
-			assertPhoneme(value);
-			requireEntity(rows, "audio-script-entities", value.audioScriptId);
+		case "phonetic-script-entities.phoneme": {
+			if (key === "caption-entities.selection") assertCaptionContent(value);
+			else assertPhoneme(value);
+			const { audioScriptId, segmentId } = value;
+			requireSegment(rows, audioScriptId, segmentId);
 			break;
+		}
 	}
 }
-/** Both ends of a caption's selection exist: the caption and the script it selects from. */
+/** Both ends of a caption's selection exist: the caption and the segment it selects. */
 function assertCaptionEndpoints(rows, selection) {
 	requireEntity(rows, "caption-entities", selection.captionId);
-	requireEntity(rows, "audio-script-entities", selection.audioScriptId);
+	requireSegment(rows, selection.audioScriptId, selection.segmentId);
+}
+/** Both ends of a phoneme exist: the PhoneticScript and the segment it is written for. */
+function assertPhonemeEndpoints(rows, selection) {
+	requireEntity(rows, "phonetic-script-entities", selection.phoneticScriptId);
+	requireSegment(rows, selection.audioScriptId, selection.segmentId);
+}
+/**
+* A selection of a segment's current text: the whole segment, or a run of it in UTF-16 offsets
+* with both ends stated. What it selects is never empty.
+*/
+function assertSegmentRange(range, text) {
+	if (range.start === void 0 !== (range.end === void 0)) throw new Error("A run inside a segment states both its start and its end");
+	if (range.start === void 0 || range.end === void 0) {
+		if (!text.length) throw new Error("An empty segment cannot be selected");
+		return;
+	}
+	assertTextOffset(text, range.start);
+	assertTextOffset(text, range.end);
+	if (range.start >= range.end) throw new Error("Expected a nonempty range in the current segment");
 }
-/** A caption selects a nonempty run of its script's current body, in UTF-16 offsets. */
-function assertCaptionSelection(rows, selection, body) {
+/** A caption selects a segment of its script, or a nonempty run of it. */
+function assertCaptionSelection(rows, selection, text) {
 	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");
+	assertSegmentRange(selection, text);
+}
+/** A PhoneticScript is written for a segment of its script, or a nonempty run of it, as a Caption selects one. */
+function assertPhonemeSelection(rows, selection, text) {
+	assertPhonemeEndpoints(rows, selection);
+	assertSegmentRange(selection, text);
+	if (selection.phonemeScript !== void 0 && typeof selection.phonemeScript !== "string") throw new Error("phonemeScript is a string");
 }
 /** A caption's text comes from a selection of a script or from its own text, never both. */
 function assertCaptionSource(caption, selected) {
@@ -858,35 +1200,1572 @@ function replaceSequencePlan(s, input, ids) {
 			};
 		}
 	}
-	mutations.push(...deleteClips({
-		...s,
-		"clip-entities": clips
-	}, input.clipIds, "cascade"));
-	return mutations;
+	mutations.push(...deleteClips({
+		...s,
+		"clip-entities": clips
+	}, 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
+			},
+			source: source.id
+		}
+	}];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/schema/resolver.js
+function getMapFieldSchema(schema, key) {
+	if (!schema) return void 0;
+	if (Object.prototype.hasOwnProperty.call(schema.definition, key)) return schema.definition[key];
+	if (schema.type === "loro-map" && "catchallType" in schema) return schema.catchallType;
+}
+function getChildSchema(schema, childKey) {
+	if (!schema) return void 0;
+	switch (schema.type) {
+		case "schema":
+		case "loro-map": return childKey === void 0 ? void 0 : getMapFieldSchema(schema, String(childKey));
+		case "loro-list":
+		case "loro-movable-list": return schema.itemSchema;
+		case "loro-tree": return schema.nodeSchema;
+		default: return;
+	}
+}
+function getChildContainerSchema(schema, childKey) {
+	const childSchema = getChildSchema(schema, childKey);
+	if (!childSchema) return void 0;
+	switch (childSchema.type) {
+		case "loro-map":
+		case "loro-list":
+		case "loro-movable-list":
+		case "loro-text":
+		case "loro-tree": return childSchema;
+		default: return;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/constants.js
+const CID_KEY = "$cid";
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/container-inference.js
+function isPlainObjectValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && typeof value !== "function";
+}
+function inferContainerTypeFromValue$1(value, defaults) {
+	switch (getContainerValueKind(value)) {
+		case "map": return "Map";
+		case "array": return defaults?.defaultMovableList ? "MovableList" : "List";
+		case "string": return defaults?.defaultLoroText ? "Text" : void 0;
+		default: return;
+	}
+}
+function inferSchemaContainerTypeFromValue(value, defaults) {
+	switch (inferContainerTypeFromValue$1(value, defaults)) {
+		case "Map": return "loro-map";
+		case "List": return "loro-list";
+		case "MovableList": return "loro-movable-list";
+		case "Text": return "loro-text";
+		default: return;
+	}
+}
+function matchesContainerType(containerType, value) {
+	const kind = getContainerValueKind(value);
+	switch (containerType) {
+		case "Map": return kind === "map";
+		case "List":
+		case "MovableList":
+		case "Tree": return kind === "array";
+		case "Text": return kind === "string";
+		default: return false;
+	}
+}
+function getContainerValueKind(value) {
+	if (isPlainObjectValue(value)) return "map";
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "string") return "string";
+	return "other";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/utils.js
+/**
+* Utility functions for Loro Mirror core
+*/
+/**
+* Check if a schema has a transform.
+* Distinguishes between the .transform() builder method (function) and an actual
+* TransformDefinition object (with decode/encode functions).
+*/
+function hasTransform(schema) {
+	if (schema === void 0) return false;
+	const t = schema.transform;
+	return t != null && typeof t === "object";
+}
+/**
+* Get the transform from a schema, or undefined if none exists.
+*/
+function getTransform(schema) {
+	if (hasTransform(schema)) return schema.transform;
+}
+/**
+* Get the effective equality strategy for a transform.
+* Default: "reference-equality"
+*/
+function getEqualityStrategy(schema, strategyIfNotTransformable) {
+	const transform = getTransform(schema);
+	if (!transform) return strategyIfNotTransformable;
+	return transform.isEqual ?? "reference-equality";
+}
+/**
+* Apply decode transform to a CRDT value.
+* Null/undefined pass through as-is - transform is only called for real values.
+*/
+function applyDecode(schema, crdtValue) {
+	if (crdtValue === null || crdtValue === void 0) return crdtValue;
+	const transform = getTransform(schema);
+	return transform ? transform.decode(crdtValue) : crdtValue;
+}
+/**
+* Recursively decode JSON values using schema transforms.
+* Mutates in-place. Used for snapshot initialization where toJSON() skips decode.
+*/
+function decodeNestedJsonValues(json, schema) {
+	if (json === null || json === void 0 || !schema) return json;
+	switch (schema.type) {
+		case "loro-map":
+			if (!isObject(json)) return json;
+			for (const key of Object.keys(json)) {
+				const fieldSchema = getChildSchema(schema, key);
+				json[key] = decodeNestedJsonValues(json[key], fieldSchema);
+			}
+			return json;
+		case "loro-list":
+		case "loro-movable-list": {
+			if (!Array.isArray(json)) return json;
+			const itemSchema = getChildSchema(schema);
+			for (let i = 0; i < json.length; i++) json[i] = decodeNestedJsonValues(json[i], itemSchema);
+			return json;
+		}
+		case "loro-tree": {
+			if (!Array.isArray(json)) return json;
+			const nodeSchema = getChildSchema(schema);
+			const walk = (nodes) => {
+				for (const node of nodes) if (node != null && typeof node == "object") {
+					if ("data" in node && node.data !== void 0) node.data = decodeNestedJsonValues(node.data, nodeSchema);
+					if ("children" in node && Array.isArray(node.children)) walk(node.children);
+				}
+			};
+			walk(json);
+			return json;
+		}
+		case "loro-text":
+		case "ignore": return json;
+		default: return applyDecode(schema, json);
+	}
+}
+/**
+* Apply encode transform to a domain value.
+* Null/undefined pass through as-is - transform is only called for real values.
+*/
+function applyEncode(schema, domainValue) {
+	if (domainValue === null || domainValue === void 0) return domainValue;
+	const transform = getTransform(schema);
+	return transform ? transform.encode(domainValue) : domainValue;
+}
+/**
+* Check if two domain values are equal according to the schema's equality strategy.
+*
+* Reference equality is always checked first (performance optimization).
+* If refs match, returns true (no change).
+* If refs differ, behavior depends on isEqual setting.
+*/
+function valuesEqual(schema, oldValue, newValue, strategyIfNotTransformable) {
+	if (oldValue === newValue) return true;
+	const strategy = getEqualityStrategy(schema, strategyIfNotTransformable);
+	if (strategy === "reference-equality") return false;
+	else if (strategy === "encoded-value-equality") return applyEncode(schema, oldValue) === applyEncode(schema, newValue);
+	else if (strategy === "deep-equality") return deepEqual(oldValue, newValue);
+	else return strategy(oldValue, newValue);
+}
+function defineCidProperty(target, cid) {
+	if (!isObject(target) || Object.prototype.hasOwnProperty.call(target, "$cid")) return;
+	Object.defineProperty(target, CID_KEY, { value: cid });
+}
+/**
+* Restore the read-only `$cid` contract on a freshly produced state.
+*
+* `defineCidProperty` stamps `$cid` as `{ writable: false, enumerable: false,
+* configurable: false }`. Immer's `useStrictShallowCopy` preserves the descriptor, but it
+* deliberately rewrites every non-writable data property to `{ writable: true,
+* configurable: true }` so the draft stays mutable — which would leave `$cid` writable on
+* every object Immer copied, letting callers reassign a published `$cid`.
+*
+* Two things keep this proportional to what Immer actually copied rather than to the size
+* of the state:
+*
+* - `prev` is the state `produce` was called with, and Immer shares everything it did not
+*   copy, so a subtree reference-equal to `prev` cannot have been touched.
+* - An already-locked `$cid` means this object was not copied this round, so its children
+*   are the same references they were when it was last hardened and are locked too. This
+*   is what makes a reorder cheap: moved items are shared references that land at a new
+*   index, so `prev` no longer lines up with them, but they are still locked.
+*/
+function hardenCidDescriptors(next, prev, visited) {
+	if (next === prev) return;
+	if (Array.isArray(next)) {
+		if ((visited ?? (visited = /* @__PURE__ */ new Set())).has(next)) return;
+		visited.add(next);
+		const prevArr = Array.isArray(prev) ? prev : void 0;
+		for (let i = 0; i < next.length; i++) hardenCidDescriptors(next[i], prevArr?.[i], visited);
+		return;
+	}
+	if (!isObject(next)) return;
+	const descriptor = Object.getOwnPropertyDescriptor(next, CID_KEY);
+	if (descriptor) {
+		if (!descriptor.configurable) return;
+		if ("value" in descriptor) Object.defineProperty(next, CID_KEY, {
+			value: descriptor.value,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	if ((visited ?? (visited = /* @__PURE__ */ new Set())).has(next)) return;
+	visited.add(next);
+	const prevObj = isObject(prev) ? prev : void 0;
+	for (const key of Object.keys(next)) hardenCidDescriptors(next[key], prevObj?.[key], visited);
+}
+/**
+* Check if a value is an object
+*/
+function isObject(value) {
+	return isPlainObjectValue(value);
+}
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* Recursively removes undefined values from an object.
+* This treats undefined values as non-existent fields.
+* Preserves non-enumerable properties like $cid.
+* Returns the original object if no undefined values are found.
+* Protects against prototype pollution by skipping unsafe keys.
+*/
+function stripUndefined(value) {
+	return stripUndefinedInner(value, 0, void 0);
+}
+/**
+* Depth at which we start recording the recursion path to detect cycles.
+*
+* This runs over the whole state on every `setState`, and tracking every node costs more
+* than the stripping itself. Mirror state is a tree whose depth follows the schema, so a
+* real state never gets near this; only a cycle recurses without bound. Once the path is
+* being recorded, any cycle revisits one of its own nodes within a single lap, so starting
+* late still terminates.
+*/
+const CYCLE_GUARD_DEPTH = 64;
+/**
+* Placeholder for a key that must not reach the rebuilt object: an unsafe key, or one whose
+* value is `undefined` and is therefore treated as a non-existent field.
+*/
+const DROPPED = Symbol("dropped");
+function stripUndefinedInner(value, depth, path) {
+	if (value === void 0) return value;
+	if (Array.isArray(value)) {
+		if (depth >= CYCLE_GUARD_DEPTH) {
+			if ((path ?? (path = /* @__PURE__ */ new Set())).has(value)) return value;
+			path.add(value);
+		}
+		let hasChanges = false;
+		const result = value.map((item) => {
+			const stripped = stripUndefinedInner(item, depth + 1, path);
+			if (stripped !== item) hasChanges = true;
+			return stripped;
+		});
+		path?.delete(value);
+		return hasChanges ? result : value;
+	}
+	if (isObject(value)) {
+		if (depth >= CYCLE_GUARD_DEPTH) {
+			if ((path ?? (path = /* @__PURE__ */ new Set())).has(value)) return value;
+			path.add(value);
+		}
+		const keys = Object.keys(value);
+		const strippedValues = Array.from({ length: keys.length });
+		let changed = false;
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (UNSAFE_KEYS.has(key)) {
+				strippedValues[i] = DROPPED;
+				continue;
+			}
+			const val = value[key];
+			if (val === void 0) {
+				strippedValues[i] = DROPPED;
+				changed = true;
+				continue;
+			}
+			const stripped = stripUndefinedInner(val, depth + 1, path);
+			strippedValues[i] = stripped;
+			if (stripped !== val) changed = true;
+		}
+		path?.delete(value);
+		if (!changed) return value;
+		const result = Object.create(null);
+		const allProps = Object.getOwnPropertyNames(value);
+		for (const key of allProps) {
+			if (UNSAFE_KEYS.has(key)) continue;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor && !descriptor.enumerable) Object.defineProperty(result, key, descriptor);
+		}
+		for (let i = 0; i < keys.length; i++) {
+			const val = strippedValues[i];
+			if (val === DROPPED) continue;
+			Object.defineProperty(result, keys[i], {
+				value: val,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+		}
+		return result;
+	}
+	return value;
+}
+/**
+* Performs a deep equality check between two values
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null || typeof a !== "object" && typeof a !== "function" || typeof b !== "object" && typeof b !== "function") return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+		return true;
+	}
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (a instanceof RegExp && b instanceof RegExp) return a.toString() === b.toString();
+	if (!Array.isArray(a) && !Array.isArray(b)) {
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		if (keysA.length !== keysB.length) return false;
+		for (const key of keysA) {
+			if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+			if (!deepEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return false;
+}
+/**
+* Recursively compare the `$cid` markers of two state trees.
+*
+* `deepEqual` only walks enumerable keys, so it cannot see `$cid` (which is stamped as a
+* non-enumerable descriptor). Used by `Mirror.checkStateConsistency` so that a tampered
+* or stale `$cid` is reported as a divergence instead of silently sitting in the state.
+* Only the markers are compared here; value equality is `deepEqual`'s job.
+*/
+function cidsEqual(a, b, seen) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		if (markSeen(a, b, seen ?? (seen = /* @__PURE__ */ new Map())) === "seen") return true;
+		for (let i = 0; i < a.length; i++) if (!cidsEqual(a[i], b[i], seen)) return false;
+		return true;
+	}
+	if (!isObject(a) || !isObject(b)) return true;
+	if (a["$cid"] !== b["$cid"]) return false;
+	if (markSeen(a, b, seen ?? (seen = /* @__PURE__ */ new Map())) === "seen") return true;
+	for (const key of Object.keys(a)) {
+		if (!Object.prototype.hasOwnProperty.call(b, key)) continue;
+		if (!cidsEqual(a[key], b[key], seen)) return false;
+	}
+	return true;
+}
+function markSeen(a, b, seen) {
+	let partners = seen.get(a);
+	if (!partners) {
+		partners = /* @__PURE__ */ new Set();
+		seen.set(a, partners);
+	}
+	if (partners.has(b)) return "seen";
+	partners.add(b);
+	return "new";
+}
+function containerIdToContainerType(containerId) {
+	const parts = containerId.split(":");
+	return parts[parts.length - 1];
+}
+function getRootContainerByType(doc, key, type) {
+	if (type === "Text") return doc.getText(key);
+	else if (type === "List") return doc.getList(key);
+	else if (type === "MovableList") return doc.getMovableList(key);
+	else if (type === "Map") return doc.getMap(key);
+	else if (type === "Tree") return doc.getTree(key);
+	else throw new Error();
+}
+function insertChildToMap(containerId, key, value, inferOptions) {
+	const ct = tryInferContainerType(value, inferOptions);
+	if (ct) return {
+		container: containerId,
+		key,
+		value,
+		kind: "insert-container",
+		childContainerType: ct
+	};
+	return {
+		container: containerId,
+		key,
+		value,
+		kind: "insert"
+	};
+}
+function tryUpdateToContainer(change, toUpdate, schema, inferOptions) {
+	if (!toUpdate) return change;
+	if (change.kind !== "insert" && change.kind !== "set") return change;
+	const effectiveInferOptions = applySchemaToInferOptions(schema, inferOptions);
+	const containerType = schema ? schemaToContainerType(schema) ?? tryInferContainerType(change.value, effectiveInferOptions) : tryInferContainerType(change.value, effectiveInferOptions);
+	if (containerType == null || schema && hasTransform(schema)) {
+		const encodedValue = applyEncode(schema, change.value);
+		return encodedValue !== change.value ? {
+			...change,
+			value: encodedValue
+		} : change;
+	}
+	if (change.kind === "insert") return {
+		container: change.container,
+		key: change.key,
+		value: change.value,
+		kind: "insert-container",
+		childContainerType: containerType
+	};
+	if (change.kind === "set") return {
+		container: change.container,
+		key: change.key,
+		value: change.value,
+		kind: "set-container",
+		childContainerType: containerType
+	};
+	return change;
+}
+function schemaToContainerType(schema) {
+	const containerType = schema.getContainerType();
+	return containerType === null ? void 0 : containerType;
+}
+function tryInferContainerType(value, defaults) {
+	return inferContainerTypeFromValue$1(value, defaults);
+}
+function applySchemaToInferOptions(schema, base) {
+	if (!schema || schema.type !== "any") return base;
+	const next = { ...base };
+	next.defaultLoroText = schema.options.defaultLoroText ?? false;
+	if (schema.options.defaultMovableList !== void 0) next.defaultMovableList = schema.options.defaultMovableList;
+	return next;
+}
+function isValueOfContainerType(containerType, value) {
+	return matchesContainerType(containerType, value);
+}
+function inferContainerTypeFromValue(value, defaults) {
+	return inferSchemaContainerTypeFromValue(value, defaults);
+}
+function isObjectLike(value) {
+	return typeof value === "object";
+}
+function isArrayLike(value) {
+	return Array.isArray(value);
+}
+function isStateAndSchemaOfType(values, stateGuard, schemaGuard) {
+	return stateGuard(values.oldState) && stateGuard(values.newState) && (!values.schema || schemaGuard(values.schema));
+}
+function isTreeID(id) {
+	if (!(typeof id === "string")) return false;
+	return !!id.match(/[0-9]+@[0-9]+/);
+}
+/**
+* Stringify a value safely, handling non-JSON-serializable types.
+* Handles BigInt, Date, RegExp, functions, and custom objects.
+*/
+function safeStringify(value, indent = 2) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	function replacer(val) {
+		if (val === null || val === void 0) return val;
+		if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") return val;
+		if (typeof val === "bigint") return `[BigInt: ${val.toString()}]`;
+		if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+		if (typeof val === "symbol") return `[Symbol: ${val.description || ""}]`;
+		if (typeof val === "object") {
+			if (seen.has(val)) return "[Circular]";
+			seen.add(val);
+			if (val instanceof Date) return `[Date: ${val.toISOString()}]`;
+			if (val instanceof RegExp) return `[RegExp: ${val.toString()}]`;
+			if (val instanceof Error) return `[Error: ${val.message}]`;
+			if (Array.isArray(val)) return val.map(replacer);
+			const result = {};
+			for (const key of Object.keys(val)) result[key] = replacer(val[key]);
+			return result;
+		}
+		return Object.prototype.toString.call(val);
+	}
+	return JSON.stringify(replacer(value), null, indent);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/schema/validators.js
+const schemaValidationCache = /* @__PURE__ */ new WeakMap();
+function isCacheableValue(value) {
+	return typeof value === "object" && value !== null;
+}
+function isSchemaValidated(schema, value) {
+	if (!isCacheableValue(value)) return false;
+	return schemaValidationCache.get(value)?.has(schema) ?? false;
+}
+function markSchemaValidated(schema, value) {
+	if (!isCacheableValue(value)) return;
+	let cache = schemaValidationCache.get(value);
+	if (!cache) {
+		cache = /* @__PURE__ */ new WeakSet();
+		schemaValidationCache.set(value, cache);
+	}
+	cache.add(schema);
+}
+/**
+* Type guard for LoroMapSchema
+*/
+function isLoroMapSchema(schema) {
+	return !!schema && schema.type === "loro-map";
+}
+/**
+* Type guard for LoroListSchema
+*/
+function isLoroListSchema(schema) {
+	return !!schema && schema.type === "loro-list";
+}
+function isListLikeSchema(schema) {
+	return isLoroListSchema(schema) || isLoroMovableListSchema(schema);
+}
+function isLoroMovableListSchema(schema) {
+	return !!schema && schema.type === "loro-movable-list";
+}
+/**
+* Type guard for RootSchemaType
+*/
+function isRootSchemaType(schema) {
+	return !!schema && schema.type === "schema";
+}
+/**
+* Whether a schema subtree contains any `Ignore` field. Recursive schemas are
+* tolerated (each schema object is visited once).
+*/
+function schemaContainsIgnoreField(schema) {
+	const visited = /* @__PURE__ */ new Set();
+	const walk = (s) => {
+		if (!s || visited.has(s)) return false;
+		visited.add(s);
+		if (s.type === "ignore") return true;
+		switch (s.type) {
+			case "schema":
+			case "loro-map": {
+				const record = s;
+				return Object.values(record.definition).some(walk) || walk(record.catchallType);
+			}
+			case "loro-list":
+			case "loro-movable-list": return walk(s.itemSchema);
+			case "loro-tree": return walk(s.nodeSchema);
+			default: return false;
+		}
+	};
+	return walk(schema);
+}
+/**
+* Type guard for LoroTreeSchema
+*/
+function isLoroTreeSchema(schema) {
+	return !!schema && schema.type === "loro-tree";
+}
+/**
+* Check if a schema is for a Loro container
+*/
+function isContainerSchema(schema) {
+	return !!schema && (schema.type === "loro-map" || schema.type === "loro-list" || schema.type === "loro-text" || schema.type === "loro-movable-list" || schema.type === "loro-tree");
+}
+/**
+* Validate a value against a schema
+*
+* When `options.ignoreUnknownProperties` is true, the root schema check does
+* not reject properties missing from the schema definition — typically
+* written by peers on a newer schema version. (Nested map schemas never
+* reject undeclared properties.)
+*/
+function validateSchema(schema, value, options) {
+	const errors = [];
+	const actualType = schema.type;
+	if (schema.options.required && (value === void 0 || value === null)) {
+		errors.push("Value is required");
+		return {
+			valid: false,
+			errors
+		};
+	}
+	if (value === void 0 || value === null) return { valid: true };
+	const useCache = !options?.ignoreUnknownProperties;
+	if (useCache && isSchemaValidated(schema, value)) return { valid: true };
+	switch (actualType) {
+		case "any":
+			if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && value !== null && value !== void 0 && !Array.isArray(value) && !isObject(value)) errors.push("Value must be JSON-like");
+			break;
+		case "string":
+		case "number":
+		case "boolean":
+			validateTransformablePrimitive(schema, value, actualType, errors);
+			break;
+		case "ignore": break;
+		case "loro-text":
+			if (typeof value !== "string") errors.push("Content must be a string");
+			break;
+		case "loro-map":
+			if (!isObject(value)) errors.push("Value must be an object");
+			else if (isLoroMapSchema(schema)) {
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const propSchema = schema.definition[key];
+					const propValue = value[key];
+					const result = validateSchema(propSchema, propValue);
+					if (!result.valid && result.errors) {
+						const prefixedErrors = result.errors.map((err) => `${key}: ${err}`);
+						errors.push(...prefixedErrors);
+					}
+				}
+			}
+			break;
+		case "loro-movable-list":
+		case "loro-list":
+			if (!Array.isArray(value)) errors.push("Value must be an array");
+			else if (isLoroListSchema(schema) || isLoroMovableListSchema(schema)) {
+				const itemSchema = schema.itemSchema;
+				value.forEach((item, index) => {
+					const result = validateSchema(itemSchema, item);
+					if (!result.valid && result.errors) {
+						const prefixedErrors = result.errors.map((err) => `Item ${index}: ${err}`);
+						errors.push(...prefixedErrors);
+					}
+				});
+			}
+			break;
+		case "loro-tree": {
+			if (!Array.isArray(value)) {
+				errors.push("Value must be an array of tree nodes");
+				break;
+			}
+			if (!isLoroTreeSchema(schema)) {
+				errors.push("Invalid tree schema");
+				break;
+			}
+			const validateNode = (node, path) => {
+				if (!isObject(node)) {
+					errors.push(`${path}: Node must be an object`);
+					return;
+				}
+				const n = node;
+				if (n.id != null && typeof n.id !== "string") errors.push(`${path}: id must be a string if provided`);
+				const dataResult = validateSchema(schema.nodeSchema, n.data);
+				if (!dataResult.valid && dataResult.errors) errors.push(...dataResult.errors.map((e) => `${path}.data: ${e}`));
+				if (!Array.isArray(n.children)) errors.push(`${path}: children must be an array`);
+				else n.children.forEach((child, idx) => {
+					validateNode(child, `${path}.children[${idx}]`);
+				});
+			};
+			value.forEach((node, i) => {
+				validateNode(node, `node[${i}]`);
+			});
+			break;
+		}
+		case "schema":
+			if (!isObject(value)) errors.push("Value must be an object");
+			else if (isRootSchemaType(schema)) if (!isObject(value)) errors.push("Value must be an object");
+			else {
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const propSchema = schema.definition[key];
+					const propValue = value[key];
+					const result = validateSchema(propSchema, propValue);
+					if (!result.valid && result.errors) {
+						const prefixedErrors = result.errors.map((err) => `${key}: ${err}`);
+						errors.push(...prefixedErrors);
+					}
+				}
+				for (const key in value) if (!Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					if (options?.ignoreUnknownProperties) continue;
+					errors.push(`Unknown property: ${key}`);
+				}
+			}
+			else errors.push(`Should be a schema, but got ${actualType}`);
+			break;
+		default: errors.push(`Unknown schema type: ${actualType}`);
+	}
+	if (schema.options.validate && typeof schema.options.validate === "function") try {
+		const customValidation = schema.options.validate(value);
+		if (customValidation !== true) {
+			const errorMessage = typeof customValidation === "string" ? customValidation : "Value failed custom validation";
+			errors.push(errorMessage);
+		}
+	} catch (error) {
+		errors.push(`Validation error: ${String(error)}`);
+	}
+	if (errors.length === 0) {
+		if (useCache) markSchemaValidated(schema, value);
+		return { valid: true };
+	}
+	return {
+		valid: false,
+		errors
+	};
+}
+function validateTransformablePrimitive(schema, value, expectedType, errors) {
+	const transform = getTransform(schema);
+	if (transform) {
+		if (transform.validate) try {
+			const result = transform.validate(value);
+			if (result !== true) errors.push(typeof result === "string" ? result : "Transform validation failed");
+		} catch (error) {
+			errors.push(`Transform validation error: ${String(error)}`);
+		}
+		if (transform.validateEncodedType) try {
+			const encoded = applyEncode(schema, value);
+			if (typeof encoded !== expectedType) errors.push(`Transform encode must return a ${expectedType}, got ${typeof encoded}`);
+		} catch (error) {
+			errors.push(`Transform encode validation error: ${String(error)}`);
+		}
+	} else if (typeof value !== expectedType) errors.push(`Value must be a ${expectedType}`);
+}
+/**
+* Get default value for a schema
+* Based on the schema type, it might return a plain value or a wrapped value
+*/
+function getDefaultValue(schema) {
+	if ("defaultValue" in schema.options) return schema.options.defaultValue;
+	switch (schema.type) {
+		case "any": return;
+		case "string":
+			if (schema.options.required === false) return;
+			if (getTransform(schema)) return;
+			return "";
+		case "number":
+			if (schema.options.required === false) return;
+			if (getTransform(schema)) return;
+			return 0;
+		case "boolean":
+			if (schema.options.required === false) return;
+			if (getTransform(schema)) return;
+			return false;
+		case "loro-text": {
+			const value = schema.options.required ? "" : void 0;
+			if (value === void 0) return void 0;
+			return value;
+		}
+		case "loro-map":
+			if (isLoroMapSchema(schema)) {
+				const result = {};
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const value = getDefaultValue(schema.definition[key]);
+					if (value !== void 0) result[key] = value;
+				}
+				return result;
+			}
+			return {};
+		case "loro-list": return [];
+		case "loro-tree": {
+			const value = schema.options.required ? [] : void 0;
+			if (value === void 0) return void 0;
+			return value;
+		}
+		case "schema":
+			if (isRootSchemaType(schema)) {
+				const result = {};
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const value = getDefaultValue(schema.definition[key]);
+					if (value !== void 0) result[key] = value;
+				}
+				return result;
+			}
+			return {};
+		default: return;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/schema/index.js
+/**
+* Create a schema definition
+*/
+function schema(definition, options) {
+	return {
+		type: "schema",
+		definition,
+		options: options || {},
+		getContainerType() {
+			return "Map";
+		}
+	};
+}
+/**
+* Define a string field
+*/
+schema.String = (function(options) {
+	const baseSchema = {
+		type: "string",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+	return {
+		...baseSchema,
+		transform: (def) => ({
+			...baseSchema,
+			transform: def
+		})
+	};
+});
+/**
+* Define an any field (runtime-inferred by Mirror)
+*/
+schema.Any = function(options) {
+	return {
+		type: "any",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+};
+/**
+* Define a number field
+*/
+schema.Number = function(options) {
+	const baseSchema = {
+		type: "number",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+	return {
+		...baseSchema,
+		transform: (def) => ({
+			...baseSchema,
+			transform: def
+		})
+	};
+};
+/**
+* Define a boolean field
+*/
+schema.Boolean = function(options) {
+	const baseSchema = {
+		type: "boolean",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+	return {
+		...baseSchema,
+		transform: (def) => ({
+			...baseSchema,
+			transform: def
+		})
+	};
+};
+/**
+* Define a field to be ignored (not synced with Loro)
+*/
+schema.Ignore = function(options) {
+	return {
+		type: "ignore",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+};
+/**
+* Define a Loro map
+*/
+schema.LoroMap = function(definition, options) {
+	const baseSchema = {
+		type: "loro-map",
+		definition,
+		options: options || {},
+		getContainerType: () => {
+			return "Map";
+		}
+	};
+	const schemaWithCatchall = {
+		...baseSchema,
+		catchall: (catchallSchema) => {
+			return {
+				...baseSchema,
+				catchallType: catchallSchema,
+				catchall: (newCatchallSchema) => {
+					return {
+						...baseSchema,
+						catchallType: newCatchallSchema,
+						catchall: schemaWithCatchall.catchall
+					};
+				}
+			};
+		}
+	};
+	return schemaWithCatchall;
+};
+/**
+* Create a dynamic record schema (like zod's z.record)
+*/
+schema.LoroMapRecord = function(valueSchema, options) {
+	return {
+		type: "loro-map",
+		definition: {},
+		catchallType: valueSchema,
+		options: options || {},
+		getContainerType: () => {
+			return "Map";
+		},
+		catchall: (newCatchallSchema) => {
+			return schema.LoroMapRecord(newCatchallSchema, options);
+		}
+	};
+};
+/**
+* Define a Loro list
+*/
+schema.LoroList = function(itemSchema, idSelector, options) {
+	return {
+		type: "loro-list",
+		itemSchema,
+		idSelector,
+		options: options || {},
+		getContainerType: () => {
+			return "List";
+		}
+	};
+};
+schema.LoroMovableList = function(itemSchema, idSelector, options) {
+	return {
+		type: "loro-movable-list",
+		itemSchema,
+		idSelector,
+		options: options || {},
+		getContainerType: () => {
+			return "MovableList";
+		}
+	};
+};
+/**
+* Define a Loro text field
+*/
+schema.LoroText = function(options) {
+	return {
+		type: "loro-text",
+		options: options || {},
+		getContainerType: () => {
+			return "Text";
+		}
+	};
+};
+/**
+* Define a Loro tree
+*
+* Each tree node has a `data` map described by `nodeSchema`.
+*/
+schema.LoroTree = function(nodeSchema, options) {
+	return {
+		type: "loro-tree",
+		nodeSchema,
+		options: options || {},
+		getContainerType() {
+			return "Tree";
+		}
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/immer@10.2.0/node_modules/immer/dist/immer.mjs
+var NOTHING = Symbol.for("immer-nothing");
+var DRAFTABLE = Symbol.for("immer-draftable");
+var DRAFT_STATE = Symbol.for("immer-state");
+var errors = [
+	function(plugin) {
+		return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \`enable${plugin}()\` when initializing your application.`;
+	},
+	function(thing) {
+		return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;
+	},
+	"This object has been frozen and should not be mutated",
+	function(data) {
+		return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + data;
+	},
+	"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+	"Immer forbids circular references",
+	"The first or second argument to `produce` must be a function",
+	"The third argument to `produce` must be a function or undefined",
+	"First argument to `createDraft` must be a plain object, an array, or an immerable object",
+	"First argument to `finishDraft` must be a draft returned by `createDraft`",
+	function(thing) {
+		return `'current' expects a draft, got: ${thing}`;
+	},
+	"Object.defineProperty() cannot be used on an Immer draft",
+	"Object.setPrototypeOf() cannot be used on an Immer draft",
+	"Immer only supports deleting array indices",
+	"Immer only supports setting array indices and the 'length' property",
+	function(thing) {
+		return `'original' expects a draft, got: ${thing}`;
+	}
+];
+function die(error, ...args) {
+	{
+		const e = errors[error];
+		const msg = typeof e === "function" ? e.apply(null, args) : e;
+		throw new Error(`[Immer] ${msg}`);
+	}
+	throw new Error(`[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`);
+}
+var getPrototypeOf = Object.getPrototypeOf;
+function isDraft(value) {
+	return !!value && !!value[DRAFT_STATE];
+}
+function isDraftable(value) {
+	if (!value) return false;
+	return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+}
+var objectCtorString = Object.prototype.constructor.toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
+function isPlainObject(value) {
+	if (!value || typeof value !== "object") return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto === null || proto === Object.prototype) return true;
+	const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+	if (Ctor === Object) return true;
+	if (typeof Ctor !== "function") return false;
+	let ctorString = cachedCtorStrings.get(Ctor);
+	if (ctorString === void 0) {
+		ctorString = Function.toString.call(Ctor);
+		cachedCtorStrings.set(Ctor, ctorString);
+	}
+	return ctorString === objectCtorString;
+}
+function each(obj, iter, strict = true) {
+	if (getArchtype(obj) === 0) (strict ? Reflect.ownKeys(obj) : Object.keys(obj)).forEach((key) => {
+		iter(key, obj[key], obj);
+	});
+	else obj.forEach((entry, index) => iter(index, entry, obj));
+}
+function getArchtype(thing) {
+	const state = thing[DRAFT_STATE];
+	return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+}
+function has(thing, prop) {
+	return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+}
+function set(thing, propOrOldValue, value) {
+	const t = getArchtype(thing);
+	if (t === 2) thing.set(propOrOldValue, value);
+	else if (t === 3) thing.add(value);
+	else thing[propOrOldValue] = value;
+}
+function is(x, y) {
+	if (x === y) return x !== 0 || 1 / x === 1 / y;
+	else return x !== x && y !== y;
+}
+function isMap(target) {
+	return target instanceof Map;
+}
+function isSet(target) {
+	return target instanceof Set;
+}
+function latest(state) {
+	return state.copy_ || state.base_;
+}
+function shallowCopy(base, strict) {
+	if (isMap(base)) return new Map(base);
+	if (isSet(base)) return new Set(base);
+	if (Array.isArray(base)) return Array.prototype.slice.call(base);
+	const isPlain = isPlainObject(base);
+	if (strict === true || strict === "class_only" && !isPlain) {
+		const descriptors = Object.getOwnPropertyDescriptors(base);
+		delete descriptors[DRAFT_STATE];
+		let keys = Reflect.ownKeys(descriptors);
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			const desc = descriptors[key];
+			if (desc.writable === false) {
+				desc.writable = true;
+				desc.configurable = true;
+			}
+			if (desc.get || desc.set) descriptors[key] = {
+				configurable: true,
+				writable: true,
+				enumerable: desc.enumerable,
+				value: base[key]
+			};
+		}
+		return Object.create(getPrototypeOf(base), descriptors);
+	} else {
+		const proto = getPrototypeOf(base);
+		if (proto !== null && isPlain) return { ...base };
+		return Object.assign(Object.create(proto), base);
+	}
+}
+function freeze(obj, deep = false) {
+	if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
+	if (getArchtype(obj) > 1) Object.defineProperties(obj, {
+		set: dontMutateMethodOverride,
+		add: dontMutateMethodOverride,
+		clear: dontMutateMethodOverride,
+		delete: dontMutateMethodOverride
+	});
+	Object.freeze(obj);
+	if (deep) Object.values(obj).forEach((value) => freeze(value, true));
+	return obj;
+}
+function dontMutateFrozenCollections() {
+	die(2);
+}
+var dontMutateMethodOverride = { value: dontMutateFrozenCollections };
+function isFrozen(obj) {
+	if (obj === null || typeof obj !== "object") return true;
+	return Object.isFrozen(obj);
+}
+var plugins = {};
+function getPlugin(pluginKey) {
+	const plugin = plugins[pluginKey];
+	if (!plugin) die(0, pluginKey);
+	return plugin;
+}
+var currentScope;
+function getCurrentScope() {
+	return currentScope;
+}
+function createScope(parent_, immer_) {
+	return {
+		drafts_: [],
+		parent_,
+		immer_,
+		canAutoFreeze_: true,
+		unfinalizedDrafts_: 0
+	};
+}
+function usePatchesInScope(scope, patchListener) {
+	if (patchListener) {
+		getPlugin("Patches");
+		scope.patches_ = [];
+		scope.inversePatches_ = [];
+		scope.patchListener_ = patchListener;
+	}
+}
+function revokeScope(scope) {
+	leaveScope(scope);
+	scope.drafts_.forEach(revokeDraft);
+	scope.drafts_ = null;
+}
+function leaveScope(scope) {
+	if (scope === currentScope) currentScope = scope.parent_;
+}
+function enterScope(immer2) {
+	return currentScope = createScope(currentScope, immer2);
+}
+function revokeDraft(draft) {
+	const state = draft[DRAFT_STATE];
+	if (state.type_ === 0 || state.type_ === 1) state.revoke_();
+	else state.revoked_ = true;
+}
+function processResult(result, scope) {
+	scope.unfinalizedDrafts_ = scope.drafts_.length;
+	const baseDraft = scope.drafts_[0];
+	if (result !== void 0 && result !== baseDraft) {
+		if (baseDraft[DRAFT_STATE].modified_) {
+			revokeScope(scope);
+			die(4);
+		}
+		if (isDraftable(result)) {
+			result = finalize(scope, result);
+			if (!scope.parent_) maybeFreeze(scope, result);
+		}
+		if (scope.patches_) getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_);
+	} else result = finalize(scope, baseDraft, []);
+	revokeScope(scope);
+	if (scope.patches_) scope.patchListener_(scope.patches_, scope.inversePatches_);
+	return result !== NOTHING ? result : void 0;
+}
+function finalize(rootScope, value, path) {
+	if (isFrozen(value)) return value;
+	const useStrictIteration = rootScope.immer_.shouldUseStrictIteration();
+	const state = value[DRAFT_STATE];
+	if (!state) {
+		each(value, (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path), useStrictIteration);
+		return value;
+	}
+	if (state.scope_ !== rootScope) return value;
+	if (!state.modified_) {
+		maybeFreeze(rootScope, state.base_, true);
+		return state.base_;
+	}
+	if (!state.finalized_) {
+		state.finalized_ = true;
+		state.scope_.unfinalizedDrafts_--;
+		const result = state.copy_;
+		let resultEach = result;
+		let isSet2 = false;
+		if (state.type_ === 3) {
+			resultEach = new Set(result);
+			result.clear();
+			isSet2 = true;
+		}
+		each(resultEach, (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2), useStrictIteration);
+		maybeFreeze(rootScope, result, false);
+		if (path && rootScope.patches_) getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_);
+	}
+	return state.copy_;
+}
+function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+	if (childValue == null) return;
+	if (typeof childValue !== "object" && !targetIsSet) return;
+	const childIsFrozen = isFrozen(childValue);
+	if (childIsFrozen && !targetIsSet) return;
+	if (childValue === targetObject) die(5);
+	if (isDraft(childValue)) {
+		const res = finalize(rootScope, childValue, rootPath && parentState && parentState.type_ !== 3 && !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0);
+		set(targetObject, prop, res);
+		if (isDraft(res)) rootScope.canAutoFreeze_ = false;
+		else return;
+	} else if (targetIsSet) targetObject.add(childValue);
+	if (isDraftable(childValue) && !childIsFrozen) {
+		if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) return;
+		if (parentState && parentState.base_ && parentState.base_[prop] === childValue && childIsFrozen) return;
+		finalize(rootScope, childValue);
+		if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && (isMap(targetObject) ? targetObject.has(prop) : Object.prototype.propertyIsEnumerable.call(targetObject, prop))) maybeFreeze(rootScope, childValue);
+	}
+}
+function maybeFreeze(scope, value, deep = false) {
+	if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) freeze(value, deep);
+}
+function createProxyProxy(base, parent) {
+	const isArray = Array.isArray(base);
+	const state = {
+		type_: isArray ? 1 : 0,
+		scope_: parent ? parent.scope_ : getCurrentScope(),
+		modified_: false,
+		finalized_: false,
+		assigned_: {},
+		parent_: parent,
+		base_: base,
+		draft_: null,
+		copy_: null,
+		revoke_: null,
+		isManual_: false
+	};
+	let target = state;
+	let traps = objectTraps;
+	if (isArray) {
+		target = [state];
+		traps = arrayTraps;
+	}
+	const { revoke, proxy } = Proxy.revocable(target, traps);
+	state.draft_ = proxy;
+	state.revoke_ = revoke;
+	return proxy;
+}
+var objectTraps = {
+	get(state, prop) {
+		if (prop === DRAFT_STATE) return state;
+		const source = latest(state);
+		if (!has(source, prop)) return readPropFromProto(state, source, prop);
+		const value = source[prop];
+		if (state.finalized_ || !isDraftable(value)) return value;
+		if (value === peek(state.base_, prop)) {
+			prepareCopy(state);
+			return state.copy_[prop] = createProxy(value, state);
+		}
+		return value;
+	},
+	has(state, prop) {
+		return prop in latest(state);
+	},
+	ownKeys(state) {
+		return Reflect.ownKeys(latest(state));
+	},
+	set(state, prop, value) {
+		const desc = getDescriptorFromProto(latest(state), prop);
+		if (desc?.set) {
+			desc.set.call(state.draft_, value);
+			return true;
+		}
+		if (!state.modified_) {
+			const current2 = peek(latest(state), prop);
+			const currentState = current2?.[DRAFT_STATE];
+			if (currentState && currentState.base_ === value) {
+				state.copy_[prop] = value;
+				state.assigned_[prop] = false;
+				return true;
+			}
+			if (is(value, current2) && (value !== void 0 || has(state.base_, prop))) return true;
+			prepareCopy(state);
+			markChanged(state);
+		}
+		if (state.copy_[prop] === value && (value !== void 0 || prop in state.copy_) || Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true;
+		state.copy_[prop] = value;
+		state.assigned_[prop] = true;
+		return true;
+	},
+	deleteProperty(state, prop) {
+		if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+			state.assigned_[prop] = false;
+			prepareCopy(state);
+			markChanged(state);
+		} else delete state.assigned_[prop];
+		if (state.copy_) delete state.copy_[prop];
+		return true;
+	},
+	getOwnPropertyDescriptor(state, prop) {
+		const owner = latest(state);
+		const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+		if (!desc) return desc;
+		return {
+			writable: true,
+			configurable: state.type_ !== 1 || prop !== "length",
+			enumerable: desc.enumerable,
+			value: owner[prop]
+		};
+	},
+	defineProperty() {
+		die(11);
+	},
+	getPrototypeOf(state) {
+		return getPrototypeOf(state.base_);
+	},
+	setPrototypeOf() {
+		die(12);
+	}
+};
+var arrayTraps = {};
+each(objectTraps, (key, fn) => {
+	arrayTraps[key] = function() {
+		arguments[0] = arguments[0][0];
+		return fn.apply(this, arguments);
+	};
+});
+arrayTraps.deleteProperty = function(state, prop) {
+	if (isNaN(parseInt(prop))) die(13);
+	return arrayTraps.set.call(this, state, prop, void 0);
+};
+arrayTraps.set = function(state, prop, value) {
+	if (prop !== "length" && isNaN(parseInt(prop))) die(14);
+	return objectTraps.set.call(this, state[0], prop, value, state[0]);
+};
+function peek(draft, prop) {
+	const state = draft[DRAFT_STATE];
+	return (state ? latest(state) : draft)[prop];
 }
-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
-			},
-			source: source.id
+function readPropFromProto(state, source, prop) {
+	const desc = getDescriptorFromProto(source, prop);
+	return desc ? `value` in desc ? desc.value : desc.get?.call(state.draft_) : void 0;
+}
+function getDescriptorFromProto(source, prop) {
+	if (!(prop in source)) return void 0;
+	let proto = getPrototypeOf(source);
+	while (proto) {
+		const desc = Object.getOwnPropertyDescriptor(proto, prop);
+		if (desc) return desc;
+		proto = getPrototypeOf(proto);
+	}
+}
+function markChanged(state) {
+	if (!state.modified_) {
+		state.modified_ = true;
+		if (state.parent_) markChanged(state.parent_);
+	}
+}
+function prepareCopy(state) {
+	if (!state.copy_) state.copy_ = shallowCopy(state.base_, state.scope_.immer_.useStrictShallowCopy_);
+}
+var Immer2 = class {
+	constructor(config) {
+		this.autoFreeze_ = true;
+		this.useStrictShallowCopy_ = false;
+		this.useStrictIteration_ = true;
+		/**
+		* The `produce` function takes a value and a "recipe function" (whose
+		* return value often depends on the base state). The recipe function is
+		* free to mutate its first argument however it wants. All mutations are
+		* only ever applied to a __copy__ of the base state.
+		*
+		* Pass only a function to create a "curried producer" which relieves you
+		* from passing the recipe function every time.
+		*
+		* Only plain objects and arrays are made mutable. All other objects are
+		* considered uncopyable.
+		*
+		* Note: This function is __bound__ to its `Immer` instance.
+		*
+		* @param {any} base - the initial state
+		* @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
+		* @param {Function} patchListener - optional function that will be called with all the patches produced here
+		* @returns {any} a new state, or the initial state if nothing was modified
+		*/
+		this.produce = (base, recipe, patchListener) => {
+			if (typeof base === "function" && typeof recipe !== "function") {
+				const defaultBase = recipe;
+				recipe = base;
+				const self = this;
+				return function curriedProduce(base2 = defaultBase, ...args) {
+					return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+				};
+			}
+			if (typeof recipe !== "function") die(6);
+			if (patchListener !== void 0 && typeof patchListener !== "function") die(7);
+			let result;
+			if (isDraftable(base)) {
+				const scope = enterScope(this);
+				const proxy = createProxy(base, void 0);
+				let hasError = true;
+				try {
+					result = recipe(proxy);
+					hasError = false;
+				} finally {
+					if (hasError) revokeScope(scope);
+					else leaveScope(scope);
+				}
+				usePatchesInScope(scope, patchListener);
+				return processResult(result, scope);
+			} else if (!base || typeof base !== "object") {
+				result = recipe(base);
+				if (result === void 0) result = base;
+				if (result === NOTHING) result = void 0;
+				if (this.autoFreeze_) freeze(result, true);
+				if (patchListener) {
+					const p = [];
+					const ip = [];
+					getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+					patchListener(p, ip);
+				}
+				return result;
+			} else die(1, base);
+		};
+		this.produceWithPatches = (base, recipe) => {
+			if (typeof base === "function") return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+			let patches, inversePatches;
+			return [
+				this.produce(base, recipe, (p, ip) => {
+					patches = p;
+					inversePatches = ip;
+				}),
+				patches,
+				inversePatches
+			];
+		};
+		if (typeof config?.autoFreeze === "boolean") this.setAutoFreeze(config.autoFreeze);
+		if (typeof config?.useStrictShallowCopy === "boolean") this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+		if (typeof config?.useStrictIteration === "boolean") this.setUseStrictIteration(config.useStrictIteration);
+	}
+	createDraft(base) {
+		if (!isDraftable(base)) die(8);
+		if (isDraft(base)) base = current(base);
+		const scope = enterScope(this);
+		const proxy = createProxy(base, void 0);
+		proxy[DRAFT_STATE].isManual_ = true;
+		leaveScope(scope);
+		return proxy;
+	}
+	finishDraft(draft, patchListener) {
+		const state = draft && draft[DRAFT_STATE];
+		if (!state || !state.isManual_) die(9);
+		const { scope_: scope } = state;
+		usePatchesInScope(scope, patchListener);
+		return processResult(void 0, scope);
+	}
+	/**
+	* Pass true to automatically freeze all copies created by Immer.
+	*
+	* By default, auto-freezing is enabled.
+	*/
+	setAutoFreeze(value) {
+		this.autoFreeze_ = value;
+	}
+	/**
+	* Pass true to enable strict shallow copy.
+	*
+	* By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+	*/
+	setUseStrictShallowCopy(value) {
+		this.useStrictShallowCopy_ = value;
+	}
+	/**
+	* Pass false to use faster iteration that skips non-enumerable properties
+	* but still handles symbols for compatibility.
+	*
+	* By default, strict iteration is enabled (includes all own properties).
+	*/
+	setUseStrictIteration(value) {
+		this.useStrictIteration_ = value;
+	}
+	shouldUseStrictIteration() {
+		return this.useStrictIteration_;
+	}
+	applyPatches(base, patches) {
+		let i;
+		for (i = patches.length - 1; i >= 0; i--) {
+			const patch = patches[i];
+			if (patch.path.length === 0 && patch.op === "replace") {
+				base = patch.value;
+				break;
+			}
 		}
-	}];
+		if (i > -1) patches = patches.slice(i + 1);
+		const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+		if (isDraft(base)) return applyPatchesImpl(base, patches);
+		return this.produce(base, (draft) => applyPatchesImpl(draft, patches));
+	}
+};
+function createProxy(value, parent) {
+	const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+	(parent ? parent.scope_ : getCurrentScope()).drafts_.push(draft);
+	return draft;
+}
+function current(value) {
+	if (!isDraft(value)) die(10, value);
+	return currentImpl(value);
+}
+function currentImpl(value) {
+	if (!isDraftable(value) || isFrozen(value)) return value;
+	const state = value[DRAFT_STATE];
+	let copy;
+	let strict = true;
+	if (state) {
+		if (!state.modified_) return state.base_;
+		state.finalized_ = true;
+		copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+		strict = state.scope_.immer_.shouldUseStrictIteration();
+	} else copy = shallowCopy(value, true);
+	each(copy, (key, childValue) => {
+		set(copy, key, currentImpl(childValue));
+	}, strict);
+	if (state) state.finalized_ = false;
+	return copy;
 }
-const produce = new Immer({
+var immer = new Immer2();
+immer.produce;
+var setAutoFreeze = /* @__PURE__ */ immer.setAutoFreeze.bind(immer);
+const produce = new Immer2({
 	autoFreeze: false,
 	useStrictShallowCopy: true
 }).produce;
 //#endregion
-//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/debounce-timer.js
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/debounce-timer.js
 /**
 * Deadline-based debounce timer.
 *
@@ -944,7 +2823,7 @@ var DebounceTimer = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/ephemeral.js
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/ephemeral.js
 /**
 * Manages ephemeral patches: storage, composition, path resolution, and finalization.
 */
@@ -1219,7 +3098,7 @@ var EphemeralPatchManager = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/tree-utils.js
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/tree-utils.js
 function normalizeTreeJson(input, options) {
 	if (!Array.isArray(input)) return [];
 	return input.map((node) => normalizeTreeNode(node, options));
@@ -1242,7 +3121,7 @@ function isPlainRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/loroEventApply.js
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/loroEventApply.js
 function isJSONObject(v) {
 	return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -1664,7 +3543,7 @@ function isIgnoredByAncestor(id, ignoreSet, getContainerById) {
 	return false;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/diff.js
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/diff.js
 /**
 * Finds the longest increasing subsequence of a sequence of numbers
 * @param sequence The sequence of numbers
@@ -2395,7 +4274,7 @@ function diffMap(doc, oldState, newState, containerId, schema, inferOptions) {
 	return changes;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/mirror.js
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.4/node_modules/loro-mirror/dist/core/mirror.js
 /**
 * Mirror core functionality for bidirectional sync between app state and Loro CRDT
 */
@@ -3890,6 +5769,220 @@ function mergeInitialIntoBaseWithSchema(base, init, rootSchema) {
 	}
 }
 //#endregion
+//#region ../medeo-dsl/src/schema/codec.ts
+function isInvalidAtomic(value) {
+	return typeof value === "object" && value !== null && "invalid" in value && value.invalid === true;
+}
+function codec(encode, decode) {
+	return {
+		encode: (v) => isInvalidAtomic(v) ? v.raw : encode(v),
+		decode: (raw) => {
+			try {
+				return decode(raw);
+			} catch (error) {
+				return {
+					invalid: true,
+					raw,
+					reason: String(error)
+				};
+			}
+		}
+	};
+}
+/** A Clip's time anchor; the Clip holding it is the anchored end. */
+const timeAnchorCodec = codec((v) => {
+	assertTimeAnchor(v);
+	return JSON.stringify({
+		to: v.to,
+		offsetMs: v.offsetMs,
+		fallback_abs_ms: v.fallback_abs_ms
+	});
+}, (raw) => {
+	const v = JSON.parse(raw);
+	assertTimeAnchor(v);
+	return v;
+});
+/** A segment selection as stored: a run's Cursors as their native bytes in unpadded base64url. */
+function encodeSelection(v) {
+	return {
+		audioScriptId: v.audioScriptId,
+		segmentId: v.segmentId,
+		...v.start === void 0 || v.end === void 0 ? {} : {
+			start: bytesToBase64url(v.start.encode()),
+			end: bytesToBase64url(v.end.encode())
+		}
+	};
+}
+function decodeSelection(v) {
+	if (!v || typeof v !== "object") throw new Error("Expected a segment selection");
+	const { start, end, ...rest } = v;
+	if (start === void 0 && end === void 0) return rest;
+	if (typeof start !== "string" || typeof end !== "string") throw new Error("Expected encoded Cursor pair");
+	return {
+		...rest,
+		start: Cursor.decode(base64urlToBytes(start)),
+		end: Cursor.decode(base64urlToBytes(end))
+	};
+}
+/** A Caption's selection. */
+const captionContentCodec = codec((v) => {
+	assertCaptionContent(v);
+	return JSON.stringify(encodeSelection(v));
+}, (raw) => {
+	const value = decodeSelection(JSON.parse(raw));
+	assertCaptionContent(value);
+	return value;
+});
+/** A PhoneticScript's selection and what to synthesize for it, stored as one string so they move together. */
+const phonemeCodec = codec((v) => {
+	assertPhoneme(v);
+	return JSON.stringify({
+		...encodeSelection(v),
+		...v.phonemeScript === void 0 ? {} : { phonemeScript: v.phonemeScript }
+	});
+}, (raw) => {
+	const value = decodeSelection(JSON.parse(raw));
+	assertPhoneme(value);
+	return value;
+});
+/** A Clip's sequence marker is stored as one string, so it is taken or replaced whole. */
+const seqMarkerCodec = codec((v) => {
+	assertSeqMarker(v);
+	return JSON.stringify({
+		inMs: v.inMs,
+		outMs: v.outMs,
+		...v.rate === void 0 ? {} : { rate: v.rate },
+		...v.fillTimeline === void 0 ? {} : { fillTimeline: v.fillTimeline }
+	});
+}, (raw) => {
+	const v = JSON.parse(raw);
+	assertSeqMarker(v);
+	return v;
+});
+//#endregion
+//#region ../medeo-dsl/src/schema/loro-shape.ts
+const optional = { required: false };
+const mergeable = { mergeableMapChildContainers: true };
+const strings = (keys) => Object.fromEntries(keys.map((key) => [key, schema.String()]));
+const relation = (keys) => schema.LoroMapRecord(schema.LoroMap(strings(keys)), mergeable);
+const transform = (codec) => ({
+	...codec,
+	isEqual: "encoded-value-equality",
+	validateEncodedType: true
+});
+/** One field stored as one encoded string, so it is taken or replaced whole. */
+const atomicValue = (codec) => schema.String().transform(transform(codec));
+const optionalAtomicValue = (codec) => schema.String(optional).transform(transform(codec));
+/**
+* Only direct children inherit mergeable identity. Text and ordinary entity rows keep normal
+* identities, so deleting a row also drops what a peer wrote into it concurrently: a relation an
+* entity holds at most one of is a field of that row and never outlives it.
+*/
+const medeoDslLoroShape = schema({
+	"timeline-entities": schema.LoroMapRecord(schema.LoroMap({})),
+	"track-entities": schema.LoroMapRecord(schema.LoroMap({
+		role: schema.String(),
+		hidden: schema.Boolean(optional)
+	})),
+	"clip-entities": schema.LoroMapRecord(schema.LoroMap({
+		seqMarker: atomicValue(seqMarkerCodec),
+		volume: schema.Number(optional),
+		source: schema.String(),
+		anchor: optionalAtomicValue(timeAnchorCodec)
+	})),
+	"media-entities": schema.LoroMapRecord(schema.LoroMap({
+		kind: schema.String(),
+		system: schema.String(),
+		key: schema.String(),
+		storageKey: schema.String(optional),
+		durationMs: schema.Number(optional),
+		digest: schema.String(optional)
+	}), mergeable),
+	"audio-script-entities": schema.LoroMapRecord(schema.LoroMap({
+		segments: schema.LoroMovableList(schema.LoroMap({
+			id: schema.String(),
+			text: schema.LoroText(),
+			startMs: schema.Number(optional),
+			endMs: schema.Number(optional)
+		}), (segment) => segment.id),
+		defaultLanguage: schema.String(optional),
+		system: schema.String(optional),
+		key: schema.String(optional),
+		storageKey: schema.String(optional),
+		digest: schema.String(optional)
+	})),
+	"phonetic-script-entities": schema.LoroMapRecord(schema.LoroMap({
+		phoneme: atomicValue(phonemeCodec),
+		system: schema.String(optional),
+		key: schema.String(optional),
+		storageKey: schema.String(optional),
+		digest: schema.String(optional)
+	})),
+	"caption-entities": schema.LoroMapRecord(schema.LoroMap({
+		selection: optionalAtomicValue(captionContentCodec),
+		text: schema.LoroText(optional),
+		style: schema.LoroMap({
+			font: schema.LoroMap({
+				system: schema.String(),
+				key: schema.String()
+			}, optional),
+			fontSize: schema.Number(optional),
+			fontColor: schema.String(optional),
+			fontWeight: schema.Number(optional),
+			entranceAnimation: schema.String(optional),
+			entranceAnimationDurationMs: schema.Number(optional),
+			strokeColor: schema.String(optional),
+			strokeWidth: schema.Number(optional),
+			positionX: schema.Number(optional),
+			positionY: schema.Number(optional)
+		}, {
+			...optional,
+			...mergeable
+		})
+	}, mergeable)),
+	"voice-entities": schema.LoroMapRecord(schema.LoroMap({
+		system: schema.String(),
+		key: schema.String(),
+		name: schema.String(optional)
+	}), mergeable),
+	"contain-relations": schema.LoroTree(schema.LoroMap({ entityId: schema.String() })),
+	"voice-timbre-relations": relation(["recordingId", "voiceId"]),
+	"derived-from-relations": schema.LoroMapRecord(schema.LoroMap({
+		entityId: schema.String(),
+		sourceId: schema.String(),
+		sourceDigest: schema.String(optional)
+	}), mergeable)
+});
+//#endregion
+//#region ../medeo-dsl/src/schema/document-format.ts
+/** Format discrimination does not register containers or alter the document. */
+function documentFormat(doc) {
+	const roots = doc.getShallowValue();
+	const legacy = [
+		"medeo",
+		"timeline",
+		"tracks",
+		"part_library"
+	].some((key) => Object.hasOwn(roots, key));
+	const dsl = Object.keys(roots).some((key) => key.endsWith("-entities") || key.endsWith("-relations"));
+	return legacy && dsl ? "mixed" : legacy ? "legacy" : dsl ? "dsl" : "unknown";
+}
+var UnsupportedDocumentFormatError = class extends Error {
+	code = "unsupported_document_format";
+	constructor() {
+		super("Expected a new DSL document; legacy, mixed or uninitialized content is not supported");
+		this.name = "UnsupportedDocumentFormatError";
+	}
+};
+/** Run after initial import, before opening an editable handle. Empty new documents still have one Timeline. */
+function assertDslDocument(doc) {
+	if (documentFormat(doc) !== "dsl" || doc.getMap("timeline-entities").keys().length !== 1) throw new UnsupportedDocumentFormatError();
+}
+//#endregion
+//#region ../medeo-dsl/src/schema/text-styles.ts
+/** How rich-text marks extend at their edges: a language runs on into text typed after it. */
+const textStyles = { language: { expand: "after" } };
+//#endregion
 //#region src/dsl/document/read.ts
 /** Looking up a missing root must not create it. */
 function rootMap(doc, name) {
@@ -3898,11 +5991,21 @@ function rootMap(doc, name) {
 	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 asMap(value) {
+	return isContainer(value) && value.kind() === "Map" ? value : void 0;
+}
+function asText(value) {
+	return isContainer(value) && value.kind() === "Text" && !value.isDeleted() ? value : void 0;
+}
+/** The live Text a target names: a Caption's own, or a script segment's. */
+function liveText(doc, target) {
+	if ("captionId" in target) return asText(asMap(rootMap(doc, "caption-entities")?.get(target.captionId))?.get("text"));
+	const segments = asMap(rootMap(doc, "audio-script-entities")?.get(target.audioScriptId))?.get("segments");
+	if (!isContainer(segments) || segments.kind() !== "MovableList") return;
+	for (const item of segments.toArray()) {
+		const segment = asMap(item);
+		if (segment?.get("id") === target.segmentId) return asText(segment.get("text"));
+	}
 }
 function readContainNodes(nodes) {
 	const read = (nodes) => nodes.map((node) => ({
@@ -3912,19 +6015,41 @@ function readContainNodes(nodes) {
 	}));
 	return read(nodes);
 }
+/** What a selection holds now: its whole segment, or the run between its Cursors on that segment's Text. */
 function resolveContent(doc, content) {
-	const text = liveText(doc, content.audioScriptId);
-	if (!text || content.start.containerId() !== text.id || content.end.containerId() !== text.id) return;
+	const text = liveText(doc, {
+		audioScriptId: content.audioScriptId,
+		segmentId: content.segmentId
+	});
+	if (!text) return;
+	const whole = text.toString();
+	if (content.start === void 0 || content.end === void 0) return {
+		text: whole,
+		start: 0,
+		end: whole.length,
+		bodyId: text.id
+	};
+	if (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),
+		text: whole.slice(start, end),
 		start,
 		end,
 		bodyId: text.id
 	};
 }
+function richTextOf(text) {
+	return {
+		bodyId: text.id,
+		plainText: text.toString(),
+		delta: text.toDelta().flatMap((run) => typeof run.insert === "string" ? [{
+			insert: run.insert,
+			...run.attributes ? { attributes: run.attributes } : {}
+		}] : [])
+	};
+}
 /** Optional relation fields read apart from their row: an unreadable one is dropped, the row is kept. */
 const optionalReferences = {
 	"clip-entities": ["anchor"],
@@ -3962,19 +6087,16 @@ function readMedeoDsl(doc, state) {
 		}
 		assertEntity(table, v);
 		assertResourceIdentity(table, id, v);
+		if (table === "phonetic-script-entities") assertPhoneticScript(void 0, v);
+		const texts = [];
+		if (table === "audio-script-entities") for (const segment of v.segments) texts.push([segment.id, liveText(doc, {
+			audioScriptId: id,
+			segmentId: segment.id
+		})]);
+		if (table === "caption-entities" && v.text !== void 0) texts.push([id, liveText(doc, { captionId: id })]);
+		for (const [, text] of texts) if (!text) throw new Error("Missing live LoroText");
 		entities[table][id] = v;
-		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 } : {}
-				}] : [])
-			};
-		}
+		for (const [key, text] of texts) richText[key] = richTextOf(text);
 	} catch (error) {
 		delete entities[table][id];
 		diagnostic("invalid-entity", `${table}/${id}`, error);
@@ -4033,17 +6155,26 @@ function readMedeoDsl(doc, state) {
 		try {
 			const resolved = resolveContent(doc, caption.selection);
 			if (resolved) captionText[id] = resolved;
-			else diagnostic("invalid-caption-content", `caption-entities/${id}/selection`, "Cursor does not resolve in the current body");
+			else diagnostic("invalid-caption-content", `caption-entities/${id}/selection`, "Selection does not resolve in its current segment");
 		} catch (error) {
 			diagnostic("invalid-caption-content", `caption-entities/${id}/selection`, error);
 		}
 	}
+	const phoneticText = {};
+	for (const [id, phonetic] of Object.entries(entities["phonetic-script-entities"])) try {
+		const resolved = resolveContent(doc, phonetic.phoneme);
+		if (resolved) phoneticText[id] = resolved;
+		else diagnostic("invalid-phoneme", `phonetic-script-entities/${id}/phoneme`, "Selection does not resolve in its current segment");
+	} catch (error) {
+		diagnostic("invalid-phoneme", `phonetic-script-entities/${id}/phoneme`, error);
+	}
 	return freezeSnapshot({
 		...entities,
 		...relations,
 		"contain-relations": validTree(treeNodes),
 		richText,
 		captionText,
+		phoneticText,
 		diagnostics
 	});
 }
@@ -4056,6 +6187,19 @@ function freezeSnapshot(value) {
 }
 //#endregion
 //#region src/dsl/document/draft.ts
+function textKey(target) {
+	return "captionId" in target ? JSON.stringify(["caption", target.captionId]) : JSON.stringify([
+		"segment",
+		target.audioScriptId,
+		target.segmentId
+	]);
+}
+/** Rows holding a segment selection, by the field that holds it (D181). */
+const selectionField = {
+	"caption-entities": "selection",
+	"phonetic-script-entities": "phoneme"
+};
+const isSelectionTable = (table) => Object.hasOwn(selectionField, table);
 const entities = new Set(entityTables);
 const relations = new Set(relationTables);
 const reserved = new Set([
@@ -4088,9 +6232,10 @@ var TransactionDraft = class {
 	entities = /* @__PURE__ */ new Map();
 	relations = /* @__PURE__ */ new Map();
 	deleted = /* @__PURE__ */ new Set();
+	/** Texts this write edits, by {@link textKey}, as its edits so far leave them. */
 	textPreviews = /* @__PURE__ */ new Map();
-	/** Captions whose selection the draft wrote; they are replayed natively in order with text edits. */
-	dirtyCaptions = /* @__PURE__ */ new Set();
+	/** Selections the draft wrote, by table then row; they are replayed natively in order with text edits. */
+	dirty = /* @__PURE__ */ new Map();
 	removedCaptionTexts = /* @__PURE__ */ new Set();
 	treeChanged = false;
 	active = true;
@@ -4121,13 +6266,30 @@ var TransactionDraft = class {
 	close() {
 		this.active = false;
 	}
+	dirtySelections() {
+		return [...this.dirty].flatMap(([table, ids]) => [...ids].map((id) => [table, id]));
+	}
+	clearDirtySelections() {
+		this.dirty.clear();
+	}
+	/** Whether this write edits any segment of a script. */
+	usesScript(scriptId) {
+		const prefix = JSON.stringify(["segment", scriptId]).slice(0, -1) + ",";
+		return [...this.textPreviews.keys()].some((key) => key.startsWith(prefix));
+	}
 	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 (key === "text") {
+					const preview = path[0] === "caption-entities" && path.length === 2 ? this.textPreviews.get(textKey({ captionId: path[1] })) : path[0] === "audio-script-entities" && path[2] === "segments" && path.length === 4 ? this.textPreviews.get(textKey({
+						audioScriptId: path[1],
+						segmentId: String(target.id)
+					})) : void 0;
+					if (preview !== void 0) return preview;
+				}
 				if (!path.length && key === "contain-relations" && target[key] === void 0) target[key] = [];
 				return this.wrap(Reflect.get(target, key), [...path, String(key)]);
 			}),
@@ -4182,16 +6344,22 @@ var TransactionDraft = class {
 			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 ((path.length === 2 && key === "segments" || path[2] === "segments" || path.length === 1 && initial && isRecord(next) && !sameSegments(next.segments, initial.segments)) && (initial || this.usesScript(rowId))) throw new Error("Change segments with segment mutations and edit their text through the Text adapter");
+				if (path.length === 1 && this.usesScript(rowId)) throw new Error("Cannot delete or replace a Text used in this transaction");
+			}
+			if (isSelectionTable(table)) {
+				const field = selectionField[table];
+				if (path.length === 1 && isRecord(next) && Object.hasOwn(next, field) || path.length === 2 && key === field || path[2] === field) {
+					let ids = this.dirty.get(table);
+					if (!ids) this.dirty.set(table, ids = /* @__PURE__ */ new Set());
+					ids.add(rowId);
+				}
 			}
 			if (table === "caption-entities") {
-				if (path.length === 1 && isRecord(next) && Object.hasOwn(next, "selection") || path.length === 2 && key === "selection" || path[2] === "selection") this.dirtyCaptions.add(rowId);
 				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 (this.textPreviews.has(textKey({ captionId: rowId }))) throw new Error("Cannot delete or replace a Text 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);
 				}
@@ -4208,7 +6376,7 @@ var TransactionDraft = class {
 			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;
+				if (initial && isRecord(next) && (field === "segments" && table === "audio-script-entities" && sameSegments(next[field], initial[field]) || field === "text" && table === "caption-entities" && next[field] === initial[field])) continue;
 				fields.add(field);
 			}
 			else fields.add(path[2] ?? key);
@@ -4219,6 +6387,9 @@ var TransactionDraft = class {
 		}
 	}
 };
+function sameSegments(a, b) {
+	return JSON.stringify(a) === JSON.stringify(b);
+}
 //#endregion
 //#region src/dsl/document/draft-operations.ts
 function nodeIndex(nodes) {
@@ -4314,8 +6485,20 @@ function applyMutations(tx, mutations) {
 			case "delete-relation":
 				delete rows[m.table][m.id];
 				break;
+			case "insert-segment":
+				tx.insertSegment(m.audioScriptId, m.segmentId, m.text, m.index, m.startMs === void 0 && m.endMs === void 0 ? void 0 : {
+					startMs: m.startMs,
+					endMs: m.endMs
+				});
+				break;
+			case "move-segment":
+				tx.moveSegment(m.audioScriptId, m.segmentId, m.index);
+				break;
+			case "delete-segment":
+				tx.deleteSegment(m.audioScriptId, m.segmentId);
+				break;
 			case "edit-text":
-				tx.editText(m.audioScriptId, m.edits, m.expectedBodyId);
+				tx.editText(m.audioScriptId, m.segmentId, m.edits, m.expectedBodyId);
 				break;
 			case "edit-caption-text":
 				tx.editCaptionText(m.captionId, m.edits, m.expectedBodyId);
@@ -4323,6 +6506,9 @@ function applyMutations(tx, mutations) {
 			case "set-caption-content":
 				tx.setCaptionContent(m);
 				break;
+			case "set-phoneme":
+				tx.setPhoneme(m);
+				break;
 			default: changeTree(tx.draft["contain-relations"], m, tx.draft);
 		}
 	}
@@ -4375,12 +6561,15 @@ function applyTextEdits(text, edits) {
 }
 //#endregion
 //#region src/dsl/document/validation.ts
-/** A caption selection by the DSL's rules, which must also select a nonempty run of the live body. */
-function validateSelection(doc, state, captionId, value) {
-	assertReferenceAdmitted(state, "caption-entities", captionId, "selection", value);
-	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);
+/**
+* A selection the draft wrote whole, by the DSL's rules: its segment must exist and what it
+* selects must not be empty. A run's Cursors must lie on that segment's live Text.
+*/
+function validateSelection(doc, state, table, id, value) {
+	assertReferenceAdmitted(state, table, id, selectionField[table], value);
+	const selection = value;
+	if (!(selection.start === void 0 ? requireSegment(state, selection.audioScriptId, selection.segmentId).text : resolveContent(doc, selection)?.text)) throw new Error("Expected a nonempty selection of the current segment");
+	(table === "caption-entities" ? captionContentCodec : phonemeCodec).encode(selection);
 }
 /**
 * The DSL's admission of the whole draft, then what only this document can check: containment
@@ -4412,8 +6601,12 @@ function validateDraft(tracked) {
 }
 //#endregion
 //#region src/dsl/document/transact.ts
-function captionRow(doc, captionId) {
-	const row = doc.getMap("caption-entities").get(captionId);
+const codecs = {
+	"caption-entities": captionContentCodec,
+	"phonetic-script-entities": phonemeCodec
+};
+function entityRow(doc, table, id) {
+	const row = doc.getMap(table).get(id);
 	return isContainer(row) && row.kind() === "Map" ? row : void 0;
 }
 /** Serialization happens before preparing any writes, so invalid/cyclic audit data cannot partly commit. */
@@ -4434,8 +6627,8 @@ const nativeHookSupport = /* @__PURE__ */ new WeakMap();
 /**
 * Every write relies on the patched Mirror's `applyNative` (patches/loro-mirror@2.3.3.patch). An
 * unpatched Mirror ignores the option and commits only the draft, silently dropping Text, ranges
-* and Caption selections. The patch runs the hook even for an empty draft without committing, so
-* probe each Mirror class once on a scratch document and refuse before the first real write.
+* and selections. The patch runs the hook even for an empty draft without committing, so probe
+* each Mirror class once on a scratch document and refuse before the first real write.
 */
 function assertNativeHook(mirror) {
 	const Impl = mirror.constructor;
@@ -4469,57 +6662,75 @@ function runTransaction(doc, mirror, edit, options, setReject) {
 	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;
+		/** The current text of a Caption's own Text or a script segment, as this transaction leaves it so far. */
+		const useText = (target) => {
+			let text;
+			if ("captionId" in target) {
+				assertId(target.captionId);
+				const entity = requireEntity(tracked.draft, "caption-entities", target.captionId);
+				if (tracked.deleted.has(target.captionId)) throw new Error("Cannot use a deleted Text");
+				if (tracked.removedCaptionTexts.has(target.captionId)) throw new Error("Cannot edit a removed Text");
+				text = entity.text;
+			} else {
+				assertId(target.audioScriptId);
+				if (tracked.deleted.has(target.audioScriptId)) throw new Error("Cannot use a deleted Text");
+				text = requireSegment(tracked.draft, target.audioScriptId, target.segmentId).text;
+			}
+			if (typeof text !== "string") throw new Error("Missing Text");
+			tracked.textPreviews.set(textKey(target), text);
+			return text;
 		};
-		const flushCaptions = () => {
-			for (const id of tracked.dirtyCaptions) {
-				const row = raw["caption-entities"][id];
+		const textBefore = (target) => {
+			if ("captionId" in target) return before["caption-entities"][target.captionId]?.text;
+			return before["audio-script-entities"][target.audioScriptId]?.segments?.find((segment) => segment.id === target.segmentId)?.text;
+		};
+		const flushSelections = () => {
+			for (const [table, id] of tracked.dirtySelections()) {
+				const row = raw[table][id];
 				if (!row) continue;
-				const value = row.selection;
-				const old = before["caption-entities"][id]?.selection;
+				const field = selectionField[table];
+				const value = row[field];
+				const old = before[table][id]?.[field];
 				if (isInvalidAtomic(value)) {
 					if (isInvalidAtomic(old) && old.raw === value.raw) continue;
-					throw new Error("Invalid Caption selection");
-				}
-				if (value !== void 0) {
-					validateSelection(doc, raw, id, value);
-					useBody(value.audioScriptId);
+					throw new Error(`Invalid ${field}`);
 				}
+				if (value !== void 0) validateSelection(doc, raw, table, id, value);
 				steps.push({
-					type: "caption",
+					type: "selection",
+					table,
 					id,
 					value: copyInput(value)
 				});
 			}
-			tracked.dirtyCaptions.clear();
+			tracked.clearDirtySelections();
 		};
-		const editBody = (scriptId, edits, expectedBodyId, caption) => {
+		const editBody = (target, edits, expectedBodyId) => {
 			tracked.run(() => {
-				flushCaptions();
-				const body = useBody(scriptId, caption);
-				if (!bodies.has(scriptId)) bodies.set(scriptId, liveText(doc, scriptId, caption));
-				const native = bodies.get(scriptId);
+				flushSelections();
+				const text = useText(target);
+				const key = textKey(target);
+				if (!bodies.has(key)) bodies.set(key, liveText(doc, target));
+				const native = bodies.get(key);
 				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);
+				if (textBefore(target) !== void 0 && !native) throw new Error("Missing live Text body");
+				const prepared = prepareTextEdits(text, copyInput(edits));
+				tracked.textPreviews.set(key, prepared.text);
 				steps.push({
 					type: "text",
-					scriptId,
-					caption,
+					target,
 					expectedBodyId: native?.id,
 					edits: prepared.edits
 				});
 			});
 		};
+		/** A script's segments as this transaction leaves them; never a Mirror-tracked write. */
+		const segmentsOf = (audioScriptId) => {
+			assertId(audioScriptId);
+			requireEntity(tracked.draft, "audio-script-entities", audioScriptId);
+			if (tracked.deleted.has(audioScriptId)) throw new Error("Cannot change a deleted AudioScript");
+			return raw["audio-script-entities"][audioScriptId].segments;
+		};
 		const tx = Object.freeze({
 			get draft() {
 				return tracked.run(() => tracked.draft);
@@ -4527,29 +6738,98 @@ function runTransaction(doc, mirror, edit, options, setReject) {
 			applyMutations(mutations) {
 				tracked.run(() => applyMutations(tx, mutations));
 			},
-			editText(scriptId, edits, expectedBodyId) {
-				editBody(scriptId, edits, expectedBodyId, false);
+			editText(audioScriptId, segmentId, edits, expectedBodyId) {
+				editBody({
+					audioScriptId,
+					segmentId
+				}, edits, expectedBodyId);
 			},
 			editCaptionText(captionId, edits, expectedBodyId) {
-				editBody(captionId, edits, expectedBodyId, true);
+				editBody({ captionId }, edits, expectedBodyId);
+			},
+			insertSegment(audioScriptId, segmentId, text, index, time) {
+				tracked.run(() => {
+					assertId(segmentId);
+					if (typeof text !== "string") throw new Error("Segment text is a string");
+					const segment = {
+						id: segmentId,
+						text,
+						...time
+					};
+					assertScriptSegment(segment);
+					const segments = segmentsOf(audioScriptId);
+					if (segments.some((segment) => segment.id === segmentId)) throw new Error(`Segment already exists: ${segmentId}`);
+					const at = index ?? segments.length;
+					if (!Number.isSafeInteger(at) || at < 0 || at > segments.length) throw new Error("Invalid segment index");
+					segments.splice(at, 0, segment);
+				});
+			},
+			moveSegment(audioScriptId, segmentId, index) {
+				tracked.run(() => {
+					const segments = segmentsOf(audioScriptId);
+					const from = segments.findIndex((segment) => segment.id === segmentId);
+					if (from < 0) throw new Error(`Missing segment ${segmentId} of ${audioScriptId}`);
+					if (!Number.isSafeInteger(index) || index < 0 || index >= segments.length) throw new Error("Invalid segment index");
+					const [segment] = segments.splice(from, 1);
+					segments.splice(index, 0, segment);
+				});
+			},
+			deleteSegment(audioScriptId, segmentId) {
+				tracked.run(() => {
+					const segments = segmentsOf(audioScriptId);
+					const at = segments.findIndex((segment) => segment.id === segmentId);
+					if (at < 0) throw new Error(`Missing segment ${segmentId} of ${audioScriptId}`);
+					if (tracked.textPreviews.has(textKey({
+						audioScriptId,
+						segmentId
+					}))) throw new Error("Cannot delete a segment whose text this transaction edits");
+					segments.splice(at, 1);
+				});
 			},
 			setCaptionContent(selection) {
 				tracked.run(() => {
-					flushCaptions();
-					const { captionId, audioScriptId, start, end } = selection;
+					flushSelections();
+					const { captionId, audioScriptId, segmentId, start, end } = selection;
 					assertId(captionId);
-					assertCaptionEndpoints(raw, selection);
-					assertCaptionSelection(raw, selection, useBody(audioScriptId));
+					assertCaptionSelection(raw, selection, useText({
+						audioScriptId,
+						segmentId
+					}));
 					steps.push({
 						type: "range",
-						selection: {
-							captionId,
+						table: "caption-entities",
+						id: captionId,
+						range: {
 							audioScriptId,
+							segmentId,
 							start,
 							end
 						}
 					});
 				});
+			},
+			setPhoneme(selection) {
+				tracked.run(() => {
+					flushSelections();
+					const { phoneticScriptId, audioScriptId, segmentId, start, end, phonemeScript } = selection;
+					assertId(phoneticScriptId);
+					assertPhonemeSelection(raw, selection, useText({
+						audioScriptId,
+						segmentId
+					}));
+					steps.push({
+						type: "range",
+						table: "phonetic-script-entities",
+						id: phoneticScriptId,
+						range: {
+							audioScriptId,
+							segmentId,
+							start,
+							end
+						},
+						...phonemeScript === void 0 ? {} : { phonemeScript }
+					});
+				});
 			}
 		});
 		try {
@@ -4562,34 +6842,15 @@ function runTransaction(doc, mirror, edit, options, setReject) {
 				}
 				tracked.assertValid();
 				if (doc.getPendingTxnLength()) throw new Error("Native writes are not allowed during transaction preparation");
-				flushCaptions();
+				flushSelections();
 				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.entries(before["caption-entities"]).filter(([, caption]) => typeof caption === "object" && caption.selection !== void 0).map(([id]) => id));
-				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") {
-						changedCaptions.add(step.id);
-						if (step.value) referenceIds.add(step.id);
-						else referenceIds.delete(step.id);
-					}
-					if (step.type === "text" && step.caption) changedCaptions.add(step.scriptId);
-				}
-				for (const id of changedCaptions) if (raw["caption-entities"][id]) 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, {
-					captionId: step.id,
-					audioScriptId: step.value.audioScriptId
-				});
+				for (const step of steps) if (step.type === "text") if ("captionId" in step.target) requireEntity(raw, "caption-entities", step.target.captionId);
+				else requireSegment(raw, step.target.audioScriptId, step.target.segmentId);
+				assertSelectionsAfter(raw, before, tracked, steps);
 				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) {
@@ -4597,12 +6858,15 @@ function runTransaction(doc, mirror, edit, options, setReject) {
 						delete row.text;
 					}
 				}
-				for (const [id, fields] of tracked.entities.get("caption-entities") ?? []) {
-					const row = raw["caption-entities"][id];
-					if (!row || !fields.has("selection")) continue;
-					const old = before["caption-entities"][id];
-					if (old?.selection === void 0) delete row.selection;
-					else row.selection = old.selection;
+				for (const table of Object.keys(selectionField)) {
+					const field = selectionField[table];
+					for (const [id, fields] of tracked.entities.get(table) ?? []) {
+						const row = raw[table][id];
+						if (!row || !fields.has(field)) continue;
+						const old = before[table][id]?.[field];
+						if (old === void 0) delete row[field];
+						else row[field] = old;
+					}
 				}
 			});
 		} finally {
@@ -4612,45 +6876,104 @@ function runTransaction(doc, mirror, edit, options, setReject) {
 	}, {
 		...options,
 		applyNative: (doc) => {
-			const bodyFor = (scriptId, caption = false) => {
-				let text = bodies.get(scriptId);
+			const textFor = (target) => {
+				const key = textKey(target);
+				let text = bodies.get(key);
 				if (!text) {
-					text = liveText(doc, scriptId, caption);
-					bodies.set(scriptId, text);
+					text = liveText(doc, target);
+					bodies.set(key, text);
 				}
-				if (!text || text.isDeleted()) throw new Error("Prepared Text body is missing");
+				if (!text || text.isDeleted()) throw new Error("Prepared Text 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);
+				const text = doc.getMap("caption-entities").get(id).setContainer("text", new LoroText());
+				if (value.length) text.insert(0, value);
+				bodies.set(textKey({ captionId: id }), text);
 			}
-			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);
-				const row = captionRow(doc, captionId);
-				if (!from || !to || !row) throw new Error("Unable to construct prepared range");
-				row.set("selection", captionContentCodec.encode({
-					audioScriptId,
-					start: from,
-					end: to
-				}));
-			} else {
-				const row = captionRow(doc, step.id);
-				if (step.value !== void 0) {
-					if (!row) throw new Error("Prepared Caption is missing");
-					row.set("selection", captionContentCodec.encode(step.value));
-				} else if (row?.get("selection") !== void 0) row.delete("selection");
+			for (const step of steps) {
+				if (step.type === "text") {
+					const text = textFor(step.target);
+					if (step.expectedBodyId && text.id !== step.expectedBodyId) throw new Error("Stale Text body");
+					applyTextEdits(text, step.edits);
+					continue;
+				}
+				const row = entityRow(doc, step.table, step.id);
+				const field = selectionField[step.table];
+				if (step.type === "range") {
+					const { audioScriptId, segmentId, start, end } = step.range;
+					const value = {
+						audioScriptId,
+						segmentId
+					};
+					if (start !== void 0 && end !== void 0) {
+						const text = textFor({
+							audioScriptId,
+							segmentId
+						});
+						value.start = text.getCursor(start, 0);
+						value.end = text.getCursor(end, 0);
+						if (!value.start || !value.end) throw new Error("Unable to construct prepared range");
+					}
+					if (step.phonemeScript !== void 0) value.phonemeScript = step.phonemeScript;
+					if (!row) throw new Error("Unable to construct prepared range");
+					row.set(field, codecs[step.table].encode(value));
+				} else if (step.value !== void 0) {
+					if (!row) throw new Error("Prepared selection owner is missing");
+					row.set(field, codecs[step.table].encode(step.value));
+				} else if (row?.get(field) !== void 0) row.delete(field);
 			}
 		}
 	});
 }
+/**
+* What only the whole write can say about selections, with the native steps counted in order:
+* each Caption keeps one source of words, each selection's segment still exists, and every
+* PhoneticScript the write touched is written for a segment and stores its text as a file.
+*/
+function assertSelectionsAfter(raw, before, tracked, steps) {
+	const selected = new Set(Object.entries(before["caption-entities"]).filter(([, caption]) => typeof caption === "object" && caption.selection !== void 0).map(([id]) => id));
+	const changedCaptions = /* @__PURE__ */ new Set();
+	for (const [id, fields] of tracked.entities.get("caption-entities") ?? []) if (fields.has("text")) changedCaptions.add(id);
+	const phonemes = /* @__PURE__ */ new Map();
+	for (const step of steps) {
+		if (step.type === "text") {
+			if ("captionId" in step.target) changedCaptions.add(step.target.captionId);
+			continue;
+		}
+		const value = step.type === "range" ? {
+			...step.range,
+			...step.phonemeScript === void 0 ? {} : { phonemeScript: step.phonemeScript }
+		} : step.value;
+		if (step.table === "caption-entities") {
+			changedCaptions.add(step.id);
+			if (value) selected.add(step.id);
+			else selected.delete(step.id);
+			if (value) assertCaptionEndpoints(raw, {
+				captionId: step.id,
+				...value
+			});
+		} else {
+			phonemes.set(step.id, value);
+			if (value) assertPhonemeEndpoints(raw, {
+				phoneticScriptId: step.id,
+				...value
+			});
+		}
+	}
+	for (const id of changedCaptions) if (raw["caption-entities"][id]) assertCaptionSource(raw["caption-entities"][id], selected.has(id));
+	const phonetics = new Set([...tracked.entities.get("phonetic-script-entities")?.keys() ?? [], ...phonemes.keys()]);
+	for (const id of phonetics) {
+		const row = raw["phonetic-script-entities"][id];
+		if (!row) continue;
+		const phoneme = phonemes.has(id) ? phonemes.get(id) : row.phoneme;
+		const old = before["phonetic-script-entities"][id];
+		assertPhoneticScript(old, {
+			...row,
+			phoneme: isRecord(phoneme) ? phoneme : void 0
+		});
+	}
+}
 //#endregion
 //#region src/dsl/document/medeo-dsl.ts
 const contentRoots = new Set([
@@ -4741,17 +7064,23 @@ var MedeoDsl = class MedeoDsl {
 	applyMutations(mutations, audit) {
 		this.transact((tx) => tx.applyMutations(mutations), audit);
 	}
-	editText(scriptId, expectedBodyId, edits, audit) {
-		this.transact((tx) => tx.editText(scriptId, edits, expectedBodyId), audit);
+	editText(scriptId, segmentId, expectedBodyId, edits, audit) {
+		this.transact((tx) => tx.editText(scriptId, segmentId, 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) {
+	/**
+	* A run inside one segment as native Cursors. Local ranges exclude insertions at their start and
+	* include insertions at their end. K01 remains deferred.
+	*/
+	textRange(scriptId, segmentId, start, end) {
 		this.assertActive();
-		const text = liveText(this.doc, scriptId);
-		if (!text) throw new Error("Missing AudioScript body");
+		const text = liveText(this.doc, {
+			audioScriptId: scriptId,
+			segmentId
+		});
+		if (!text) throw new Error("Missing AudioScript segment");
 		assertTextOffset(text.toString(), start);
 		assertTextOffset(text.toString(), end);
 		if (start >= end) throw new Error("Expected a nonempty range");
@@ -4759,6 +7088,7 @@ var MedeoDsl = class MedeoDsl {
 		if (!from || !to) throw new Error("Unable to construct text range");
 		return {
 			audioScriptId: scriptId,
+			segmentId,
 			start: from,
 			end: to
 		};
@@ -4771,42 +7101,186 @@ var MedeoDsl = class MedeoDsl {
 		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();
+	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/projection/audio-scripts.ts
+/**
+* The scripts a recording says. It follows derived-from from the recording; a PhoneticScript is a
+* variant, so its words are the base its phoneme names, and derived-from is not followed past it.
+* When nothing is found that way, a script read off the recording itself is what it says.
+*/
+function spokenScripts(snapshot, recordingId) {
+	const relations = Object.values(snapshot["derived-from-relations"]);
+	const found = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (id, phoneticScriptId) => {
+		if (seen.has(id)) return;
+		seen.add(id);
+		if (snapshot["audio-script-entities"][id]) {
+			if (!found.has(id)) found.set(id, phoneticScriptId);
+			return;
+		}
+		const phonetic = snapshot["phonetic-script-entities"][id];
+		if (phonetic) {
+			visit(phonetic.phoneme.audioScriptId, id);
+			return;
+		}
+		for (const r of relations) if (r.entityId === id) visit(r.sourceId, phoneticScriptId);
+	};
+	visit(recordingId);
+	if (!found.size) {
+		for (const r of relations) if (r.sourceId === recordingId && snapshot["audio-script-entities"][r.entityId]) found.set(r.entityId, void 0);
+	}
+	return [...found].map(([audioScriptId, phoneticScriptId]) => phoneticScriptId === void 0 ? { audioScriptId } : {
+		audioScriptId,
+		phoneticScriptId
+	});
+}
+/** Every AudioScript in the document with its PhoneticScripts, the Speech Clips saying it and the Caption Clips showing it. */
+function toAudioScriptViews(snapshot) {
+	const views = /* @__PURE__ */ new Map();
+	const segmentIndex = (scriptId, segmentId) => {
+		const index = snapshot["audio-script-entities"][scriptId]?.segments.findIndex((s) => s.id === segmentId) ?? -1;
+		return index < 0 ? void 0 : index;
+	};
+	for (const [id, script] of Object.entries(snapshot["audio-script-entities"])) views.set(id, {
+		id,
+		segments: script.segments.map((segment) => {
+			const rich = snapshot.richText[segment.id];
+			const language = rich ? markedLanguage(langsFromDelta(rich.delta)) : void 0;
+			return {
+				id: segment.id,
+				text: segment.text,
+				...language === void 0 ? {} : { language },
+				...segment.startMs === void 0 ? {} : {
+					startMs: segment.startMs,
+					endMs: segment.endMs
+				}
+			};
+		}),
+		sourceMediaIds: [],
+		phoneticScripts: [],
+		speeches: [],
+		captions: []
+	});
+	for (const r of Object.values(snapshot["derived-from-relations"])) if (snapshot["media-entities"][r.sourceId]) views.get(r.entityId)?.sourceMediaIds.push(r.sourceId);
+	for (const [id, phonetic] of Object.entries(snapshot["phonetic-script-entities"])) {
+		const { audioScriptId, segmentId, phonemeScript } = phonetic.phoneme;
+		const { digest } = phonetic;
+		const segment = segmentIndex(audioScriptId, segmentId);
+		const text = snapshot.phoneticText[id]?.text;
+		views.get(audioScriptId)?.phoneticScripts.push({
+			id,
+			...segment === void 0 ? {} : { segment },
+			...text === void 0 ? {} : { text },
+			...phonemeScript === void 0 ? {} : { phonemeScript },
+			...digest === void 0 ? {} : { digest }
+		});
+	}
+	const layout = resolveDslLayout(snapshot);
+	for (const view of views.values()) placeTranscript(snapshot, layout, view);
+	const timbres = Object.values(snapshot["voice-timbre-relations"]);
+	for (const track of layout.tracks) for (const { clipId } of track.clips) {
+		const source = snapshot["clip-entities"][clipId]?.source;
+		if (!source) continue;
+		if (snapshot["media-entities"][source]?.kind === "voiceover-recording") {
+			const voices = timbres.filter((r) => r.recordingId === source).flatMap((r) => {
+				const voice = snapshot["voice-entities"][r.voiceId];
+				if (!voice) return [];
+				return [voice.name === void 0 ? {
+					voiceId: r.voiceId,
+					key: voice.key
+				} : {
+					voiceId: r.voiceId,
+					key: voice.key,
+					name: voice.name
+				}];
+			});
+			for (const spoken of spokenScripts(snapshot, source)) {
+				const applied = appliedSpeech(snapshot, source, spoken);
+				views.get(spoken.audioScriptId)?.speeches.push({
+					clipId,
+					recordingId: source,
+					...spoken.phoneticScriptId === void 0 ? {} : { phoneticScriptId: spoken.phoneticScriptId },
+					voices,
+					...applied === void 0 ? {} : { applied }
+				});
 			}
-		};
-		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;
+			continue;
 		}
+		const caption = snapshot["caption-entities"][source];
+		if (!caption?.selection || caption.text !== void 0 || !snapshot.captionText[source]) continue;
+		const { audioScriptId, segmentId } = caption.selection;
+		const segment = segmentIndex(audioScriptId, segmentId);
+		if (segment !== void 0) views.get(audioScriptId)?.captions.push({
+			clipId,
+			captionId: source,
+			segment
+		});
 	}
-	assertActive() {
-		if (this.disposed) throw new Error("MedeoDsl is disposed");
+	return [...views.values()];
+}
+/**
+* A transcript's segments on the Timeline: a segment's time is in the medium the script was read
+* off, so it lands where the earliest Clip playing that medium holds that moment in its window.
+*/
+function placeTranscript(snapshot, layout, view) {
+	if (!view.sourceMediaIds.length) return;
+	const plays = layout.tracks.flatMap((track) => track.clips).filter((clip) => view.sourceMediaIds.includes(snapshot["clip-entities"][clip.clipId]?.source ?? "")).sort((a, b) => a.startMs - b.startMs);
+	for (const segment of view.segments) {
+		const at = segment.startMs;
+		if (at === void 0) continue;
+		const clip = plays.find((c) => c.inMs <= at && at < c.outMs);
+		if (clip) segment.timelineMs = Math.round(clip.startMs + (at - clip.inMs) / clip.rate);
 	}
-};
+}
+/**
+* Whether a recording still matches what it was synthesized from: the digest its derived-from
+* records against the source's file digest now. A recording derived from a script directly is
+* not judged: a written script has no file, and a transcript's file is what it was read from,
+* not what a take was synthesized from (D190).
+*/
+function appliedSpeech(snapshot, recordingId, spoken) {
+	const sourceId = spoken.phoneticScriptId ?? spoken.audioScriptId;
+	const recorded = Object.values(snapshot["derived-from-relations"]).find((r) => r.entityId === recordingId && r.sourceId === sourceId)?.sourceDigest;
+	const current = spoken.phoneticScriptId === void 0 ? void 0 : snapshot["phonetic-script-entities"][sourceId]?.digest;
+	return recorded === void 0 || current === void 0 ? void 0 : recorded === current;
+}
 //#endregion
 //#region src/dsl/voiceover-actions.ts
 function voiceoverPlan(s, input, result) {
@@ -4820,16 +7294,28 @@ function voiceoverPlan(s, input, result) {
 		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");
+	let segmentIds;
+	if (input.script.segments !== void 0) {
+		if (result.segmentIds.length !== input.script.segments.length) throw new Error("Expected one id per segment");
+		const segments = input.script.segments;
+		segmentIds = result.segmentIds;
+		mutations.push({
+			type: "create-entity",
+			table: "audio-script-entities",
+			id: result.audioScriptId,
+			value: {
+				segments: segments.map((text, i) => ({
+					id: segmentIds[i],
+					text
+				})),
+				..."defaultLanguage" in input.script && input.script.defaultLanguage !== void 0 ? { defaultLanguage: input.script.defaultLanguage } : {}
+			}
+		});
+	} else {
+		const script = s["audio-script-entities"][result.audioScriptId];
+		if (!script) throw new Error("Missing AudioScript");
+		segmentIds = script.segments.map((segment) => segment.id);
+	}
 	const phoneticScriptId = input.script.phoneticScriptId;
 	if (phoneticScriptId !== void 0 && s["phonetic-script-entities"][phoneticScriptId]?.phoneme.audioScriptId !== result.audioScriptId) throw new Error("The PhoneticScript must name this AudioScript as its base");
 	validateWindow({
@@ -4896,7 +7382,7 @@ function voiceoverPlan(s, input, result) {
 	mutations.push(...placementMutations(s, result.clipId, input.placement));
 	uniqueIds(result.captionClipIds);
 	const retained = new Set(result.captionClipIds);
-	const oldCaptions = anchoredTo(s, new Set([result.clipId])).filter((id) => requireTrack(s, trackOf(s, id)).role === "caption");
+	const oldCaptions = existing ? captionsShowing(s, existing.source) : [];
 	mutations.push(...deleteClips(s, oldCaptions.filter((id) => !retained.has(id)), "cascade"));
 	const placement = mutations.find((m) => m.type === "patch-entity" && m.table === "clip-entities" && m.id === result.clipId && "anchor" in m.patch);
 	const anchor = placement?.type === "patch-entity" && placement.table === "clip-entities" ? placement.patch.anchor : void 0;
@@ -4912,6 +7398,8 @@ function voiceoverPlan(s, input, result) {
 		}, 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 segmentId = segmentIds[caption.segment];
+		if (segmentId === void 0) throw new Error(`Missing segment ${caption.segment} of the voiceover's script`);
 		const previousSource = previous?.source;
 		const style = caption.style ?? (previousSource ? s["caption-entities"][previousSource]?.style : void 0);
 		mutations.push({
@@ -4923,8 +7411,11 @@ function voiceoverPlan(s, input, result) {
 			type: "set-caption-content",
 			captionId,
 			audioScriptId: result.audioScriptId,
-			start: caption.range.start,
-			end: caption.range.end
+			segmentId,
+			...caption.range === void 0 ? {} : {
+				start: caption.range.start,
+				end: caption.range.end
+			}
 		});
 		const anchor = {
 			to: result.clipId,
@@ -4962,6 +7453,33 @@ function voiceoverPlan(s, input, result) {
 	});
 	return mutations;
 }
+/**
+* Caption Clips showing what a recording says (D183): their Caption selects the run of the segment
+* the PhoneticScript it was spoken from is written for, or any segment of the script it was read
+* from directly.
+*/
+function captionsShowing(s, recordingId) {
+	const said = spokenScripts(s, recordingId).map(({ audioScriptId, phoneticScriptId }) => {
+		if (phoneticScriptId === void 0) return { audioScriptId };
+		const { segmentId } = s["phonetic-script-entities"][phoneticScriptId].phoneme;
+		return {
+			audioScriptId,
+			segmentId,
+			run: s.phoneticText[phoneticScriptId]
+		};
+	});
+	return Object.entries(s["clip-entities"]).flatMap(([id, clip]) => {
+		const selection = s["caption-entities"][clip.source]?.selection;
+		const shown = s.captionText[clip.source];
+		if (!selection) return [];
+		return said.some((words) => {
+			if (selection.audioScriptId !== words.audioScriptId) return false;
+			if (!("segmentId" in words)) return true;
+			if (selection.segmentId !== words.segmentId || !shown || !words.run) return false;
+			return shown.start < words.run.end && words.run.start < shown.end;
+		}) && requireTrack(s, trackOf(s, id)).role === "caption" ? [id] : [];
+	});
+}
 //#endregion
 //#region src/dsl/dsl-editor.ts
 /** Business edits write DSL facts in one audited transaction; layout is derived on read. */
@@ -5075,30 +7593,76 @@ var DslEditor = class {
 			patch: { volume }
 		}], options);
 	}
-	createAudioScript(body, defaultLanguage, options) {
+	/** A script of these segments, in order; each segment gets its own id. */
+	createAudioScript(segments, defaultLanguage, options) {
 		const id = this.idFactory("audio-script");
+		const value = {
+			segments: segments.map((text) => ({
+				id: this.idFactory("segment"),
+				text
+			})),
+			...defaultLanguage === void 0 ? {} : { defaultLanguage }
+		};
 		this.write("createAudioScript", {
 			id,
-			body,
-			defaultLanguage
+			...value
 		}, [{
 			type: "create-entity",
 			table: "audio-script-entities",
 			id,
-			value: {
-				body,
-				...defaultLanguage === void 0 ? {} : { defaultLanguage }
-			}
+			value
 		}], options);
 		return id;
 	}
-	editAudioScript(scriptId, expectedBodyId, edits, options) {
-		this.dsl.editText(scriptId, expectedBodyId, edits, audit("editAudioScript", {
+	editAudioScript(scriptId, segmentId, expectedBodyId, edits, options) {
+		this.dsl.editText(scriptId, segmentId, expectedBodyId, edits, audit("editAudioScript", {
 			scriptId,
+			segmentId,
 			expectedBodyId,
 			edits
 		}, options));
 	}
+	/** Adds a segment at `index`, the end by default, and returns its id. */
+	insertScriptSegment(scriptId, text, index, options) {
+		const segmentId = this.idFactory("segment");
+		this.write("insertScriptSegment", {
+			scriptId,
+			segmentId,
+			text,
+			index
+		}, [{
+			type: "insert-segment",
+			audioScriptId: scriptId,
+			segmentId,
+			text,
+			...index === void 0 ? {} : { index }
+		}], options);
+		return segmentId;
+	}
+	/** `index` is measured after removing the segment. */
+	moveScriptSegment(scriptId, segmentId, index, options) {
+		this.write("moveScriptSegment", {
+			scriptId,
+			segmentId,
+			index
+		}, [{
+			type: "move-segment",
+			audioScriptId: scriptId,
+			segmentId,
+			index
+		}], options);
+	}
+	/** Captions and PhoneticScripts selecting the segment keep their selection, which then shows nothing (D72). */
+	deleteScriptSegment(scriptId, segmentId, options) {
+		this.write("deleteScriptSegment", {
+			scriptId,
+			segmentId
+		}, [{
+			type: "delete-segment",
+			audioScriptId: scriptId,
+			segmentId
+		}], options);
+	}
 	createCaption(input, options) {
 		const id = this.idFactory("caption");
 		this.write("createCaption", {
@@ -5115,18 +7679,16 @@ var DslEditor = class {
 		}, ...input.text !== void 0 ? [] : [{
 			type: "set-caption-content",
 			captionId: id,
-			audioScriptId: input.audioScriptId,
-			start: input.start,
-			end: input.end
+			...segmentRange(input)
 		}]], options);
 		return id;
 	}
-	setCaptionContent(captionId, audioScriptId, start, end, options) {
+	/** Show a segment of a script, or a run of it, in place of the Caption's own text. */
+	setCaptionContent(captionId, selection, options) {
+		const range = segmentRange(selection);
 		this.write("setCaptionContent", {
 			captionId,
-			audioScriptId,
-			start,
-			end
+			...range
 		}, [{
 			type: "patch-entity",
 			table: "caption-entities",
@@ -5135,9 +7697,7 @@ var DslEditor = class {
 		}, {
 			type: "set-caption-content",
 			captionId,
-			audioScriptId,
-			start,
-			end
+			...range
 		}], options);
 	}
 	setCaptionText(captionId, text, options) {
@@ -5263,6 +7823,7 @@ var DslEditor = class {
 			clipId: input.clipId ?? this.idFactory("clip"),
 			mediaId: resourceId("media", input.media.system, input.media.key),
 			audioScriptId: this.voiceoverScriptId(input.script),
+			segmentIds: input.script.segments?.map(() => this.idFactory("segment")) ?? [],
 			captionClipIds: input.captions.map((c) => c.clipId ?? this.idFactory("clip")),
 			captionIds: input.captions.map(() => this.idFactory("caption"))
 		};
@@ -5280,17 +7841,14 @@ var DslEditor = class {
 		return phonetic.phoneme.audioScriptId;
 	}
 	/**
-	* Write a PhoneticScript: create one for `audioScriptId`, or, given `phoneticScriptId`, replace its
-	* base and pronunciation together. A `phonemeScript` is stored as a Memota text file first, and
-	* the file's facts are written with it; an unchanged one keeps its file. Recordings already spoken
-	* from it keep their derived-from.
+	* Write a PhoneticScript: create one for a segment of a script, or a run of it, or, given
+	* `phoneticScriptId`, replace its selection and what to synthesize together (D181). A
+	* `phonemeScript` is stored as a Memota text file first, and the file's facts are written with
+	* it; an unchanged one keeps its file. Recordings already spoken from it keep their derived-from.
 	*/
 	async setPhoneticScript(input, options) {
 		const id = input.phoneticScriptId ?? this.idFactory("phonetic-script");
-		const phoneme = {
-			audioScriptId: input.audioScriptId,
-			...input.phonemeScript === void 0 ? {} : { phonemeScript: input.phonemeScript }
-		};
+		const range = segmentRange(input);
 		const file = input.phonemeScript === void 0 ? {} : await this.fileFor(id, input.phonemeScript);
 		const exists = Object.hasOwn(this.dsl.getSnapshot()["phonetic-script-entities"], id);
 		const cleared = {
@@ -5299,9 +7857,11 @@ var DslEditor = class {
 			storageKey: void 0,
 			digest: void 0
 		};
+		const phonemeScript = input.phonemeScript === void 0 ? {} : { phonemeScript: input.phonemeScript };
 		this.write("setPhoneticScript", {
 			id,
-			phoneme,
+			...range,
+			...phonemeScript,
 			...cleared,
 			...file
 		}, [exists ? {
@@ -5309,10 +7869,6 @@ var DslEditor = class {
 			table: "phonetic-script-entities",
 			id,
 			patch: {
-				phoneme: {
-					...phoneme,
-					phonemeScript: input.phonemeScript
-				},
 				...cleared,
 				...file
 			}
@@ -5320,10 +7876,12 @@ var DslEditor = class {
 			type: "create-entity",
 			table: "phonetic-script-entities",
 			id,
-			value: {
-				phoneme,
-				...file
-			}
+			value: file
+		}, {
+			type: "set-phoneme",
+			phoneticScriptId: id,
+			...range,
+			...phonemeScript
 		}], options);
 		return id;
 	}
@@ -5392,6 +7950,15 @@ var DslEditor = class {
 		this.dsl.applyMutations(mutations, audit(action, payload, options));
 	}
 };
+/** A selection as a write states it: a run only when both its ends are given. */
+function segmentRange(input) {
+	return {
+		audioScriptId: input.audioScriptId,
+		segmentId: input.segmentId,
+		...input.start === void 0 ? {} : { start: input.start },
+		...input.end === void 0 ? {} : { end: input.end }
+	};
+}
 function audit(action, payload, options) {
 	return {
 		semantic_op: action,
@@ -5431,131 +7998,6 @@ function createInitialMedeoDsl(options = {}) {
 	}
 }
 //#endregion
-//#region src/dsl/projection/audio-scripts.ts
-/**
-* The scripts a recording says. It follows derived-from from the recording; a PhoneticScript is a
-* variant, so its words are the base its phoneme names, and derived-from is not followed past it.
-* When nothing is found that way, a script read off the recording itself is what it says.
-*/
-function spokenScripts(snapshot, recordingId) {
-	const relations = Object.values(snapshot["derived-from-relations"]);
-	const found = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const visit = (id, phoneticScriptId) => {
-		if (seen.has(id)) return;
-		seen.add(id);
-		if (snapshot["audio-script-entities"][id]) {
-			if (!found.has(id)) found.set(id, phoneticScriptId);
-			return;
-		}
-		const phonetic = snapshot["phonetic-script-entities"][id];
-		if (phonetic) {
-			visit(phonetic.phoneme.audioScriptId, id);
-			return;
-		}
-		for (const r of relations) if (r.entityId === id) visit(r.sourceId, phoneticScriptId);
-	};
-	visit(recordingId);
-	if (!found.size) {
-		for (const r of relations) if (r.sourceId === recordingId && snapshot["audio-script-entities"][r.entityId]) found.set(r.entityId, void 0);
-	}
-	return [...found].map(([audioScriptId, phoneticScriptId]) => phoneticScriptId === void 0 ? { audioScriptId } : {
-		audioScriptId,
-		phoneticScriptId
-	});
-}
-/** Every AudioScript in the document with its PhoneticScripts, the Speech Clips saying it and the Caption Clips showing it. */
-function toAudioScriptViews(snapshot) {
-	const views = /* @__PURE__ */ new Map();
-	const bodies = /* @__PURE__ */ new Map();
-	for (const [id, script] of Object.entries(snapshot["audio-script-entities"])) {
-		const rich = snapshot.richText[id];
-		const text = rich ? langsFromDelta(rich.delta) : {
-			body: script.body,
-			langs: []
-		};
-		bodies.set(id, text.body);
-		views.set(id, {
-			id,
-			segments: lines(text.body).map((line) => {
-				const language = lineLanguage(text, line);
-				return language === void 0 ? { text: line.text } : {
-					text: line.text,
-					language
-				};
-			}),
-			sourceMediaIds: [],
-			phoneticScripts: [],
-			speeches: [],
-			captions: []
-		});
-	}
-	for (const r of Object.values(snapshot["derived-from-relations"])) if (snapshot["media-entities"][r.sourceId]) views.get(r.entityId)?.sourceMediaIds.push(r.sourceId);
-	for (const [id, phonetic] of Object.entries(snapshot["phonetic-script-entities"])) {
-		const { phonemeScript } = phonetic.phoneme;
-		const { digest } = phonetic;
-		views.get(phonetic.phoneme.audioScriptId)?.phoneticScripts.push({
-			id,
-			...phonemeScript === void 0 ? {} : { phonemeScript },
-			...digest === void 0 ? {} : { digest }
-		});
-	}
-	const timbres = Object.values(snapshot["voice-timbre-relations"]);
-	for (const track of resolveDslLayout(snapshot).tracks) for (const { clipId } of track.clips) {
-		const source = snapshot["clip-entities"][clipId]?.source;
-		if (!source) continue;
-		if (snapshot["media-entities"][source]?.kind === "voiceover-recording") {
-			const voices = timbres.filter((r) => r.recordingId === source).flatMap((r) => {
-				const voice = snapshot["voice-entities"][r.voiceId];
-				if (!voice) return [];
-				return [voice.name === void 0 ? {
-					voiceId: r.voiceId,
-					key: voice.key
-				} : {
-					voiceId: r.voiceId,
-					key: voice.key,
-					name: voice.name
-				}];
-			});
-			for (const spoken of spokenScripts(snapshot, source)) {
-				const applied = appliedSpeech(snapshot, source, spoken);
-				views.get(spoken.audioScriptId)?.speeches.push({
-					clipId,
-					recordingId: source,
-					...spoken.phoneticScriptId === void 0 ? {} : { phoneticScriptId: spoken.phoneticScriptId },
-					voices,
-					...applied === void 0 ? {} : { applied }
-				});
-			}
-			continue;
-		}
-		const caption = snapshot["caption-entities"][source];
-		const shown = snapshot.captionText[source];
-		if (!caption?.selection || caption.text !== void 0 || !shown) continue;
-		const scriptId = caption.selection.audioScriptId;
-		const body = bodies.get(scriptId);
-		if (body === void 0) continue;
-		const segment = lines(body).findIndex((line) => shown.start >= line.start && shown.end <= line.end);
-		if (segment >= 0) views.get(scriptId)?.captions.push({
-			clipId,
-			captionId: source,
-			segment
-		});
-	}
-	return [...views.values()];
-}
-/**
-* Whether a recording still matches what it was synthesized from: the digest its derived-from
-* records against the source's file digest now. An AudioScript has no file, so a recording
-* derived from a script directly is not judged.
-*/
-function appliedSpeech(snapshot, recordingId, spoken) {
-	const sourceId = spoken.phoneticScriptId ?? spoken.audioScriptId;
-	const recorded = Object.values(snapshot["derived-from-relations"]).find((r) => r.entityId === recordingId && r.sourceId === sourceId)?.sourceDigest;
-	const current = spoken.phoneticScriptId === void 0 ? void 0 : snapshot["phonetic-script-entities"][sourceId]?.digest;
-	return recorded === void 0 || current === void 0 ? void 0 : recorded === current;
-}
-//#endregion
 //#region src/dsl/projection/caption-style.ts
 const fields = {
 	fontSize: "font_size",
@@ -5592,6 +8034,9 @@ function fromDraftStyle(style) {
 	};
 }
 //#endregion
+//#region src/dsl/projection/video-draft-types.ts
+const DEFAULT_UNIT_TIME_MS = 33.333;
+//#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) {
@@ -5644,7 +8089,7 @@ function toVideoDraft(snapshot) {
 					audio_storage_key: source.storageKey,
 					origin_speech_id: source.key,
 					volume: clip.volume,
-					audio_script: spokenText(snapshot, sourceId, captionIds),
+					audio_script: spokenText(snapshot, sourceId),
 					voice: voice ? {
 						id: voice.key,
 						name: voice.name
@@ -5730,29 +8175,17 @@ 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");
 }
 /**
-* The words a speech Clip says. A script voiced in several takes is said one part per take, and
-* the Captions following the Clip select that part: its words are the segments they select, in
-* script order. A Clip no Caption of its script follows says the whole script.
+* What a recording says: what the selection of the PhoneticScript it was spoken from holds now,
+* or, for one derived from a script directly, the whole script, one segment per line.
 */
-function spokenText(snapshot, recordingId, captionClipIds) {
-	const scripts = new Set(spokenScripts(snapshot, recordingId).map((spoken) => spoken.audioScriptId));
-	if (scripts.size > 1) projectionError("ambiguous-script", `media-entities/${recordingId}`, "Multiple scripts cannot be silently concatenated into audio_script");
-	const id = [...scripts][0];
-	if (!id) return "";
-	const body = snapshot.richText[id]?.plainText ?? "";
-	const segments = lines(body);
-	const said = /* @__PURE__ */ new Set();
-	for (const clipId of captionClipIds) {
-		const captionId = snapshot["clip-entities"][clipId]?.source;
-		const caption = captionId === void 0 ? void 0 : snapshot["caption-entities"][captionId];
-		const shown = captionId === void 0 ? void 0 : snapshot.captionText[captionId];
-		if (caption?.selection?.audioScriptId !== id || caption.text !== void 0 || !shown) continue;
-		segments.forEach((line, index) => {
-			if (shown.start < Math.max(line.end, line.start + 1) && shown.end > line.start) said.add(index);
-		});
-	}
-	if (!said.size) return body;
-	return [...said].sort((a, b) => a - b).map((index) => segments[index].text).join("\n");
+function spokenText(snapshot, recordingId) {
+	const spoken = spokenScripts(snapshot, recordingId);
+	if (new Set(spoken.map((s) => s.phoneticScriptId ?? s.audioScriptId)).size > 1) projectionError("ambiguous-script", `media-entities/${recordingId}`, "Multiple scripts cannot be silently concatenated into audio_script");
+	const [first] = spoken;
+	if (!first) return "";
+	if (first.phoneticScriptId !== void 0) return snapshot.phoneticText[first.phoneticScriptId]?.text ?? "";
+	const script = snapshot["audio-script-entities"][first.audioScriptId];
+	return script ? script.segments.map((segment) => segment.text).join("\n") : "";
 }
 //#endregion
 //#region src/dsl/projection/from-video-draft.ts
@@ -5894,16 +8327,16 @@ function prepare(input, options) {
 		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
-			};
+			script = importedScript(claim(mint("audio-script")), speech.audio_script, () => mint("segment"));
 			scriptByRecording.set(recordingId, script);
 			mutations.push({
 				type: "create-entity",
 				table: "audio-script-entities",
 				id: script.id,
-				value: { body: script.text }
+				value: { segments: script.segments.map(({ id, text }) => ({
+					id,
+					text
+				})) }
 			}, {
 				type: "set-relation",
 				table: "derived-from-relations",
@@ -5951,12 +8384,18 @@ function prepare(input, options) {
 			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, {
+			const end = start + text.length;
+			const segment = script.segments.find((s) => start >= s.start && end <= s.start + s.text.length);
+			if (start >= 0 && segment) {
+				cursor = end;
+				selections.set(captionId, text === segment.text ? {
+					audioScriptId: script.id,
+					segmentId: segment.id
+				} : {
 					audioScriptId: script.id,
-					start,
-					end: cursor
+					segmentId: segment.id,
+					start: start - segment.start,
+					end: end - segment.start
 				});
 			} else diagnostics.push({
 				code: "caption-text-unmatched",
@@ -6067,5 +8506,22 @@ 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;
 }
+function importedScript(id, text, mintSegment) {
+	const segments = [];
+	let start = 0;
+	if (text.length) for (const line of text.split("\n")) {
+		segments.push({
+			id: mintSegment(),
+			text: line,
+			start
+		});
+		start += line.length + 1;
+	}
+	return {
+		id,
+		text,
+		segments
+	};
+}
 //#endregion
-export { DslEditor as a, DslProjectionError as c, createInitialMedeoDsl as i, toVideoDraft as n, MedeoDsl as o, toAudioScriptViews as r, resolveDslLayout as s, fromVideoDraft as t };
+export { defaultIdFactory as _, DslEditor as a, tupleHash as b, UnsupportedDocumentFormatError as c, medeoDslLoroShape as d, captionContentCodec as f, DslProjectionError as g, resolveDslLayout as h, createInitialMedeoDsl as i, assertDslDocument as l, timeAnchorCodec as m, toVideoDraft as n, toAudioScriptViews as o, isInvalidAtomic as p, DEFAULT_UNIT_TIME_MS as r, MedeoDsl as s, fromVideoDraft as t, documentFormat as u, relationId as v, resourceId as y };