@mengine/medeo-client 0.1.0

package/dist/index.js

@@ -0,0 +1,3374 @@
+import { t as __exportAll } from "./chunk-D7D4PA-g.js";
+import { Mirror, schema } from "loro-mirror";
+import { z } from "zod";
+import { LoroDoc } from "loro-crdt";
+import { ClientServerSynchronizer, DocManager } from "@mengine/sync";
+import { DisposableSet, EventBus, Task } from "@mengine/utils";
+import { BaseDocStorage, DummyConnection } from "@mengine/storage";
+//#region src/client/base64.ts
+function bytesToBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function base64ToBytes(base64) {
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+//#endregion
+//#region src/client/http-client.ts
+var MengineHttpRequestError = class extends Error {
+	status;
+	payload;
+	constructor(status, payload) {
+		super(`mengine request failed: ${status}`);
+		this.status = status;
+		this.payload = payload;
+		this.name = "MengineHttpRequestError";
+	}
+};
+var MengineHttpClient = class {
+	options;
+	fetchImpl;
+	constructor(options) {
+		this.options = options;
+		this.fetchImpl = options.fetchImpl ?? globalThis.fetch.bind(globalThis);
+	}
+	async fetchSnapshot() {
+		return await this.requestJson("snapshot");
+	}
+	async bootstrapSnapshot(snapshot) {
+		return await this.requestJson("bootstrap", {
+			method: "POST",
+			body: JSON.stringify({ snapshot: bytesToBase64(snapshot) })
+		});
+	}
+	/**
+	* Loro VV-diff pull: send the caller's oplog `VersionVector.encode` as `from`
+	* (omit for a full pull) and receive exactly the updates it is missing plus
+	* the server's current VV. Replaces the old integer `after_update_id` cursor.
+	*/
+	async sync(fromVV) {
+		const query = fromVV != null ? `?from=${encodeURIComponent(bytesToBase64(fromVV))}` : "";
+		return await this.requestJson(`sync${query}`);
+	}
+	/** Audit trail: extracted metadata per accepted update, in log order. */
+	async audit() {
+		return await this.requestJson("audit");
+	}
+	async pushUpdate(update, baseVersion = null) {
+		const response = await this.requestJson("updates", {
+			method: "POST",
+			body: JSON.stringify({
+				update: bytesToBase64(update),
+				base_version: baseVersion
+			})
+		});
+		if (response.kind === "rejected") throw new MengineHttpRequestError(409, response);
+		return response;
+	}
+	eventsUrl() {
+		return this.endpoint("events");
+	}
+	headers() {
+		const headers = new Headers();
+		headers.set("accept", "application/json");
+		headers.set("content-type", "application/json");
+		if (this.options.authToken != null && this.options.authToken !== "") headers.set("authorization", `Bearer ${this.options.authToken}`);
+		const userId = typeof this.options.userId === "function" ? this.options.userId() : this.options.userId;
+		if (userId != null && userId !== "") headers.set("medeo-user-id", userId);
+		return headers;
+	}
+	async fetch(input, init) {
+		return await this.fetchImpl(input, init);
+	}
+	async requestJson(path, init = {}) {
+		const headers = this.headers();
+		new Headers(init.headers).forEach((value, key) => {
+			headers.set(key, value);
+		});
+		const response = await this.fetchImpl(this.endpoint(path), {
+			...init,
+			headers
+		});
+		const payload = await safeReadJson(response);
+		if (!response.ok) throw new MengineHttpRequestError(response.status, payload);
+		return payload;
+	}
+	endpoint(path) {
+		return `${this.options.httpOrigin.replace(/\/$/, "")}/api/mengine/docs/${encodeURIComponent(this.options.docId)}/${path}`;
+	}
+};
+async function safeReadJson(response) {
+	const text = await response.text();
+	if (text.length === 0) return null;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+//#endregion
+//#region src/client/sse.ts
+async function readMengineEventStream(options) {
+	const onUpdate = (event) => {
+		options.onUpdate(event);
+	};
+	const response = await options.client.fetch(options.client.eventsUrl(), {
+		headers: options.client.headers(),
+		signal: options.signal
+	});
+	if (!response.ok) throw new Error(`mengine event stream failed: ${response.status}`);
+	const reader = response.body?.getReader();
+	if (reader == null) throw new Error("mengine event stream response has no readable body");
+	options.onOpen?.();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	while (options.signal?.aborted !== true) {
+		const { done, value } = await reader.read();
+		if (done) return;
+		buffer += decoder.decode(value, { stream: true });
+		let splitAt = findSseFrameBoundary(buffer);
+		while (splitAt >= 0) {
+			const frame = buffer.slice(0, splitAt);
+			buffer = buffer.slice(buffer[splitAt] === "\r" ? splitAt + 4 : splitAt + 2);
+			handleSseFrame(frame, onUpdate);
+			splitAt = findSseFrameBoundary(buffer);
+		}
+	}
+}
+function handleSseFrame(frame, onUpdate) {
+	const event = parseSseFrame(frame);
+	if (event.event !== "update" || event.data.length === 0) return;
+	onUpdate(JSON.parse(event.data.join("\n")));
+}
+function parseSseFrame(frame) {
+	let event = null;
+	const data = [];
+	for (const line of frame.split(/\r?\n/)) if (line.startsWith("event:")) event = line.slice(6).trim();
+	else if (line.startsWith("data:")) data.push(line.slice(5).trimStart());
+	return {
+		event,
+		data
+	};
+}
+function findSseFrameBoundary(buffer) {
+	const lf = buffer.indexOf("\n\n");
+	const crlf = buffer.indexOf("\r\n\r\n");
+	if (lf < 0) return crlf;
+	if (crlf < 0) return lf;
+	return Math.min(lf, crlf);
+}
+//#endregion
+//#region src/document/mirror-schema.ts
+/**
+* Declarative `loro-mirror` schema for `VideoDocument` — the canonical structural
+* SSOT and live storage wire (replaces the hand-rolled `@mengine/schema`
+* definition + adapter, see ADR 0008).
+*
+* Mirror gives an in-memory immutable state synced to the Loro doc by declarative
+* diff, so the storage layer no longer hand-writes per-region reconcile or a
+* transaction state machine. The shapes here store only authoritative facts
+* (RFC 02 §6): per-item absolute time, `part_aggregations`, and total duration
+* are projection-derived (cascade-solved at read time), so they are absent here.
+*
+* - tracks live in a single `tracks` `LoroMovableList` keyed by track id
+*   (reference/17 §4). Lane is expressed by each track's `parts_kind`, not by
+*   which container it lives in; order is the movable-list order itself. There is
+*   no `lane` / `lane_order` field, so two peers inserting tracks never collide
+*   on an order integer — list moves are conflict-free (RFC 03 §4). The legacy
+*   keyed-map (`LoroMapRecord` + an integer `lane_order`) and the prior three
+*   named containers are gone; the `main` / `above` / `below` three-pane view is
+*   rebuilt by the projection from `parts_kind`.
+* - each track's `items` is a `LoroMovableList` keyed by `part_id`: a part is
+*   placed at most once per lane, so `part_id` is the stable placement identity.
+*   Reorder diffs to a real Loro `move`, preserving per-item CRDT identity on
+*   every lane (main and secondary alike).
+* - `time_position` is the authoritative positioning fact (RFC 02 §4,
+*   reference/17 §3), carried as an opaque JSON blob string (a whole tagged-union
+*   value, last-writer-wins). The derived `fallback_abs_ms` snapshot sits beside
+*   it as its own number field — a separate LWW unit so a projection refresh
+*   never clobbers a `time_position` edit.
+* - meta lives in a `meta` LoroMap: the mirror root only accepts container
+*   schemas, so meta scalars can't sit at the root as bare values. The domain
+*   `VideoDocument` keeps the same `meta` wrapper, so the shapes are isomorphic
+*   and the read/seed mapping is a near-identity.
+* - `part_library` values are nested `LoroMap`s: the value is a `LoroMap` with
+*   four mutually-exclusive optional part sub-maps (`video_clip` / `speech` /
+*   `caption` / `bgm`), each a `LoroMap` whose fields are stored as real Loro
+*   sub-keys. This makes each field its own CRDT unit, so two peers editing
+*   different fields of the same part (e.g. one volume, one play_out) merge
+*   field-by-field instead of one whole-value overwrite. Field `required` mirrors
+*   the Smithy `@required` contract (see `video_draft_comp.smithy`). `kind` is not
+*   stored (the present sub-key names the kind); `duration_ms` is not stored (it
+*   is derived, reference/17 §5). Nested values that the engine does not edit
+*   field-by-field — `speed_shift` (a tagged union), `voice`, `caption_ids` — stay
+*   as opaque JSON-blob sub-keys via `transform`. The four sub-keys are optional,
+*   so the "exactly one part kind" union invariant is not enforced by the schema
+*   type; it is rebuilt by `draftToPartUnion` on read and gated by zod on write.
+* - a caption's `style` is the one lazily-created optional child container, so
+*   `captionPart` sets `mergeableMapChildContainers: true` — two peers can
+*   concurrently first-create the same caption's `style` (one attribute each), and
+*   only a mergeable child converges instead of last-writer-wins dropping one. All
+*   other nested maps are keyed by a unique id (`part_library`) or created
+*   atomically with their parent (`partValue`'s part sub-map), so they never hit
+*   that concurrent-first-create fork and stay on plain `setContainer`. See the
+*   note on `captionPart` below.
+* - `video_creation_settings` is an opaque JSON blob carried in a string via
+*   `transform`: a whole value, last-writer-wins (no field-level concurrent edits).
+*/
+/**
+* JSON-blob transform for an opaque, last-writer-wins value carried in a Loro
+* string. The field must be declared `required: false`: an absent field decodes
+* to `undefined` (mirror never calls `decode`/`encode` for null/undefined),
+* which is how we represent "no value" instead of encoding a `null` sentinel.
+*/
+function jsonTransform() {
+	return {
+		decode: (value) => JSON.parse(value),
+		encode: (value) => JSON.stringify(value),
+		isEqual: "encoded-value-equality"
+	};
+}
+const trackItem = schema.LoroMap({
+	part_id: schema.String(),
+	time_position: schema.String().transform(jsonTransform()),
+	fallback_abs_ms: schema.Number({ required: false })
+});
+const track = schema.LoroMap({
+	id: schema.String(),
+	parts_kind: schema.String({ required: false }),
+	is_hidden: schema.Boolean({ required: false }),
+	items: schema.LoroMovableList(trackItem, (item) => item.part_id)
+});
+const videoClipPart = schema.LoroMap({
+	id: schema.String(),
+	play_in: schema.Number(),
+	play_out: schema.Number(),
+	volume: schema.Number(),
+	origin_media_id: schema.String(),
+	speed_shift: schema.String({ required: false }).transform(jsonTransform())
+}, { required: false });
+const speechPart = schema.LoroMap({
+	id: schema.String(),
+	media_duration_ms: schema.Number(),
+	audio_script: schema.String(),
+	volume: schema.Number(),
+	audio_storage_key: schema.String(),
+	origin_speech_id: schema.String(),
+	voice: schema.String().transform(jsonTransform()),
+	caption_ids: schema.String().transform(jsonTransform())
+}, { required: false });
+const captionStyle = schema.LoroMap({
+	font_id: schema.String({ required: false }),
+	font_size: schema.Number({ required: false }),
+	font_color: schema.String({ required: false }),
+	font_weight: schema.Number({ required: false }),
+	entrance_animation: schema.String({ required: false }),
+	entrance_animation_duration_ms: schema.Number({ required: false }),
+	stroke_color: schema.String({ required: false }),
+	stroke_width: schema.Number({ required: false }),
+	position_x: schema.Number({ required: false }),
+	position_y: schema.Number({ required: false })
+}, { required: false });
+const captionPart = schema.LoroMap({
+	id: schema.String(),
+	initial_duration_ms: schema.Number(),
+	speech_part_id: schema.String(),
+	text: schema.String(),
+	start_ms: schema.Number(),
+	style: captionStyle
+}, {
+	required: false,
+	mergeableMapChildContainers: true
+});
+const bgmPart = schema.LoroMap({
+	id: schema.String(),
+	audio_storage_key: schema.String(),
+	volume: schema.Number(),
+	origin_media_id: schema.String()
+}, { required: false });
+const partValue = schema.LoroMap({
+	video_clip: videoClipPart,
+	speech: speechPart,
+	caption: captionPart,
+	bgm: bgmPart
+});
+const videoDocumentMirrorSchema = schema({
+	meta: schema.LoroMap({
+		schema_version: schema.String({ required: false }),
+		draft_id: schema.String({ required: false }),
+		project_id: schema.String({ required: false }),
+		owner_id: schema.String({ required: false }),
+		thumbnail_storage_key: schema.String({ required: false }),
+		chat_session_id: schema.String({ required: false }),
+		video_creation_settings: schema.String({ required: false }).transform(jsonTransform()),
+		version: schema.Number({ required: false })
+	}),
+	timeline: schema.LoroMap({ unit_time_ms: schema.Number({ required: false }) }),
+	tracks: schema.LoroMovableList(track, (t) => t.id),
+	part_library: schema.LoroMapRecord(partValue)
+});
+/** Project a discriminated `PartUnion` into the draft's four-optional shape. */
+function partUnionToDraft(part) {
+	if (part.video_clip != null) return { video_clip: omitKind(part.video_clip) };
+	if (part.speech != null) return { speech: omitKind(part.speech) };
+	if (part.caption != null) return { caption: omitKind(part.caption) };
+	return { bgm: omitKind(part.bgm) };
+}
+/**
+* Rebuild a discriminated `PartUnion` from a draft part value: pick the one
+* present sub-key, restore its `kind`, and drop the `$cid`. Returns `undefined`
+* when no part sub-key is present (an empty/placeholder value).
+*/
+function draftToPartUnion(value) {
+	if (value == null) return void 0;
+	const v = value;
+	if (v.video_clip != null) return { video_clip: withKind(v.video_clip, "video_clip") };
+	if (v.speech != null) return { speech: withKind(v.speech, "speech") };
+	if (v.caption != null) return { caption: withKind(v.caption, "caption") };
+	if (v.bgm != null) return { bgm: withKind(v.bgm, "bgm") };
+}
+/** Drop `kind` (not stored) and `$cid` from a part payload for the draft. */
+function omitKind(part) {
+	const { kind: _kind, $cid: _cid, ...rest } = part;
+	return rest;
+}
+/** Restore `kind` (and drop `$cid`) on a part sub-map read from the draft. */
+function withKind(part, kind) {
+	const { $cid: _cid, ...rest } = part;
+	return {
+		...rest,
+		kind
+	};
+}
+/** Entries of a draft record (e.g. `tracks`) with `$cid` stripped. */
+function recordEntries(record) {
+	if (record == null) return [];
+	const out = [];
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "$cid") continue;
+		out.push([key, value]);
+	}
+	return out;
+}
+//#endregion
+//#region src/document/types.ts
+const VIDEO_DOCUMENT_SCHEMA_VERSION = "video-document/v0";
+/** The linear speed multiplier of a `speed_shift`, defaulting to 1 (original). */
+function speedOf(speedShift) {
+	const speed = speedShift?.config?.linear?.speed;
+	return typeof speed === "number" && Number.isFinite(speed) && speed > 0 ? speed : 1;
+}
+/**
+* A video clip's effective timeline duration, derived from authoritative facts
+* (RFC 02, `reference/16` §4, reference/17 §5): the trim window
+* `play_out - play_in` divided by the speed multiplier, rounded to integer ms.
+* `play_in` / `play_out` are optional in the IDL but every write path sets them
+* (defaulting to the whole media), and the legacy-ingest projection backfills the
+* window from a legacy `duration_ms` — so an authoritative clip always carries a
+* trim window and there is no stored `duration_ms` to fall back to. A clip with
+* neither bound yields 0. Speeds the clip up (>1× → shorter) or down (<1×).
+*/
+function effectiveVideoClipDurationMs(clip) {
+	const speed = speedOf(clip.speed_shift);
+	const sourceMs = (clip.play_out ?? 0) - (clip.play_in ?? 0);
+	const effective = Math.round(sourceMs / speed);
+	return Number.isFinite(effective) && effective > 0 ? effective : 0;
+}
+//#endregion
+//#region src/timeline-core/types.ts
+/** Total document duration when there is no real content (matches FE bgm fallback). */
+const TIMELINE_SKELETON_DURATION_MS = 2e4;
+/** Empty placeholder clip marker: a video_clip part with no backing media. */
+function isEmptyVideoClip(part) {
+	const clip = part?.video_clip;
+	if (clip == null) return false;
+	return clip.origin_media_id == null || clip.origin_media_id === "";
+}
+/** Clamp a duration to a non-negative integer (NaN/Infinity/negative → 0). */
+function safeDurationMs(value) {
+	const n = Number(value);
+	if (!Number.isFinite(n) || n <= 0) return 0;
+	return Math.round(n);
+}
+function partDurationMs(doc, partId) {
+	const part = doc.part_library[partId];
+	if (part?.video_clip != null) return safeDurationMs(effectiveVideoClipDurationMs(part.video_clip));
+	if (part?.bgm != null) return doc.timeline.duration_ms > 0 ? doc.timeline.duration_ms : TIMELINE_SKELETON_DURATION_MS;
+	if (part?.speech != null) return safeDurationMs(part.speech.media_duration_ms);
+	if (part?.caption != null) return safeDurationMs(part.caption.initial_duration_ms);
+	return 0;
+}
+//#endregion
+//#region src/timeline-core/cascade.ts
+/**
+* Canonical timeline cascade primitives (ADR 0009).
+*
+* Single source of truth for "how an edit's connected regions move": main-track
+* seamless layout, aggregation position sync + reassignment, total-duration
+* recompute, speech-overlap resolution, gap filling. Reconciled per ADR 0009 §4:
+*
+* - product behavior follows the FE current implementation;
+* - all times are integer ms — positions/durations are rounded, never floated;
+* - function decomposition follows agent-harness (the Python-derived structure).
+*
+* Every function mutates the `TimelineDoc` in place (the editor runs them inside
+* one immer `transact`, so in-place edits diff correctly).
+*/
+/**
+* Lay the main track out head-to-tail from 0, rewriting each item's
+* `abs_time_position`. Items whose part is missing from the library are dropped.
+*/
+function arrangeMainTrackSeamlessly(doc) {
+	const kept = [];
+	let cursor = 0;
+	for (const item of doc.main_track) {
+		if (doc.part_library[item.part_id] == null) continue;
+		item.abs_time_position = cursor;
+		cursor += partDurationMs(doc, item.part_id);
+		kept.push(item);
+	}
+	doc.main_track = kept;
+}
+/**
+* Sync attached parts' absolute positions from their host:
+*   speech.abs   = host_video.abs + relative_time_position
+*   caption.abs  = speech.abs + caption.start_ms
+*/
+function syncAggregatedClipsTimePosition(doc) {
+	const videoByPart = indexByPart(doc.main_track);
+	const speechByPart = indexByPart(doc.speech_track);
+	for (const aggregation of doc.aggregations) {
+		const videoItem = videoByPart.get(aggregation.body_part_id);
+		if (videoItem == null) continue;
+		for (const attachment of aggregation.attachments) {
+			const speechItem = speechByPart.get(attachment.part_id);
+			if (speechItem == null) continue;
+			speechItem.abs_time_position = videoItem.abs_time_position + attachment.relative_time_position;
+		}
+	}
+	for (const captionItem of doc.caption_track) {
+		const captionPart = doc.part_library[captionItem.part_id]?.caption;
+		if (captionPart == null) continue;
+		const speechItem = captionPart.speech_part_id == null ? void 0 : speechByPart.get(captionPart.speech_part_id);
+		if (speechItem == null) continue;
+		captionItem.abs_time_position = speechItem.abs_time_position + safeDurationMs(captionPart.start_ms);
+	}
+}
+/**
+* Reassign each speech to the video clip whose time range contains its start,
+* rebuilding `aggregations`. A speech before the first clip or after the last
+* falls back to the first / last clip respectively (FE: see §4 note — FE falls
+* back to last only; we keep the harness two-sided fallback because a speech
+* dragged before clip 0 belonging to the last clip is clearly wrong, and the FE
+* single-sided rule is an acknowledged rough edge). `relative_time_position` is
+* clamped to a non-negative integer.
+*/
+function reassignSpeechesToVideoClipsByTime(doc) {
+	const ranges = doc.main_track.filter((item) => doc.part_library[item.part_id] != null).map((item) => ({
+		part_id: item.part_id,
+		start: item.abs_time_position,
+		end: item.abs_time_position + partDurationMs(doc, item.part_id)
+	}));
+	if (ranges.length === 0) {
+		doc.aggregations = [];
+		return;
+	}
+	const rebuilt = /* @__PURE__ */ new Map();
+	for (const speechItem of doc.speech_track) {
+		const start = speechItem.abs_time_position;
+		const targetRange = ranges.find((r) => r.start <= start && start < r.end) ?? (start < ranges[0].start ? ranges[0] : ranges[ranges.length - 1]);
+		const relative = Math.max(0, Math.round(start - targetRange.start));
+		const targetId = targetRange.part_id;
+		let aggregation = rebuilt.get(targetId);
+		if (aggregation == null) {
+			aggregation = {
+				body_part_id: targetId,
+				attachments: []
+			};
+			rebuilt.set(targetId, aggregation);
+		}
+		aggregation.attachments.push({
+			part_id: speechItem.part_id,
+			relative_time_position: relative
+		});
+	}
+	doc.aggregations = ranges.map((r) => rebuilt.get(r.part_id)).filter((a) => a != null);
+}
+/**
+* Recompute `timeline.duration_ms` as the max end (abs + duration) across main,
+* speech, and caption lanes (BGM does not extend the timeline).
+*
+* BGM has no authoritative duration (RFC 02 / `reference/16` §0b): its effective
+* length is always the timeline total, so it is not written back here — the
+* projection derives it from `timeline.duration_ms` on read (`partDurationMs`
+* returns the timeline total for a bgm part). The empty-document 20s skeleton is
+* applied at that read step, not stored.
+*/
+function recalculateTimelineDuration(doc) {
+	const max = Math.max(laneEndMs(doc, doc.main_track), laneEndMs(doc, doc.speech_track), laneEndMs(doc, doc.caption_track));
+	doc.timeline.duration_ms = max;
+}
+/**
+* Resolve one speech overlap by shifting the overlapping speech's host video
+* (and every clip after it) right. Returns true when one overlap was resolved;
+* callers loop until it returns false. The compared range is the speech merged
+* with its captions: start = min(speech.start, captions.start) (FE behavior),
+* end = max(speech.end, captions.end).
+*/
+function resolveSpeechOverlapByShiftingVideos(doc) {
+	const speeches = doc.speech_track;
+	for (let i = 1; i < speeches.length; i++) {
+		const prev = speechWithCaptionsRange(doc, speeches[i - 1]);
+		const curr = speechWithCaptionsRange(doc, speeches[i]);
+		if (prev == null || curr == null) continue;
+		if (curr.start >= prev.end) continue;
+		const overlapMs = Math.round(prev.end - curr.start);
+		const hostId = hostVideoOf(doc, speeches[i].part_id);
+		if (hostId == null) continue;
+		const fromIndex = doc.main_track.findIndex((item) => item.part_id === hostId);
+		if (fromIndex < 0) continue;
+		for (let idx = fromIndex; idx < doc.main_track.length; idx++) doc.main_track[idx].abs_time_position += overlapMs;
+		syncAggregatedClipsTimePosition(doc);
+		return true;
+	}
+	return false;
+}
+/**
+* Resolve speech overlaps for one cascade pass. Mirrors the authoritative FE
+* `ensureNoOverlappingClips`, which is documented to resolve AT MOST ONE overlap
+* per cascade and is invoked exactly once at every FE call site — the supported
+* ops each produce at most one new overlap. It is NOT a fixpoint loop: shifting a
+* host right also moves every speech anchored to it, so two speeches sharing a
+* host can never be separated by shifting. Looping to a "fixed point" there does
+* not converge — it accumulates the same overlap every iteration and pushes the
+* clip arbitrarily far right (e.g. a sped-up clip landing at ~287k ms instead of
+* its seamless slot). A single pass matches FE product behavior and terminates.
+*/
+function resolveAllSpeechOverlaps(doc) {
+	resolveSpeechOverlapByShiftingVideos(doc);
+}
+/**
+* Make the main track gapless by adjusting/merging empty placeholder clips or
+* inserting new ones between real clips. Mirrors the harness four-case rule, but
+* the merge of two adjacent empty clips keeps the earlier clip (harness Case 4).
+* Requires `makeEmptyPart` to mint a placeholder part (the editor supplies an
+* id generator).
+*/
+function fillMainTrackTimeGaps(doc, makeEmptyPart) {
+	const items = doc.main_track;
+	let i = 0;
+	while (i < items.length) {
+		const current = items[i];
+		const currentPart = doc.part_library[current.part_id];
+		if (currentPart == null) {
+			i += 1;
+			continue;
+		}
+		const currentEnd = current.abs_time_position + partDurationMs(doc, current.part_id);
+		if (i + 1 >= items.length) break;
+		const next = items[i + 1];
+		const nextPart = doc.part_library[next.part_id];
+		if (nextPart == null) {
+			i += 1;
+			continue;
+		}
+		const gap = next.abs_time_position - currentEnd;
+		if (gap > 0) {
+			if (isEmptyVideoClip(currentPart)) {
+				extendEmptyClip(currentPart.video_clip, gap);
+				continue;
+			}
+			if (isEmptyVideoClip(nextPart)) {
+				next.abs_time_position -= gap;
+				extendEmptyClip(nextPart.video_clip, gap);
+				i += 1;
+				continue;
+			}
+			const { partId } = makeEmptyPart(gap);
+			doc.part_library[partId] = { video_clip: {
+				id: partId,
+				kind: "video_clip",
+				play_in: 0,
+				play_out: gap,
+				volume: 0,
+				origin_media_id: ""
+			} };
+			items.splice(i + 1, 0, {
+				part_id: partId,
+				time_position: { mode: "sequential" },
+				abs_time_position: currentEnd
+			});
+			i += 1;
+			continue;
+		}
+		if (gap === 0 && isEmptyVideoClip(currentPart) && isEmptyVideoClip(nextPart)) {
+			extendEmptyClip(currentPart.video_clip, partDurationMs(doc, next.part_id));
+			items.splice(i + 1, 1);
+			delete doc.part_library[next.part_id];
+			continue;
+		}
+		i += 1;
+	}
+}
+function indexByPart(items) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of items) map.set(item.part_id, item);
+	return map;
+}
+function laneEndMs(doc, items) {
+	let max = 0;
+	for (const item of items) {
+		if (doc.part_library[item.part_id] == null) continue;
+		const end = item.abs_time_position + partDurationMs(doc, item.part_id);
+		if (end > max) max = end;
+	}
+	return max;
+}
+function extendEmptyClip(clip, byMs) {
+	clip.play_out = safeDurationMs(clip.play_out) + byMs;
+}
+/** speech merged with its captions: start = min, end = max. */
+function speechWithCaptionsRange(doc, speechItem) {
+	const speech = doc.part_library[speechItem.part_id]?.speech;
+	if (speech == null) return null;
+	let start = speechItem.abs_time_position;
+	let end = speechItem.abs_time_position + safeDurationMs(speech.media_duration_ms);
+	for (const captionId of captionIdsOf(speech)) {
+		const captionItem = doc.caption_track.find((item) => item.part_id === captionId);
+		const captionPart = doc.part_library[captionId]?.caption;
+		if (captionItem == null || captionPart == null) continue;
+		const cStart = captionItem.abs_time_position;
+		const cEnd = captionItem.abs_time_position + safeDurationMs(captionPart.initial_duration_ms);
+		if (cStart < start) start = cStart;
+		if (cEnd > end) end = cEnd;
+	}
+	return {
+		start,
+		end
+	};
+}
+function captionIdsOf(speech) {
+	return (speech.caption_ids ?? []).filter((id) => id != null);
+}
+function hostVideoOf(doc, speechPartId) {
+	for (const aggregation of doc.aggregations) if (aggregation.attachments.some((att) => att.part_id === speechPartId)) return aggregation.body_part_id;
+	return null;
+}
+//#endregion
+//#region src/timeline-core/entrypoints.ts
+/**
+* The full solve pipeline: arrange → sync → reassign → resolve-overlap →
+* fill-gaps → recalc. The single cascade the read-side projection runs; ops
+* never call it (they write only facts — RFC 02 §7/§10).
+*/
+function cascadeAfterVideoClipChanges(doc, makeEmptyPart) {
+	arrangeMainTrackSeamlessly(doc);
+	syncAggregatedClipsTimePosition(doc);
+	reassignSpeechesToVideoClipsByTime(doc);
+	resolveAllSpeechOverlaps(doc);
+	fillMainTrackTimeGaps(doc, makeEmptyPart);
+	recalculateTimelineDuration(doc);
+}
+//#endregion
+//#region src/timeline-core/bridge.ts
+/**
+* Solve a `VideoDocument` (authoritative, position-only) into its derived
+* read-view: absolute time per item, `part_aggregations`, and total duration.
+* This is the read side of the single-directional flow — never written back.
+*/
+function solveVideoDocument(document) {
+	const doc = videoDocumentToTimelineDoc(document);
+	let counter = 0;
+	cascadeAfterVideoClipChanges(doc, () => ({ partId: `empty_${counter++}` }));
+	const absByPartId = /* @__PURE__ */ new Map();
+	for (const item of doc.main_track) absByPartId.set(item.part_id, item.abs_time_position);
+	for (const item of doc.speech_track) absByPartId.set(item.part_id, item.abs_time_position);
+	for (const item of doc.caption_track) absByPartId.set(item.part_id, item.abs_time_position);
+	for (const item of doc.bgm_track) absByPartId.set(item.part_id, item.abs_time_position);
+	return {
+		absByPartId,
+		aggregations: doc.aggregations.map((aggregation) => ({
+			body_part_id: aggregation.body_part_id,
+			attachments: aggregation.attachments.map((a) => ({
+				part_id: a.part_id,
+				relative_time_position: a.relative_time_position
+			}))
+		})),
+		durationMs: doc.timeline.duration_ms,
+		partLibrary: doc.part_library
+	};
+}
+function videoDocumentToTimelineDoc(document) {
+	const partLibrary = {};
+	for (const [partId, part] of Object.entries(document.part_library ?? {})) partLibrary[partId] = part;
+	const laneItems = (track) => (track?.items ?? []).map((item) => ({
+		part_id: item.part_id,
+		time_position: item.time_position,
+		abs_time_position: seedAbs(item.time_position, item.fallback_abs_ms),
+		fallback_abs_ms: item.fallback_abs_ms
+	}));
+	const tracks = document.tracks ?? [];
+	let mainItems = [];
+	let speechItems = [];
+	let bgmItems = [];
+	let captionItems = [];
+	for (const t of tracks) switch (t.parts_kind) {
+		case "video_clip":
+			mainItems = mainItems.concat(laneItems(t));
+			break;
+		case "speech":
+			speechItems = speechItems.concat(laneItems(t));
+			break;
+		case "bgm":
+			bgmItems = bgmItems.concat(laneItems(t));
+			break;
+		case "caption":
+			captionItems = captionItems.concat(laneItems(t));
+			break;
+	}
+	return {
+		main_track: mainItems,
+		speech_track: speechItems,
+		caption_track: captionItems,
+		bgm_track: bgmItems,
+		part_library: partLibrary,
+		aggregations: seedAggregations(mainItems, speechItems),
+		timeline: {
+			duration_ms: 0,
+			unit_time_ms: document.timeline?.unit_time_ms ?? 0
+		}
+	};
+}
+/**
+* Seed an item's solve-variable `abs_time_position` from its `time_position` (and
+* the `fallback_abs_ms` snapshot carried beside it): `absolute` → `offsetMs`;
+* `anchored` → `fallbackAbsMs` (last solved position, also the orphan-recovery
+* anchor when the host is gone); `sequential` → 0 (the cascade lays the main
+* track out head-to-tail). The cascade then resolves anchored items against their
+* host, so this seed only needs to put each item somewhere plausible for the
+* first reassign/overlap pass.
+*/
+function seedAbs(position, fallbackAbsMs) {
+	switch (position.mode) {
+		case "absolute": return Math.round(position.offsetMs);
+		case "anchored": return Math.round(fallbackAbsMs ?? 0);
+		case "sequential": return 0;
+	}
+}
+/**
+* Build the cascade `aggregations` parent-map from anchored items: an anchored
+* item's `anchorPartId` is the host's `part_id` (= `body_part_id`), `offsetMs`
+* is `relative_time_position`. Only main-track (video) hosts form aggregations;
+* caption→speech relations are recomputed by the cascade from `caption.start_ms`.
+*/
+function seedAggregations(mainItems, speechItems) {
+	const mainPartIds = new Set(mainItems.map((item) => item.part_id));
+	const byHost = /* @__PURE__ */ new Map();
+	const order = [];
+	for (const speech of speechItems) {
+		if (speech.time_position.mode !== "anchored") continue;
+		const host = speech.time_position.anchorPartId;
+		if (!mainPartIds.has(host)) continue;
+		let aggregation = byHost.get(host);
+		if (aggregation == null) {
+			aggregation = {
+				body_part_id: host,
+				attachments: []
+			};
+			byHost.set(host, aggregation);
+			order.push(host);
+		}
+		aggregation.attachments.push({
+			part_id: speech.part_id,
+			relative_time_position: speech.time_position.offsetMs
+		});
+	}
+	return order.map((host) => byHost.get(host));
+}
+/**
+* Lane-stacking rank for the single `tracks` list (reference/17 §4): caption
+* (above) sits before the video_clip main track, which sits before speech / bgm
+* (below). The `tracks` array is kept in this top-to-bottom order so a freshly
+* minted track lands in the right place and the projection's three-pane rebuild
+* stays deterministic.
+*/
+function laneRank(kind) {
+	switch (kind) {
+		case "caption": return 0;
+		case "video_clip": return 1;
+		case "speech":
+		case "bgm": return 2;
+		default: return 3;
+	}
+}
+/**
+* Insert a freshly-minted track into `tracks` at the position that keeps the
+* lane-stacking order (caption → main → speech/bgm). Inserts before the first
+* track whose rank is strictly greater, so same-rank tracks keep insertion order.
+*/
+function insertTrackByLaneOrder(tracks, track) {
+	const rank = laneRank(track.parts_kind);
+	const at = tracks.findIndex((t) => laneRank(t?.parts_kind) > rank);
+	if (at < 0) tracks.push(track);
+	else tracks.splice(at, 0, track);
+}
+/**
+* Locate a lane's track row in the single `tracks` list by kind, minting an empty
+* row in lane-stacking order if absent (reference/17 §4: lane = `parts_kind`).
+* Ops use this to write authoritative items onto the right lane. The track id
+* mirrors the seed convention (`<kind>_track`).
+*/
+function ensureLaneTrack(draft, kind) {
+	draft.tracks ??= [];
+	let track = draft.tracks.find((t) => t?.parts_kind === kind);
+	if (track == null) {
+		track = {
+			id: kind === "video_clip" ? "main_track" : `${kind}_track`,
+			parts_kind: kind,
+			is_hidden: void 0,
+			items: []
+		};
+		insertTrackByLaneOrder(draft.tracks, track);
+	}
+	track.items ??= [];
+	return track;
+}
+/** Find a secondary lane's track row without minting it. */
+function findLaneTrack(draft, kind) {
+	return (draft.tracks ?? []).find((t) => t?.parts_kind === kind);
+}
+//#endregion
+//#region src/document/zod-schema.ts
+const partKindSchema = z.enum([
+	"video_clip",
+	"speech",
+	"caption",
+	"bgm"
+]);
+const finiteNumber = z.number().finite();
+const trackItemTimePositionSchema = z.discriminatedUnion("mode", [
+	z.object({ mode: z.literal("sequential") }).passthrough(),
+	z.object({
+		mode: z.literal("anchored"),
+		anchorPartId: z.string(),
+		offsetMs: finiteNumber
+	}).passthrough(),
+	z.object({
+		mode: z.literal("absolute"),
+		offsetMs: finiteNumber
+	}).passthrough()
+]);
+const trackItemSchema = z.object({
+	part_id: z.string(),
+	time_position: trackItemTimePositionSchema,
+	fallback_abs_ms: finiteNumber.optional()
+}).passthrough();
+const trackSchema = z.object({
+	id: z.string().optional(),
+	parts_kind: partKindSchema.optional(),
+	is_hidden: z.boolean().optional(),
+	items: z.array(trackItemSchema).optional()
+}).passthrough();
+const speedShiftSchema$1 = z.object({
+	category: z.string().optional(),
+	mode: z.string().optional(),
+	config: z.object({ linear: z.object({ speed: finiteNumber.optional() }).passthrough().optional() }).passthrough().optional()
+}).passthrough();
+const videoClipPartSchema = z.object({
+	id: z.string().optional(),
+	kind: z.literal("video_clip"),
+	duration_ms: finiteNumber.optional(),
+	play_in: finiteNumber,
+	play_out: finiteNumber,
+	volume: finiteNumber,
+	origin_media_id: z.string(),
+	speed_shift: speedShiftSchema$1.optional()
+}).passthrough();
+const speechPartSchema = z.object({
+	id: z.string().optional(),
+	kind: z.literal("speech"),
+	media_duration_ms: finiteNumber,
+	duration_ms: finiteNumber.optional(),
+	audio_script: z.string(),
+	volume: finiteNumber,
+	audio_storage_key: z.string(),
+	origin_speech_id: z.string(),
+	voice: z.unknown(),
+	caption_ids: z.array(z.string())
+}).passthrough();
+const captionPartSchema = z.object({
+	id: z.string().optional(),
+	kind: z.literal("caption"),
+	initial_duration_ms: finiteNumber,
+	speech_part_id: z.string(),
+	text: z.string(),
+	start_ms: finiteNumber,
+	style: z.object({
+		font_id: z.string().optional(),
+		font_size: finiteNumber.optional(),
+		font_color: z.string().optional(),
+		font_weight: finiteNumber.optional(),
+		entrance_animation: z.string().optional(),
+		entrance_animation_duration_ms: finiteNumber.optional(),
+		stroke_color: z.string().optional(),
+		stroke_width: finiteNumber.optional(),
+		position_x: finiteNumber.optional(),
+		position_y: finiteNumber.optional()
+	}).passthrough().optional()
+}).passthrough();
+const bgmPartSchema = z.object({
+	id: z.string().optional(),
+	kind: z.literal("bgm"),
+	audio_storage_key: z.string(),
+	volume: finiteNumber,
+	origin_media_id: z.string()
+}).passthrough();
+const partUnionSchema = z.union([
+	z.object({ video_clip: videoClipPartSchema }).passthrough(),
+	z.object({ speech: speechPartSchema }).passthrough(),
+	z.object({ caption: captionPartSchema }).passthrough(),
+	z.object({ bgm: bgmPartSchema }).passthrough()
+]).refine((part) => {
+	const p = part;
+	return [
+		"video_clip",
+		"speech",
+		"caption",
+		"bgm"
+	].filter((k) => p[k] != null).length === 1;
+}, { message: "A part_library value must have exactly one of video_clip / speech / caption / bgm" });
+const videoDocumentMetaSchema = z.object({
+	schema_version: z.literal(VIDEO_DOCUMENT_SCHEMA_VERSION),
+	draft_id: z.string().optional(),
+	project_id: z.string().optional(),
+	owner_id: z.string().optional(),
+	thumbnail_storage_key: z.string().optional(),
+	chat_session_id: z.string().optional(),
+	video_creation_settings: z.unknown().optional(),
+	version: finiteNumber.optional()
+}).passthrough();
+const videoDocumentSchema = z.object({
+	meta: videoDocumentMetaSchema,
+	timeline: z.object({ unit_time_ms: finiteNumber.optional() }).passthrough().optional(),
+	tracks: z.array(trackSchema).optional(),
+	part_library: z.record(z.string(), partUnionSchema).optional()
+}).passthrough().refine((doc) => (doc.tracks ?? []).filter((t) => t.parts_kind === "video_clip").length <= 1, {
+	message: "A VideoDocument may have at most one video_clip (main) track",
+	path: ["tracks"]
+});
+//#endregion
+//#region src/document/validation.ts
+/**
+* Business-level schema guard for `VideoDocument` (RFC 03 §9). It is the gate
+* that decides whether an arbitrary value is a *legal* `VideoDocument` before it
+* is written into Loro — distinct from two neighbours:
+*
+* - `zod-schema.ts` (`videoDocumentSchema`) checks structure/shape only; this
+*   file layers the business rules on top (part-kind match, reference integrity,
+*   `position.anchorPartId` targets, value ranges, identity uniqueness).
+* - loro-mirror's own `validateSchema` (run on every `setState`) only checks the
+*   storage structure, never these business invariants.
+*
+* Projection (`projection.ts`) calls `assertValidVideoDocument` before solving a
+* document into the legacy `VideoDraft`.
+*/
+var VideoDocumentValidationError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(`Invalid VideoDocument: ${issues.map((issue) => issue.message).join("; ")}`);
+		this.issues = issues;
+		this.name = "VideoDocumentValidationError";
+	}
+};
+/**
+* Assert the document is legal enough to project. Only `error`-severity issues
+* hard-reject; `recoverable` ones (dangling anchor / orphan, RFC 02 §11.1) are
+* left for the projection to heal on read and do NOT throw. Use
+* `validateVideoDocument` directly to inspect recoverable issues too.
+*/
+function assertValidVideoDocument(document) {
+	const blocking = validateVideoDocument(document).filter((issue) => (issue.severity ?? "error") === "error");
+	if (blocking.length > 0) throw new VideoDocumentValidationError(blocking);
+}
+function validateVideoDocument(document) {
+	const parsed = videoDocumentSchema.safeParse(document);
+	if (!parsed.success) return parsed.error.issues.map((issue) => ({
+		code: "invalid_schema",
+		path: zodPath(issue.path),
+		message: issue.message
+	}));
+	const doc = parsed.data;
+	const issues = [];
+	const partLibrary = doc.part_library ?? {};
+	for (const [partId, part] of Object.entries(partLibrary)) {
+		if (!partUnionSchema.safeParse(part).success) {
+			issues.push({
+				code: "unknown_part_kind",
+				path: `/part_library/${partId}`,
+				message: `Part "${partId}" is not a supported part union`
+			});
+			continue;
+		}
+		const wrapperKind = getPartUnionKind(part);
+		const innerKind = getPartKind(part);
+		if (wrapperKind != null && innerKind != null && wrapperKind !== innerKind) issues.push({
+			code: "part_kind_mismatch",
+			path: `/part_library/${partId}`,
+			message: `Part "${partId}" wrapper kind "${wrapperKind}" does not match inner kind "${innerKind}"`
+		});
+		validatePartValues(partId, part, issues);
+	}
+	for (const [idx, track] of (doc.tracks ?? []).entries()) validateTrack(track, `tracks/${idx}`, partLibrary, issues, track.parts_kind === "video_clip");
+	validateSpeechCaptionReferences(partLibrary, issues);
+	validatePositionReferences(doc, partLibrary, issues);
+	return issues;
+}
+/**
+* An `anchored` item whose `anchorPartId` no longer exists in the library is the
+* orphan condition (RFC 02 §4/§11.1) — e.g. a speech whose host video, or a
+* caption whose host speech, was concurrently deleted while this item was being
+* reparented in. This is flagged as a **recoverable** issue, NOT a hard error:
+* the projection heals it on read (the item's `fallback_abs_ms` snapshot seeds
+* its absolute position, then the cascade reassigns it to the nearest available
+* host, or it stays put as an absolute item). Reporting it here keeps the orphan
+* observable without blocking projection — the opposite of a hard reject, which
+* would make an inevitable concurrent-delete outcome un-projectable (§11.1).
+*/
+function validatePositionReferences(doc, partLibrary, issues) {
+	const tracks = (doc.tracks ?? []).map((track, idx) => ({
+		track,
+		path: `tracks/${idx}`
+	}));
+	for (const { track, path } of tracks) for (const [idx, item] of (track?.items ?? []).entries()) {
+		if (item.time_position.mode !== "anchored") continue;
+		if (partLibrary[item.time_position.anchorPartId] == null) issues.push({
+			code: "invalid_position_anchor",
+			path: `/${path}/items/${idx}/time_position/anchorPartId`,
+			message: `Track item "${path}/${idx}" anchors to missing part "${item.time_position.anchorPartId}"`,
+			severity: "recoverable"
+		});
+	}
+}
+function validatePartValues(partId, part, issues) {
+	const payload = part.video_clip ?? part.speech ?? part.caption ?? part.bgm ?? void 0;
+	if (payload == null) return;
+	if ("duration_ms" in payload && payload.duration_ms != null && payload.duration_ms < 0) issues.push({
+		code: "invalid_part_value",
+		path: `/part_library/${partId}/duration_ms`,
+		message: `Part "${partId}" has negative duration_ms`
+	});
+	if ("volume" in payload && payload.volume != null && !Number.isFinite(payload.volume)) issues.push({
+		code: "invalid_part_value",
+		path: `/part_library/${partId}/volume`,
+		message: `Part "${partId}" has non-finite volume`
+	});
+	if (part.video_clip != null) {
+		const { play_in, play_out } = part.video_clip;
+		if (play_in != null && play_in < 0) issues.push({
+			code: "invalid_part_value",
+			path: `/part_library/${partId}/play_in`,
+			message: `Video clip "${partId}" has negative play_in`
+		});
+		if (play_out != null && play_in != null && play_out < play_in) issues.push({
+			code: "invalid_part_value",
+			path: `/part_library/${partId}/play_out`,
+			message: `Video clip "${partId}" has play_out before play_in`
+		});
+	}
+}
+function validateTrack(track, path, partLibrary, issues, isMainTrack) {
+	if (track == null) return;
+	const seenPartIds = /* @__PURE__ */ new Set();
+	for (const [idx, item] of (track.items ?? []).entries()) {
+		const partId = item.part_id;
+		if (partId != null && partId !== "") if (seenPartIds.has(partId)) issues.push({
+			code: "duplicate_track_item_identity",
+			path: `/${path}/items/${idx}/part_id`,
+			message: `Track item "${path}/${idx}" reuses part_id "${partId}"`
+		});
+		else seenPartIds.add(partId);
+		if (partId == null || partId === "") {
+			issues.push({
+				code: "missing_part_reference",
+				path: `/${path}/items/${idx}/part_id`,
+				message: `Track item "${path}/${idx}" has no part_id`
+			});
+			continue;
+		}
+		const part = partLibrary[partId];
+		if (part == null) {
+			issues.push({
+				code: "missing_part_reference",
+				path: `/${path}/items/${idx}/part_id`,
+				message: `Track item "${path}/${idx}" references missing part "${partId}"`
+			});
+			continue;
+		}
+		const partKind = getPartKind(part);
+		if (isMainTrack && partKind !== "video_clip") issues.push({
+			code: "main_track_non_video_clip",
+			path: `/${path}/items/${idx}/part_id`,
+			message: `Main track item "${path}/${idx}" references non-video part "${partId}"`
+		});
+		if (track.parts_kind != null && partKind != null && track.parts_kind !== partKind) issues.push({
+			code: "track_kind_mismatch",
+			path: `/${path}/items/${idx}/part_id`,
+			message: `Track "${path}" expects "${track.parts_kind}" but part "${partId}" is "${partKind}"`
+		});
+	}
+}
+/**
+* Check speech↔caption references. A reference to a *missing* part (speech's
+* caption_ids → deleted caption, or caption's speech_part_id → deleted speech)
+* is the orphan condition (RFC 02 §11.1): reported as **recoverable** so the
+* projection can heal it on read, not block. A *back-pointer mismatch* (caption
+* exists but does not point back) is data corruption, kept as a hard error.
+*/
+function validateSpeechCaptionReferences(partLibrary, issues) {
+	for (const [partId, part] of Object.entries(partLibrary)) {
+		if (part.speech != null) for (const captionId of part.speech.caption_ids ?? []) {
+			const caption = partLibrary[captionId]?.caption;
+			if (caption == null) {
+				issues.push({
+					code: "invalid_speech_caption_reference",
+					path: `/part_library/${partId}/speech/caption_ids`,
+					message: `Speech "${partId}" references missing caption "${captionId}"`,
+					severity: "recoverable"
+				});
+				continue;
+			}
+			if (caption.speech_part_id !== partId) issues.push({
+				code: "invalid_speech_caption_reference",
+				path: `/part_library/${captionId}/caption/speech_part_id`,
+				message: `Caption "${captionId}" does not point back to speech "${partId}"`
+			});
+		}
+		if (part.caption != null) {
+			const speechId = part.caption.speech_part_id;
+			if (speechId != null && partLibrary[speechId]?.speech == null) issues.push({
+				code: "invalid_speech_caption_reference",
+				path: `/part_library/${partId}/caption/speech_part_id`,
+				message: `Caption "${partId}" references missing speech "${speechId}"`,
+				severity: "recoverable"
+			});
+		}
+	}
+}
+function getPartUnionKind(part) {
+	if (part.video_clip != null) return "video_clip";
+	if (part.speech != null) return "speech";
+	if (part.caption != null) return "caption";
+	if (part.bgm != null) return "bgm";
+}
+function getPartKind(part) {
+	return part.video_clip?.kind ?? part.speech?.kind ?? part.caption?.kind ?? part.bgm?.kind;
+}
+function zodPath(path) {
+	if (path.length === 0) return "/";
+	return `/${path.map(String).join("/")}`;
+}
+//#endregion
+//#region src/document/projection.ts
+/**
+* Projection between the authoritative `VideoDocument` and the legacy
+* `VideoDraft` read-view (RFC 02 §5/§7). Both directions live here:
+*
+* - `toVideoDocument` ingests a `VideoDraft`, deriving each item's `position`
+*   from the legacy absolute layout + aggregations; derived values (abs time,
+*   `part_aggregations`, total duration) are dropped.
+* - `fromVideoDocument` solves a `VideoDocument` back into a `VideoDraft` via the
+*   timeline-core cascade, re-deriving exactly those values.
+*
+* Business validation lives in `validation.ts`; `fromVideoDocument` asserts a
+* valid document before solving.
+*/
+/**
+* Ingest the legacy `VideoDraft` into the authoritative `VideoDocument`,
+* deriving each item's `time_position` from the legacy absolute layout +
+* aggregations (RFC 02 §4/§5). Absolute time, `part_aggregations`, and total
+* duration are dropped — they are re-derived by the projection.
+*/
+function toVideoDocument(draft) {
+	const speechHost = buildSpeechHostMap(draft.part_aggregations);
+	const partLibrary = draft.part_library ?? {};
+	const toTrack = (track, isMain) => {
+		if (track == null) return void 0;
+		return {
+			id: track.id,
+			parts_kind: track.parts_kind,
+			is_hidden: track.is_hidden,
+			items: (track.items ?? []).map((item) => deriveItem(item, isMain, speechHost, partLibrary))
+		};
+	};
+	const mainTrack = toTrack(draft.main_track, true);
+	const tracks = [
+		...(draft.above_main_tracks ?? []).map((t) => toTrack(t, false)),
+		...mainTrack == null ? [] : [mainTrack],
+		...(draft.below_main_tracks ?? []).map((t) => toTrack(t, false))
+	];
+	return {
+		meta: {
+			schema_version: VIDEO_DOCUMENT_SCHEMA_VERSION,
+			draft_id: draft.id,
+			project_id: draft.project_id,
+			owner_id: draft.owner_id,
+			thumbnail_storage_key: draft.thumbnail_storage_key,
+			chat_session_id: draft.chat_session_id,
+			video_creation_settings: clone(draft.video_creation_settings),
+			version: draft.version
+		},
+		timeline: draft.timeline == null ? void 0 : { unit_time_ms: draft.timeline.unit_time_ms },
+		tracks,
+		part_library: toAuthoritativePartLibrary(draft.part_library)
+	};
+}
+/**
+* Map the legacy `VideoDraft` part library into the authoritative shape
+* (reference/17 §5): the authoritative parts store no derived part-level
+* duration, so the read-view `duration_ms` is dropped from video / speech / bgm.
+* For a caption the legacy `duration_ms` is the generation-time length, stored
+* authoritatively as `initial_duration_ms`.
+*/
+function toAuthoritativePartLibrary(partLibrary) {
+	if (partLibrary == null) return void 0;
+	const out = {};
+	for (const [partId, part] of Object.entries(partLibrary)) {
+		if (typeof part !== "object" || part == null) continue;
+		if (part.video_clip != null) out[partId] = { video_clip: withTrimWindowFromDuration(part.video_clip) };
+		else if (part.speech != null) {
+			const { duration_ms, rest } = splitDurationMs(part.speech);
+			out[partId] = { speech: {
+				...rest,
+				media_duration_ms: rest.media_duration_ms ?? duration_ms
+			} };
+		} else if (part.caption != null) {
+			const { duration_ms, rest } = splitDurationMs(part.caption);
+			out[partId] = { caption: {
+				...rest,
+				initial_duration_ms: duration_ms
+			} };
+		} else if (part.bgm != null) out[partId] = { bgm: omitDurationMs(part.bgm) };
+	}
+	return out;
+}
+/**
+* Build a speech-host map from a part_aggregations list. Used by
+* `toVideoDocument` (legacy VideoDraft → VideoDocument) to recover each speech's
+* host video clip and relative offset. Aggregation items with null ids are
+* skipped (malformed input tolerance).
+*/
+function buildSpeechHostMap(aggregations) {
+	const map = /* @__PURE__ */ new Map();
+	for (const aggregation of aggregations ?? []) {
+		const host = aggregation.body_part_id;
+		if (host == null) continue;
+		for (const attachment of aggregation.attachments ?? []) {
+			if (attachment.part_id == null) continue;
+			map.set(attachment.part_id, {
+				hostPartId: host,
+				offsetMs: Math.round(attachment.relative_time_position ?? 0)
+			});
+		}
+	}
+	return map;
+}
+/**
+* Derive `time_position` (and `fallbackAbsMs` for anchored items) from a legacy
+* absolute time + pre-built speech-host map + part library. The three-branch
+* rule (RFC 02 §4/§5, reference/17 §3):
+*
+*   1. main-track → `sequential`
+*   2. speech/attachment (part_id in speechHost) → `anchored(host, offsetMs)`
+*   3. caption (part has `speech_part_id`) → `anchored(speech, start_ms)`
+*   4. everything else → `absolute(abs)`
+*
+* `partLibrary` values may be `PartUnion | string | undefined` (draft raw
+* form); only object-typed entries are inspected for `caption`.
+*/
+function derivePositionFromAbs(partId, abs, isMain, speechHost, partLibrary) {
+	if (isMain) return { timePosition: { mode: "sequential" } };
+	const host = speechHost.get(partId);
+	if (host != null) return {
+		timePosition: {
+			mode: "anchored",
+			anchorPartId: host.hostPartId,
+			offsetMs: host.offsetMs
+		},
+		fallbackAbsMs: abs
+	};
+	const part = partLibrary[partId];
+	const captionPart = typeof part === "object" && part != null ? part.caption : void 0;
+	const speechId = captionPart?.speech_part_id ?? void 0;
+	if (speechId != null) return {
+		timePosition: {
+			mode: "anchored",
+			anchorPartId: speechId,
+			offsetMs: Math.round(captionPart?.start_ms ?? 0)
+		},
+		fallbackAbsMs: abs
+	};
+	return { timePosition: {
+		mode: "absolute",
+		offsetMs: abs
+	} };
+}
+/** Derive one item's authoritative `time_position` from its legacy abs + aggregation. */
+function deriveItem(item, isMain, speechHost, partLibrary) {
+	const partId = item.part_id ?? "";
+	const { timePosition, fallbackAbsMs } = derivePositionFromAbs(partId, Math.round(item.abs_time_position ?? 0), isMain, speechHost, partLibrary);
+	return fallbackAbsMs == null ? {
+		part_id: partId,
+		time_position: timePosition
+	} : {
+		part_id: partId,
+		time_position: timePosition,
+		fallback_abs_ms: fallbackAbsMs
+	};
+}
+/**
+* Project the authoritative `VideoDocument` back into the legacy `VideoDraft`
+* read-view, solving each item's absolute position, the `part_aggregations`, and
+* the total duration via the timeline-core cascade.
+*/
+function fromVideoDocument(document) {
+	assertValidVideoDocument(document);
+	const view = solveVideoDocument(document);
+	const tracks = document.tracks ?? [];
+	const mainTrack = tracks.find((t) => t.parts_kind === "video_clip");
+	const aboveTracks = tracks.filter((t) => t.parts_kind === "caption");
+	const belowTracks = tracks.filter((t) => t.parts_kind === "speech" || t.parts_kind === "bgm");
+	return {
+		id: document.meta.draft_id,
+		project_id: document.meta.project_id,
+		owner_id: document.meta.owner_id,
+		thumbnail_storage_key: document.meta.thumbnail_storage_key,
+		timeline: {
+			duration_ms: view.durationMs,
+			unit_time_ms: document.timeline?.unit_time_ms
+		},
+		video_creation_settings: clone(document.meta.video_creation_settings),
+		chat_session_id: document.meta.chat_session_id,
+		main_track: draftTrack(mainTrack, view.absByPartId),
+		above_main_tracks: aboveTracks.map((t) => draftTrack(t, view.absByPartId)),
+		below_main_tracks: belowTracks.map((t) => draftTrack(t, view.absByPartId)),
+		part_aggregations: view.aggregations,
+		part_library: toReadViewPartLibrary(view.partLibrary, view.durationMs),
+		version: document.meta.version
+	};
+}
+/**
+* Map the authoritative part library into the `VideoDraft` read-view shape,
+* re-injecting the derived effective `duration_ms` downstream expects
+* (reference/17 §5/§7) — the authoritative parts store no part-level duration:
+*
+* - video clip → `(play_out - play_in) / speed` (`effectiveVideoClipDurationMs`)
+* - speech → its intrinsic `media_duration_ms` (no trim/speed)
+* - caption → its generation-time `initial_duration_ms`
+* - bgm → the timeline total (`durationMs`)
+*
+* Parts are deep-cloned; the engine extensions (`media_duration_ms`,
+* `initial_duration_ms`) are kept alongside the injected `duration_ms`.
+*/
+function toReadViewPartLibrary(partLibrary, durationMs) {
+	const out = {};
+	for (const [partId, part] of Object.entries(partLibrary)) if (part.video_clip != null) {
+		const clip = clone(part.video_clip);
+		out[partId] = { video_clip: {
+			...clip,
+			duration_ms: effectiveVideoClipDurationMs(clip)
+		} };
+	} else if (part.speech != null) {
+		const speech = clone(part.speech);
+		out[partId] = { speech: {
+			...speech,
+			duration_ms: speech.media_duration_ms
+		} };
+	} else if (part.caption != null) {
+		const caption = clone(part.caption);
+		out[partId] = { caption: {
+			...caption,
+			duration_ms: caption.initial_duration_ms
+		} };
+	} else if (part.bgm != null) out[partId] = { bgm: {
+		...clone(part.bgm),
+		duration_ms: durationMs
+	} };
+	return out;
+}
+/** Deep-clone a part payload, dropping the derived read-view `duration_ms`. */
+function omitDurationMs(part) {
+	const { duration_ms: _drop, ...rest } = clone(part);
+	return rest;
+}
+/**
+* Migrate a legacy video clip into the authoritative trim-window-only shape: the
+* authoritative part stores no `duration_ms`, so it is dropped — but a legacy
+* clip with no explicit trim window (`play_in` / `play_out` absent) would then
+* compute an effective length of 0 and vanish from the layout. When that clip
+* carried a legacy `duration_ms`, backfill it as the trim window (`play_in` 0,
+* `play_out = duration_ms`, no speed) so the effective length is preserved, then
+* drop `duration_ms`. A clip that already has a trim window keeps it verbatim.
+*/
+function withTrimWindowFromDuration(clip) {
+	const stripped = omitDurationMs(clip);
+	if (clip.play_in != null || clip.play_out != null) return stripped;
+	const legacyDuration = clip.duration_ms;
+	if (legacyDuration == null || !Number.isFinite(legacyDuration)) return stripped;
+	return {
+		...stripped,
+		play_in: 0,
+		play_out: legacyDuration
+	};
+}
+/** Deep-clone a part payload, returning its `duration_ms` separately from the rest. */
+function splitDurationMs(part) {
+	const { duration_ms, ...rest } = clone(part);
+	return {
+		duration_ms,
+		rest
+	};
+}
+function draftTrack(track, absByPartId) {
+	if (track == null) return void 0;
+	return {
+		id: track.id,
+		parts_kind: track.parts_kind,
+		is_hidden: track.is_hidden,
+		items: (track.items ?? []).map((item) => ({
+			part_id: item.part_id,
+			abs_time_position: absByPartId.get(item.part_id) ?? 0
+		}))
+	};
+}
+function clone(value) {
+	if (Array.isArray(value)) return value.map((item) => clone(item));
+	if (value != null && typeof value === "object") {
+		const result = {};
+		for (const [key, child] of Object.entries(value)) result[key] = clone(child);
+		return result;
+	}
+	return value;
+}
+//#endregion
+//#region src/document/mirror-read.ts
+/**
+* Project the mirror state (`VideoDocumentDraft`) into the authoritative
+* `VideoDocument`. The storage shape is isomorphic to the domain shape (RFC 03
+* §4, reference/17 §4: meta map + a single `tracks` list + part_library), so this
+* is a near-identity — it reads `time_position` / `fallback_abs_ms` JSON blobs
+* back into structured values and trims empty strings, nothing more.
+*
+* It maps only authoritative facts (RFC 02 §6): `part_id` + `time_position`. The
+* projection-derived `VideoDraft` read-view (absolute time, `part_aggregations`,
+* total duration) is solved separately by the cascade, not here.
+*
+* It reads in-memory mirror state (O(n) over the document), not a Loro
+* `toJSON()` FFI rebuild — the cost the prior schema adapter paid on every
+* `snapshot()`.
+*/
+function readVideoDocumentFromDraft(draft) {
+	const partLibrary = {};
+	for (const [partId, payload] of recordEntries(draft.part_library)) {
+		const part = draftToPartUnion(payload);
+		if (part != null) partLibrary[partId] = part;
+	}
+	const timeline = draft.timeline;
+	const hasTimeline = timeline?.unit_time_ms != null;
+	const meta = draft.meta;
+	return {
+		meta: {
+			schema_version: VIDEO_DOCUMENT_SCHEMA_VERSION,
+			draft_id: emptyToUndefined(meta?.draft_id),
+			project_id: emptyToUndefined(meta?.project_id),
+			owner_id: emptyToUndefined(meta?.owner_id),
+			thumbnail_storage_key: emptyToUndefined(meta?.thumbnail_storage_key),
+			chat_session_id: emptyToUndefined(meta?.chat_session_id),
+			video_creation_settings: meta?.video_creation_settings ?? void 0,
+			version: meta?.version ?? void 0
+		},
+		timeline: hasTimeline ? { unit_time_ms: timeline.unit_time_ms } : void 0,
+		tracks: rowsToTracks(draft.tracks),
+		part_library: partLibrary
+	};
+}
+/** Map a movable-list of track rows (`$cid`-bearing) into domain tracks, dropping empty-id placeholders. */
+function rowsToTracks(rows) {
+	return (rows ?? []).filter((row) => row.id != null && row.id !== "").map(rowToTrack);
+}
+function rowToTrack(row) {
+	return {
+		id: row.id,
+		parts_kind: row.parts_kind ?? void 0,
+		is_hidden: row.is_hidden ?? void 0,
+		items: (row.items ?? []).map((item) => {
+			const result = {
+				part_id: item.part_id ?? "",
+				time_position: item.time_position
+			};
+			if (item.fallback_abs_ms != null) result.fallback_abs_ms = item.fallback_abs_ms;
+			return result;
+		})
+	};
+}
+function emptyToUndefined(value) {
+	return value == null || value === "" ? void 0 : value;
+}
+//#endregion
+//#region src/document/mirror-adapter.ts
+/**
+* Storage-layer adapter that backs a `VideoDocument` with `loro-mirror` (ADR
+* 0008). The mirror holds an in-memory immutable state synced to the `LoroDoc`
+* by declarative diff, replacing the hand-rolled `@mengine/schema` adapter:
+*
+* - `snapshot()` projects the mirror's in-memory state to the read model — no
+*   per-call `toJSON()` FFI rebuild.
+* - `transact(edit, audit)` runs the whole op in one `mirror.setState` callback:
+*   one diff, one `doc.commit` carrying the audit message. The callback edits an
+*   immer draft, so a throw inside it discards the draft and never touches Loro
+*   (natural rollback) — no `guard` / `rollback` / `openTransaction` machinery.
+* - mirror's `idSelector` (track items keyed by `part_id`) diffs reorders to
+*   real Loro `move` ops on every lane, so per-item CRDT identity survives on
+*   main and secondary tracks alike.
+*/
+var MirrorVideoDocumentAdapter = class {
+	doc;
+	mirror;
+	constructor(doc) {
+		this.doc = doc;
+		this.mirror = new Mirror({
+			doc,
+			schema: videoDocumentMirrorSchema
+		});
+	}
+	snapshot() {
+		return readVideoDocumentFromDraft(this.mirror.getState());
+	}
+	/**
+	* True once the doc holds real document content. A fresh mirror over an empty
+	* doc still reports defaulted root maps, so probe the stored `schema_version`
+	* (empty until a snapshot is bootstrapped or synced in).
+	*/
+	hasContent() {
+		return (this.mirror.getState().meta?.schema_version ?? "") !== "";
+	}
+	/**
+	* Apply one op as a single transaction. `edit` mutates the immer draft; mirror
+	* diffs the result and commits once with the audit `message`. A throw in `edit`
+	* discards the draft (Loro untouched). When `edit` produces no change, mirror
+	* skips the commit — matching the prior "empty op leaves no audit" behavior.
+	*/
+	transact(edit, audit) {
+		this.mirror.setState((draft) => {
+			edit(draft);
+		}, {
+			origin: "mengine.semantic_editor",
+			message: JSON.stringify({
+				semantic_op: audit.kind,
+				payload: audit.payload,
+				intent: audit.intent ?? null
+			})
+		});
+	}
+};
+/** Build a fresh Loro doc seeded with `document` through the mirror. */
+function createMirrorVideoDocument(document, options = {}) {
+	assertValidVideoDocument(document);
+	const doc = new LoroDoc();
+	if (options.peerId != null) doc.setPeerId(options.peerId);
+	new Mirror({
+		doc,
+		schema: videoDocumentMirrorSchema
+	}).setState((draft) => {
+		seedDraft(draft, document);
+	}, { origin: options.origin ?? "mengine.bootstrap" });
+	return doc;
+}
+/** Build a `MirrorVideoDocumentAdapter` over a fresh doc seeded with `document`. */
+function createMirrorVideoDocumentAdapter(document, options) {
+	return new MirrorVideoDocumentAdapter(createMirrorVideoDocument(document, options));
+}
+/** Write a whole `VideoDocument` into the mirror draft (used to seed a fresh doc). */
+function seedDraft(draft, document) {
+	draft.meta = {
+		schema_version: document.meta.schema_version,
+		draft_id: document.meta.draft_id ?? void 0,
+		project_id: document.meta.project_id ?? void 0,
+		owner_id: document.meta.owner_id ?? void 0,
+		thumbnail_storage_key: document.meta.thumbnail_storage_key ?? void 0,
+		chat_session_id: document.meta.chat_session_id ?? void 0,
+		video_creation_settings: document.meta.video_creation_settings ?? void 0,
+		version: document.meta.version ?? void 0
+	};
+	draft.timeline = { unit_time_ms: document.timeline?.unit_time_ms ?? void 0 };
+	draft.tracks = (document.tracks ?? []).map(toTrackRow);
+	draft.part_library = {};
+	for (const [partId, part] of Object.entries(document.part_library ?? {})) draft.part_library[partId] = partUnionToDraft(part);
+}
+/** Map a domain `Track` to a draft track row (no lane/lane_order — see schema). */
+function toTrackRow(track) {
+	return {
+		id: track.id ?? "",
+		parts_kind: track.parts_kind ?? void 0,
+		is_hidden: track.is_hidden ?? void 0,
+		items: (track.items ?? []).map((item) => ({
+			part_id: item.part_id,
+			time_position: item.time_position,
+			fallback_abs_ms: item.fallback_abs_ms
+		}))
+	};
+}
+//#endregion
+//#region src/editor/id-gen.ts
+/**
+* Part-id generation, aligned with the online ecosystem.
+*
+* The authoritative online producers — agent-harness (`@harness/shared`
+* `genObjId`) and director.v2 (`common/obj_id.py` `gen_obj_id`) — both mint part
+* ids as `` `${prefix}_${ulid()}` ``, and real captured drafts use exactly that
+* shape (`clip_…` / `spe_…` / `cap_…` / `bgm_…`, each a 26-char ULID). The engine
+* previously emitted `vc_<base36 timestamp><6 random>`, a different prefix AND a
+* different encoding — the sole cross-repo id divergence. This module removes it
+* by emitting the same `<prefix>_<ULID>` bytes.
+*
+* The ULID is generated inline (Crockford Base32, 48-bit time + 80-bit random)
+* rather than pulling the `ulid` npm package: the randomness class matches the
+* old generator (both `Math.random`-based) and it keeps `@mengine/medeo-client`
+* dependency-free for a purely mechanical id string. Part ids only need to be
+* unique and lexicographically time-sortable, which this satisfies.
+*/
+/** Crockford Base32 alphabet (no I, L, O, U), per the ULID spec. */
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const TIME_LEN = 10;
+const RANDOM_LEN = 16;
+function encodeTime(now) {
+	let out = "";
+	let ms = now;
+	for (let i = TIME_LEN - 1; i >= 0; i--) {
+		const mod = ms % 32;
+		out = CROCKFORD[mod] + out;
+		ms = (ms - mod) / 32;
+	}
+	return out;
+}
+function encodeRandom() {
+	let out = "";
+	for (let i = 0; i < RANDOM_LEN; i++) out += CROCKFORD[Math.floor(Math.random() * 32)];
+	return out;
+}
+/** A 26-char Crockford Base32 ULID (10-char time + 16-char random). */
+function ulid() {
+	return encodeTime(Date.now()) + encodeRandom();
+}
+function generatePartId(prefix) {
+	return `${prefix}_${ulid()}`;
+}
+//#endregion
+//#region src/editor/schemas/shared.ts
+const clipIdSchema = z.string().min(1).describe("The clip part ID on the timeline");
+const clipIdsSchema = z.array(clipIdSchema).min(1).refine((ids) => new Set(ids).size === ids.length, { message: "Duplicate clip IDs are not allowed" }).describe("List of clip part IDs (no duplicates allowed)");
+const mediaIdSchema = z.string().min(1).describe("The media asset ID");
+const speechIdSchema = z.string().min(1).describe("The speech part ID on the timeline");
+const timelineMsSchema = z.number().int().min(0).describe("Time position in milliseconds on the timeline (>= 0)");
+const positiveMsSchema = z.number().int().positive().describe("Duration in milliseconds (> 0)");
+const volumeSchema = z.number().min(-60).max(20).describe("Volume in decibels (-60.0 to 20.0; 0.0 = original, -60 = mute, +20 = max)");
+const speechIdsSchema = z.array(speechIdSchema).min(1).refine((ids) => new Set(ids).size === ids.length, { message: "Duplicate speech IDs are not allowed" }).describe("List of speech part IDs (no duplicates allowed)");
+const tangentHandleSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite()
+}).describe("Bezier tangent handle (x, y)");
+const speedKeyframeSchema = z.object({
+	position: z.number().min(0).max(1),
+	rate: z.number().min(0),
+	in_tangent: tangentHandleSchema.optional(),
+	out_tangent: tangentHandleSchema.optional()
+}).describe("A speed keyframe: normalized position (0..1), rate, optional tangents");
+/**
+* A clip's playback-speed fact, the only thing `SetVideoClipSpeedShift` writes.
+* Mirrors the IDL `SpeedShift`: `category` is `linear` | `curve`, and `config`
+* is a discriminated union — `{ linear: { speed } }` for a constant multiplier
+* (the multiplier projection reads at `config.linear.speed`) or `{ curve: {
+* keyframes } }` for a Bezier-controlled variable speed (RFC 02 / `reference/16`
+* §0). Exactly one of `linear` / `curve` is present.
+*/
+const speedShiftSchema = z.object({
+	category: z.enum(["linear", "curve"]),
+	mode: z.string(),
+	config: z.union([z.object({ linear: z.object({ speed: z.number().finite().positive() }) }), z.object({ curve: z.object({ keyframes: z.array(speedKeyframeSchema).min(2) }) })])
+}).describe("Speed shift: linear multiplier or Bezier curve, mirroring the IDL shape");
+const voiceSchema = z.object({
+	id: z.string().min(1),
+	name: z.string()
+}).describe("TTS voice summary attached to a speech");
+//#endregion
+//#region src/editor/schemas/speech-assets.ts
+/**
+* The materialized TTS result shared by `AddSpeeches` / `ChangeSpeechScript` /
+* `ChangeSpeechVoice` (see `results/phase-4-side-effect-payload-contract.md`
+* §1/§2). The side effect (TTS/ASR + billing) runs upstream; the op receives the
+* stable speech + caption parts and writes them as authoritative facts. No
+* cascade runs on write — the projection derives absolute positions on read.
+*
+* Each speech carries the anchoring fact directly (RFC 02 §4): the host video
+* clip `anchor_part_id` and the `offset_ms` within it. The upstream caller
+* already knows which clip a speech attaches to, so the op writes
+* `{ mode:'anchored', anchorPartId, offsetMs }` verbatim — no write-time
+* host-picking. Captions anchor to their speech via the caption part's
+* `start_ms` (offset within the speech).
+*/
+const speechAssetSchema = z.object({
+	speech_id: speechIdSchema.describe("The speech part ID (= side-effect speech_parts[].id)"),
+	anchor_part_id: clipIdSchema.describe("Host video clip part ID the speech anchors to (RFC 02 §4)"),
+	offset_ms: timelineMsSchema.describe("Offset within the host clip (speech.abs = host.abs + offset_ms)"),
+	audio_storage_key: z.string().min(1),
+	duration_ms: positiveMsSchema,
+	audio_script: z.string(),
+	volume: volumeSchema,
+	voice: voiceSchema,
+	origin_speech_id: z.string().min(1),
+	caption_ids: z.array(z.string().min(1)).describe("Caption part IDs owned by this speech")
+});
+const captionAssetSchema = z.object({
+	caption_id: z.string().min(1).describe("The caption part ID (= side-effect created_caption_parts[].id)"),
+	speech_part_id: speechIdSchema.describe("The owning speech part ID"),
+	text: z.string(),
+	start_ms: timelineMsSchema.describe("Offset within the host speech (caption.abs = speech.abs + start_ms)"),
+	duration_ms: positiveMsSchema
+});
+/** A materialized speech-subtree write (speeches + their captions). */
+const speechAssetsSchema = z.object({
+	speeches: z.array(speechAssetSchema).min(1).describe("Materialized speech parts to write"),
+	captions: z.array(captionAssetSchema).describe("Materialized caption parts owned by the speeches")
+});
+//#endregion
+//#region src/editor/schemas/add-speeches.ts
+/**
+* Add speeches (and their captions). TTS runs upstream; the stable speech /
+* caption parts arrive materialized (see `speech-assets.ts`). The op writes the
+* parts and each speech's `{ mode:'anchored', anchorPartId, offsetMs }` fact
+* verbatim — no write-time host-picking, no cascade (RFC 02 §4). The projection
+* derives absolute positions on read.
+*/
+const addSpeechesInputSchema = speechAssetsSchema.describe("Materialized speeches + captions to add");
+//#endregion
+//#region src/editor/schemas/add-video-clips.ts
+/**
+* Add video clips to a track. Each clip's duration facts are separated so a
+* single number is never overloaded (RFC 02 / `reference/16` §0b):
+*
+* - `media_duration_ms` is the source media's intrinsic full length (a resource
+*   fact, written to the part);
+* - `play_in` / `play_out` are the optional trim window into that media; when
+*   omitted the whole media is used (`play_in=0`, `play_out=media_duration_ms`).
+*
+* The clip's effective timeline duration is derived by the projection from the
+* trim window and `speed_shift` — it is never an input here.
+*/
+const addVideoClipsInputSchema = z.object({
+	clips: z.array(z.object({
+		media_id: mediaIdSchema.describe("The media asset ID for the video clip"),
+		start_ms: timelineMsSchema.optional().describe("Absolute start time in milliseconds on the timeline"),
+		media_duration_ms: positiveMsSchema.describe("The source media's intrinsic full length in ms"),
+		play_in: timelineMsSchema.optional().describe("Trim window start in the media (default 0)"),
+		play_out: positiveMsSchema.optional().describe("Trim window end in the media (default media_duration_ms)"),
+		track_id: z.string().min(1).optional().describe("Target track ID (optional, defaults to main track)")
+	})).min(1).describe("List of video clips to create"),
+	before_clip_id: z.string().min(1).optional().describe("Insert new clips before this clip ID"),
+	after_clip_id: z.string().min(1).optional().describe("Insert new clips after this clip ID")
+}).superRefine((data, ctx) => {
+	if (data.before_clip_id != null && data.after_clip_id != null) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "Cannot provide both before_clip_id and after_clip_id"
+		});
+		return;
+	}
+	const hasRelative = data.before_clip_id != null || data.after_clip_id != null;
+	for (let i = 0; i < data.clips.length; i++) {
+		const clip = data.clips[i];
+		if (hasRelative && clip.start_ms != null) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `clips[${i}].start_ms must not be provided when using before_clip_id or after_clip_id`,
+			path: [
+				"clips",
+				i,
+				"start_ms"
+			]
+		});
+		if (!hasRelative && clip.start_ms == null) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `clips[${i}].start_ms is required when not using relative positioning`,
+			path: [
+				"clips",
+				i,
+				"start_ms"
+			]
+		});
+		const playIn = clip.play_in ?? 0;
+		const playOut = clip.play_out ?? clip.media_duration_ms;
+		if (playOut > clip.media_duration_ms) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `clips[${i}].play_out ${playOut}ms exceeds media_duration_ms ${clip.media_duration_ms}ms`,
+			path: [
+				"clips",
+				i,
+				"play_out"
+			]
+		});
+		if (playIn >= playOut) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `clips[${i}].play_in ${playIn}ms must be less than play_out ${playOut}ms`,
+			path: [
+				"clips",
+				i,
+				"play_in"
+			]
+		});
+	}
+});
+//#endregion
+//#region src/editor/schemas/adjust-bgm-volume.ts
+const adjustBgmVolumeInputSchema = z.object({ bgm: z.array(z.object({
+	bgm_id: clipIdSchema.describe("The bgm part ID to adjust volume for"),
+	volume: volumeSchema.describe("Volume in decibels (-60.0 to 20.0; 0.0 = original)")
+})).min(1).describe("List of bgm parts with their new volume settings") });
+//#endregion
+//#region src/editor/schemas/adjust-speech-volume.ts
+const adjustSpeechVolumeInputSchema = z.object({ speeches: z.array(z.object({
+	speech_id: speechIdSchema.describe("The speech part ID to adjust volume for"),
+	volume: volumeSchema.describe("Volume in decibels (-60.0 to 20.0; 0.0 = original)")
+})).min(1).describe("List of speeches with their new volume settings") });
+//#endregion
+//#region src/editor/schemas/adjust-video-clip-duration.ts
+/**
+* Re-trim existing video clips (the user-facing "adjust duration" gesture is a
+* trim of the source window). The new `play_in` / `play_out` are the facts; the
+* effective timeline duration is derived from them and the clip's `speed_shift`,
+* and the change reflows downstream clips, speeches, and the timeline inside the
+* op's transaction (no caller-materialized cascade).
+*/
+const adjustVideoClipDurationInputSchema = z.object({ clips: z.array(z.object({
+	clip_id: clipIdSchema.describe("The video clip part ID to re-trim"),
+	play_in: timelineMsSchema.describe("New trim window start in the source media"),
+	play_out: positiveMsSchema.describe("New trim window end in the source media")
+})).min(1).describe("Video clips with their new trim windows") });
+//#endregion
+//#region src/editor/schemas/adjust-video-clip-volume.ts
+const adjustVideoClipVolumeInputSchema = z.object({ clips: z.array(z.object({
+	clip_id: clipIdSchema.describe("The video clip part ID to adjust volume for"),
+	volume: volumeSchema.describe("Volume in decibels (-60.0 to 20.0; 0.0 = original)")
+})).min(1).describe("List of video clips with their new volume settings") });
+//#endregion
+//#region src/editor/schemas/change-speech.ts
+/**
+* Change a speech's script or voice. Both re-run TTS upstream and return the
+* regenerated speech / caption parts in the same materialized shape as
+* `AddSpeeches` (`speech-assets.ts`); the op upserts them by id (the speech part
+* id is preserved across a re-TTS), re-seats at `start_ms`, and reflows. Old
+* caption parts no longer owned by the speech are removed via `caption_ids`.
+*/
+const changeSpeechScriptInputSchema = speechAssetsSchema.describe("Regenerated speeches + captions (new script)");
+const changeSpeechVoiceInputSchema = speechAssetsSchema.describe("Regenerated speeches + captions (new voice)");
+//#endregion
+//#region src/editor/schemas/delete-bgm.ts
+/**
+* Remove the document BGM. Pure document edit: clears the bgm lane and removes
+* the bgm part. Takes no input (a document holds at most one bgm); an empty
+* object keeps the op signature uniform with the rest.
+*/
+const deleteBgmInputSchema = z.object({}).describe("Remove the document BGM (no parameters)");
+//#endregion
+//#region src/editor/schemas/delete-speeches.ts
+/**
+* Delete speeches with their captions. Pure document edit (no side effect): the
+* op removes each speech part, cascade-deletes the captions it owns (via
+* `caption_ids` / `speech_part_id`), drops their track items, and reflows.
+*/
+const deleteSpeechesInputSchema = z.object({ speech_ids: speechIdsSchema.describe("Speech part IDs to delete (their captions cascade-delete)") });
+//#endregion
+//#region src/editor/schemas/delete-video-clips.ts
+/**
+* How a delete handles the anchored subtree (speeches anchored to a deleted clip,
+* and their captions) — a delete-op policy, not a data-model field (reference/17
+* §6). `cascade` (default) removes the subtree; `detach` keeps the direct
+* anchored children, re-pinning them to `absolute` so they stay on the timeline.
+*/
+const anchoredDeletePolicySchema = z.enum(["cascade", "detach"]);
+const deleteVideoClipsInputSchema = z.object({
+	clip_ids: clipIdsSchema.describe("List of video clip part IDs to delete from the main track"),
+	on_anchored: anchoredDeletePolicySchema.optional().describe("How to treat anchored children (default cascade)")
+});
+//#endregion
+//#region src/editor/schemas/move-speeches.ts
+/**
+* Move speeches in time. Pure document edit: the op re-seats each speech at its
+* new absolute `start_ms`; the cascade reassigns it to the host video clip,
+* resolves overlaps, and reflows. Captions follow their speech.
+*/
+const moveSpeechesInputSchema = z.object({ speeches: z.array(z.object({
+	speech_id: speechIdSchema.describe("The speech part ID to move"),
+	new_start_ms: timelineMsSchema.describe("New absolute start time on the timeline")
+})).min(1).describe("Speeches to move to new positions") });
+//#endregion
+//#region src/editor/schemas/move-video-clips.ts
+const moveVideoClipsInputSchema = z.object({ clips: z.array(z.object({
+	clip_id: clipIdSchema.describe("The video clip part ID to move"),
+	new_start_ms: timelineMsSchema.describe("New absolute start time in milliseconds on the timeline"),
+	new_track_id: z.string().min(1).optional().describe("Target track ID to move the clip to (optional)")
+})).min(1).describe("List of video clips to move to new positions") });
+//#endregion
+//#region src/editor/schemas/replace-video-clip-content.ts
+/**
+* Replace the media backing existing video clips. The media import runs upstream
+* (Director); its stable result — the new media id, intrinsic length, and the
+* reset trim window — arrives materialized (see
+* `results/phase-4-side-effect-payload-contract.md` §4). Director resets
+* `play_in=0` / `play_out=media_duration_ms` and clears `speed_shift` on
+* replacement. The clip `part_id`s (hence their track items) are unchanged; the
+* editor reflows the main track from the new effective durations.
+*/
+const replaceVideoClipContentInputSchema = z.object({ clips: z.array(z.object({
+	clip_id: clipIdSchema.describe("Existing video clip part ID to re-point"),
+	origin_media_id: mediaIdSchema.describe("The new media asset ID"),
+	media_duration_ms: positiveMsSchema.describe("The new media's intrinsic full length"),
+	play_in: timelineMsSchema.describe("Trim window start in the new media (usually 0)"),
+	play_out: positiveMsSchema.describe("Trim window end in the new media (usually = media_duration_ms)"),
+	volume: volumeSchema
+})).min(1).describe("Video clips whose media is being replaced") });
+//#endregion
+//#region src/editor/schemas/set-bgm.ts
+/**
+* Set the document BGM. The media's stable result (storage key) arrives
+* materialized from upstream (see
+* `results/phase-4-side-effect-payload-contract.md` §3). The op upserts the bgm
+* part and seats it on the bgm lane; its effective length is always the whole
+* timeline, derived by the projection on read — so there is no `duration_ms`
+* input or fact (RFC 02 / `reference/16` §0b). A `bgm_id` lets the op replace an
+* existing bgm part by id.
+*/
+const setBgmInputSchema = z.object({
+	bgm_id: z.string().min(1).describe("The bgm part ID to write"),
+	audio_storage_key: z.string().min(1),
+	origin_media_id: mediaIdSchema,
+	volume: volumeSchema
+});
+//#endregion
+//#region src/editor/schemas/set-caption-style.ts
+/**
+* Set the caption visual style. GLOBAL by design: the style applies to every
+* caption part in the document — it carries NO `caption_id`. This mirrors the FE,
+* whose caption-style store (`caption-style.ts:persistCaptionStylePatch`) iterates
+* ALL captions and writes the same normalized style to each; the product has a
+* single document-wide caption style, not per-caption styling.
+*
+* Every field is optional and maps to a `CaptionStyle` attribute (snake_case
+* IDL). A field present in the input is written to every caption; a field ABSENT
+* from the input is left untouched on each caption (the editor merges the patch
+* onto each caption's existing style — this is a value edit, not a full-style
+* replace, so a partial patch such as "recolor only" does not wipe font size).
+*
+* Pure document edit, no cascade — captions keep their positions; only the style
+* sub-map of each caption part changes.
+*/
+const setCaptionStyleInputSchema = z.object({
+	font_id: z.string().min(1).optional().describe("Font ID referencing a font from the font library"),
+	font_size: z.number().positive().optional().describe("Font size in points"),
+	font_color: z.string().min(1).optional().describe("Font color as hex string, e.g. \"#FFFFFF\""),
+	font_weight: z.number().int().optional().describe("Numeric font weight, e.g. 400 or 700"),
+	entrance_animation: z.string().optional().describe("Entrance animation preset ID, e.g. \"fade\" or \"none\""),
+	entrance_animation_duration_ms: z.number().min(0).optional().describe("Entrance animation duration in ms"),
+	stroke_color: z.string().min(1).optional().describe("Outline/stroke color as hex string, e.g. \"#000000\""),
+	stroke_width: z.number().min(0).optional().describe("Outline/stroke width in pixels"),
+	position_x: z.number().optional().describe("Caption center X as a fraction (0.0 to 1.0)"),
+	position_y: z.number().optional().describe("Caption center Y as a fraction (0.0 to 1.0)")
+}).describe("Document-wide caption style patch (no caption_id; applies to every caption)");
+//#endregion
+//#region src/editor/schemas/set-caption-visibility.ts
+/**
+* Toggle caption visibility (the caption track's `is_hidden` flag). Pure
+* document edit, no cascade — captions keep their positions; only the lane's
+* hidden flag changes.
+*/
+const setCaptionVisibilityInputSchema = z.object({ is_hidden: z.boolean().describe("Whether the caption track is hidden") });
+//#endregion
+//#region src/editor/schemas/set-video-clip-speed-shift.ts
+/**
+* Set the playback speed of existing video clips. Per the speed-shift decision
+* (`reference/16` §0): the op writes only the `speed_shift` fact — it does NOT
+* store an effective `duration_ms` (projection derives it from the trim window /
+* speed) and does NOT scale anchored speeches' relative offsets (offsets stay
+* put; the cascade reflows absolute positions). A `null` speed_shift clears the
+* speed back to original (1×).
+*/
+const setVideoClipSpeedShiftInputSchema = z.object({ clips: z.array(z.object({
+	clip_id: clipIdSchema.describe("The video clip part ID to set speed for"),
+	speed_shift: speedShiftSchema.nullable().describe("The new speed setting, or null to reset to 1×")
+})).min(1).describe("Video clips with their new speed settings") });
+//#endregion
+//#region src/editor/schemas/index.ts
+var schemas_exports = /* @__PURE__ */ __exportAll({
+	addSpeechesInputSchema: () => addSpeechesInputSchema,
+	addVideoClipsInputSchema: () => addVideoClipsInputSchema,
+	adjustBgmVolumeInputSchema: () => adjustBgmVolumeInputSchema,
+	adjustSpeechVolumeInputSchema: () => adjustSpeechVolumeInputSchema,
+	adjustVideoClipDurationInputSchema: () => adjustVideoClipDurationInputSchema,
+	adjustVideoClipVolumeInputSchema: () => adjustVideoClipVolumeInputSchema,
+	anchoredDeletePolicySchema: () => anchoredDeletePolicySchema,
+	changeSpeechScriptInputSchema: () => changeSpeechScriptInputSchema,
+	changeSpeechVoiceInputSchema: () => changeSpeechVoiceInputSchema,
+	clipIdSchema: () => clipIdSchema,
+	clipIdsSchema: () => clipIdsSchema,
+	deleteBgmInputSchema: () => deleteBgmInputSchema,
+	deleteSpeechesInputSchema: () => deleteSpeechesInputSchema,
+	deleteVideoClipsInputSchema: () => deleteVideoClipsInputSchema,
+	mediaIdSchema: () => mediaIdSchema,
+	moveSpeechesInputSchema: () => moveSpeechesInputSchema,
+	moveVideoClipsInputSchema: () => moveVideoClipsInputSchema,
+	positiveMsSchema: () => positiveMsSchema,
+	replaceVideoClipContentInputSchema: () => replaceVideoClipContentInputSchema,
+	setBgmInputSchema: () => setBgmInputSchema,
+	setCaptionStyleInputSchema: () => setCaptionStyleInputSchema,
+	setCaptionVisibilityInputSchema: () => setCaptionVisibilityInputSchema,
+	setVideoClipSpeedShiftInputSchema: () => setVideoClipSpeedShiftInputSchema,
+	speechAssetsSchema: () => speechAssetsSchema,
+	speechIdSchema: () => speechIdSchema,
+	speechIdsSchema: () => speechIdsSchema,
+	speedShiftSchema: () => speedShiftSchema,
+	timelineMsSchema: () => timelineMsSchema,
+	voiceSchema: () => voiceSchema,
+	volumeSchema: () => volumeSchema
+});
+//#endregion
+//#region src/editor/snapshot-utils.ts
+function isMap(value) {
+	return value instanceof Map;
+}
+function snapshotToPlain(value) {
+	if (value instanceof Map) {
+		const obj = {};
+		for (const [k, v] of value) obj[String(k)] = snapshotToPlain(v);
+		return obj;
+	}
+	if (Array.isArray(value)) return value.map(snapshotToPlain);
+	return value;
+}
+function getAt(snapshot, ...keys) {
+	let cur = snapshot;
+	for (const k of keys) if (cur instanceof Map) cur = cur.get(k);
+	else if (cur != null && typeof cur === "object") cur = cur[k];
+	else return;
+	return cur;
+}
+function readMainTrackItems(snapshot) {
+	const tracks = getAt(snapshot, "tracks");
+	const items = getAt(Array.isArray(tracks) ? tracks.find((t) => getAt(t, "parts_kind") === "video_clip") : void 0, "items");
+	if (!Array.isArray(items)) return [];
+	return items.map((item) => {
+		if (item instanceof Map) return { part_id: optionalString(item.get("part_id")) };
+		if (item != null && typeof item === "object") return { part_id: optionalString(item.part_id) };
+		return { part_id: void 0 };
+	});
+}
+/**
+* The effective timeline duration of a part read from a raw snapshot. No part
+* stores a derived `duration_ms` in authoritative state (reference/17 §5): a
+* video clip's length is its trim window `play_out - play_in` over the speed
+* multiplier; a speech's is its intrinsic `media_duration_ms`; a caption's is its
+* `initial_duration_ms`. Falls back to `fallback` when no source value is
+* resolvable (e.g. an unknown/raw part).
+*/
+function readPartDurationMs(snapshot, partId, fallback = 1e3) {
+	const part = readPart(snapshot, partId);
+	if (part == null) return fallback;
+	let sourceMs;
+	if (part.part_kind === "video_clip") {
+		const playIn = numericValue(part.play_in);
+		const playOut = numericValue(part.play_out);
+		if (playIn != null && playOut != null) {
+			const speed = videoClipSpeed(part.speed_shift);
+			sourceMs = Math.round((playOut - playIn) / speed);
+		}
+	} else if (part.part_kind === "speech") sourceMs = numericValue(part.media_duration_ms);
+	else if (part.part_kind === "caption") sourceMs = numericValue(part.initial_duration_ms);
+	return sourceMs != null && Number.isFinite(sourceMs) ? sourceMs : fallback;
+}
+function numericValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** The linear speed multiplier of a raw `speed_shift` blob, defaulting to 1. */
+function videoClipSpeed(speedShift) {
+	const speed = speedShift?.config?.linear?.speed;
+	return typeof speed === "number" && Number.isFinite(speed) && speed > 0 ? speed : 1;
+}
+function readPart(snapshot, partId) {
+	const part = getAt(snapshot, "part_library", partId);
+	if (part == null) return null;
+	const plain = snapshotToPlain(part);
+	if ("video_clip" in plain && plain.video_clip != null) return {
+		...plain.video_clip,
+		part_kind: "video_clip"
+	};
+	if ("speech" in plain && plain.speech != null) return {
+		...plain.speech,
+		part_kind: "speech"
+	};
+	if ("caption" in plain && plain.caption != null) return {
+		...plain.caption,
+		part_kind: "caption"
+	};
+	if ("bgm" in plain && plain.bgm != null) return {
+		...plain.bgm,
+		part_kind: "bgm"
+	};
+	return plain;
+}
+function optionalString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region src/editor/schema-validator.ts
+var ValidationError = class extends Error {
+	code;
+	context;
+	constructor(code, message, context) {
+		super(`[${code}] ${message}`);
+		this.name = "ValidationError";
+		this.code = code;
+		this.context = context;
+	}
+};
+var SchemaValidator = class {
+	validateMoveVideoClips(input, doc) {
+		const parsed = this.parse(moveVideoClipsInputSchema, input, "move_invalid_input");
+		const knownIds = this.mainTrackIds(doc);
+		for (const clip of parsed.clips) if (!knownIds.has(clip.clip_id)) throw new ValidationError("move_clip_not_found", `clip_id "${clip.clip_id}" not present on main_track`, { clip_id: clip.clip_id });
+	}
+	validateDeleteVideoClips(input, doc) {
+		const parsed = this.parse(deleteVideoClipsInputSchema, input, "delete_invalid_input");
+		const knownIds = this.mainTrackIds(doc);
+		for (const id of parsed.clip_ids) if (!knownIds.has(id)) throw new ValidationError("delete_clip_not_found", `clip_id "${id}" not present on main_track`, { clip_id: id });
+	}
+	validateAddVideoClips(input, doc) {
+		const parsed = this.parse(addVideoClipsInputSchema, input, "add_invalid_input");
+		const knownIds = this.mainTrackIds(doc);
+		if (parsed.before_clip_id != null && !knownIds.has(parsed.before_clip_id)) throw new ValidationError("add_before_clip_not_found", `before_clip_id "${parsed.before_clip_id}" not on main_track`, { before_clip_id: parsed.before_clip_id });
+		if (parsed.after_clip_id != null && !knownIds.has(parsed.after_clip_id)) throw new ValidationError("add_after_clip_not_found", `after_clip_id "${parsed.after_clip_id}" not on main_track`, { after_clip_id: parsed.after_clip_id });
+	}
+	validateAdjustVideoClipVolume(input, doc) {
+		const parsed = this.parse(adjustVideoClipVolumeInputSchema, input, "adjust_volume_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const c of parsed.clips) this.assertPartKind(snapshot, c.clip_id, "video_clip", "adjust_volume");
+	}
+	validateSetVideoClipSpeedShift(input, doc) {
+		const parsed = this.parse(setVideoClipSpeedShiftInputSchema, input, "set_speed_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const c of parsed.clips) this.assertPartKind(snapshot, c.clip_id, "video_clip", "set_speed");
+	}
+	validateReplaceVideoClipContent(input, doc) {
+		const parsed = this.parse(replaceVideoClipContentInputSchema, input, "replace_content_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const c of parsed.clips) {
+			this.assertPartKind(snapshot, c.clip_id, "video_clip", "replace_content");
+			if (c.play_in >= c.play_out || c.play_out > c.media_duration_ms) throw new ValidationError("replace_content_invalid_window", `trim window [${c.play_in}, ${c.play_out}] must be non-empty and within media_duration_ms ${c.media_duration_ms}`, {
+				clip_id: c.clip_id,
+				play_in: c.play_in,
+				play_out: c.play_out,
+				media_duration_ms: c.media_duration_ms
+			});
+		}
+	}
+	validateAdjustVideoClipDuration(input, doc) {
+		const parsed = this.parse(adjustVideoClipDurationInputSchema, input, "adjust_duration_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const c of parsed.clips) {
+			this.assertPartKind(snapshot, c.clip_id, "video_clip", "adjust_duration");
+			if (c.play_out <= c.play_in) throw new ValidationError("adjust_duration_invalid_window", `play_out must be greater than play_in`, {
+				clip_id: c.clip_id,
+				play_in: c.play_in,
+				play_out: c.play_out
+			});
+		}
+	}
+	validateAdjustSpeechVolume(input, doc) {
+		const parsed = this.parse(adjustSpeechVolumeInputSchema, input, "adjust_speech_volume_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const s of parsed.speeches) this.assertPartKind(snapshot, s.speech_id, "speech", "adjust_speech_volume");
+	}
+	validateAdjustBgmVolume(input, doc) {
+		const parsed = this.parse(adjustBgmVolumeInputSchema, input, "adjust_bgm_volume_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const b of parsed.bgm) this.assertPartKind(snapshot, b.bgm_id, "bgm", "adjust_bgm_volume");
+	}
+	validateAddSpeeches(input, doc) {
+		const parsed = this.parse(addSpeechesInputSchema, input, "add_speeches_invalid_input");
+		this.assertCaptionsOwned(parsed, "add_speeches");
+		this.assertAnchorsExist(parsed, doc, "add_speeches");
+	}
+	validateChangeSpeechScript(input, doc) {
+		const parsed = this.parse(changeSpeechScriptInputSchema, input, "change_script_invalid_input");
+		this.assertCaptionsOwned(parsed, "change_script");
+		this.assertSpeechesExist(parsed, doc, "change_script");
+		this.assertAnchorsExist(parsed, doc, "change_script");
+	}
+	validateChangeSpeechVoice(input, doc) {
+		const parsed = this.parse(changeSpeechVoiceInputSchema, input, "change_voice_invalid_input");
+		this.assertCaptionsOwned(parsed, "change_voice");
+		this.assertSpeechesExist(parsed, doc, "change_voice");
+		this.assertAnchorsExist(parsed, doc, "change_voice");
+	}
+	validateDeleteSpeeches(input, doc) {
+		const parsed = this.parse(deleteSpeechesInputSchema, input, "delete_speeches_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const id of parsed.speech_ids) this.assertPartKind(snapshot, id, "speech", "delete_speeches");
+	}
+	validateMoveSpeeches(input, doc) {
+		const parsed = this.parse(moveSpeechesInputSchema, input, "move_speeches_invalid_input");
+		const snapshot = doc.snapshot();
+		for (const s of parsed.speeches) this.assertPartKind(snapshot, s.speech_id, "speech", "move_speeches");
+	}
+	validateSetBgm(input, _doc) {
+		this.parse(setBgmInputSchema, input, "set_bgm_invalid_input");
+	}
+	validateDeleteBgm(input, _doc) {
+		this.parse(deleteBgmInputSchema, input, "delete_bgm_invalid_input");
+	}
+	validateSetCaptionVisibility(input, _doc) {
+		this.parse(setCaptionVisibilityInputSchema, input, "set_caption_visibility_invalid_input");
+	}
+	validateSetCaptionStyle(input, _doc) {
+		this.parse(setCaptionStyleInputSchema, input, "set_caption_style_invalid_input");
+	}
+	parse(schema, input, code) {
+		const parsed = schema.safeParse(input);
+		if (!parsed.success) throw new ValidationError(code, parsed.error.message, { issues: parsed.error.issues });
+		return parsed.data;
+	}
+	mainTrackIds(doc) {
+		const items = readMainTrackItems(doc.snapshot());
+		return new Set(items.map((it) => it.part_id).filter((id) => id != null));
+	}
+	/** Every caption a speech declares in `caption_ids` must be supplied in `captions`. */
+	assertCaptionsOwned(assets, opName) {
+		const supplied = new Set(assets.captions.map((c) => c.caption_id));
+		for (const speech of assets.speeches) for (const captionId of speech.caption_ids) if (!supplied.has(captionId)) throw new ValidationError(`${opName}_caption_not_supplied`, `speech declares caption not in payload`, {
+			speech_id: speech.speech_id,
+			caption_id: captionId
+		});
+	}
+	/** Each regenerated speech (re-TTS) must already exist in the document. */
+	assertSpeechesExist(assets, doc, opName) {
+		const snapshot = doc.snapshot();
+		for (const speech of assets.speeches) this.assertPartKind(snapshot, speech.speech_id, "speech", opName);
+	}
+	/**
+	* Each speech's `anchor_part_id` must point at a video clip that already
+	* exists. A relative speech anchored to a missing clip cannot be positioned
+	* by the projection and has no host to recover to (RFC 02 §4/§11.1), so the
+	* write must be rejected rather than landing a dangling reference. (Restores
+	* the dangling-reference guard the old `validateMaterializedPatch` carried;
+	* ADR 0009.)
+	*/
+	assertAnchorsExist(assets, doc, opName) {
+		const snapshot = doc.snapshot();
+		for (const speech of assets.speeches) this.assertPartKind(snapshot, speech.anchor_part_id, "video_clip", `${opName}_anchor`);
+	}
+	assertPartKind(snapshot, partId, kind, opName) {
+		const part = readPart(snapshot, partId);
+		if (part == null) throw new ValidationError(`${opName}_part_not_found`, `part_library has no entry for "${partId}"`, { part_id: partId });
+		if (part.part_kind !== kind) throw new ValidationError(`${opName}_wrong_part_kind`, `part_id "${partId}" is kind "${String(part.part_kind)}", expected "${kind}"`, {
+			part_id: partId,
+			part_kind: part.part_kind
+		});
+	}
+};
+//#endregion
+//#region src/timeline-core/locate.ts
+/**
+* The flow-ordered main-track clip ranges (cumulative effective durations from
+* 0). Empty-media gap fillers are not in authoritative state, so this reflects
+* only the real clips the draft stores.
+*/
+function mainTrackRanges(draft) {
+	const partLibrary = readPartLibrary(draft);
+	const items = (draft.tracks ?? []).find((t) => t?.parts_kind === "video_clip")?.items ?? [];
+	const ranges = [];
+	let cursor = 0;
+	for (const item of items) {
+		const partId = item?.part_id;
+		if (partId == null) continue;
+		const clip = partLibrary[partId]?.video_clip;
+		if (clip == null) continue;
+		const durationMs = effectiveVideoClipDurationMs(clip);
+		ranges.push({
+			partId,
+			startMs: cursor,
+			endMs: cursor + durationMs
+		});
+		cursor += durationMs;
+	}
+	return ranges;
+}
+/**
+* Pick the host video clip an absolute time lands in, with the harness two-sided
+* fallback: before the first clip → first clip; after the last → last clip.
+* Returns null only when there is no clip at all (caller leaves the item as-is).
+*/
+function hostForAbsMs(ranges, absMs) {
+	if (ranges.length === 0) return null;
+	const hit = ranges.find((r) => r.startMs <= absMs && absMs < r.endMs);
+	if (hit != null) return hit;
+	return absMs < ranges[0].startMs ? ranges[0] : ranges[ranges.length - 1];
+}
+/**
+* Build an `anchored` time position anchoring `absMs` to the host clip it lands
+* in (offset clamped to a non-negative integer). Falls back to `absolute` when
+* there is no host clip. Pair with `fallbackAbsMs = absMs` on the item.
+*/
+function relativePositionForAbs(ranges, absMs) {
+	const host = hostForAbsMs(ranges, absMs);
+	if (host == null) return {
+		mode: "absolute",
+		offsetMs: Math.round(absMs)
+	};
+	return {
+		mode: "anchored",
+		anchorPartId: host.partId,
+		offsetMs: Math.max(0, Math.round(absMs - host.startMs))
+	};
+}
+function readPartLibrary(draft) {
+	const out = {};
+	for (const [partId, part] of recordEntries(draft.part_library)) if (part != null) out[partId] = part;
+	return out;
+}
+//#endregion
+//#region src/editor/semantic-editor.ts
+var SemanticEditor = class {
+	doc;
+	validator;
+	constructor(doc, validator = new SchemaValidator()) {
+		this.doc = doc;
+		this.validator = validator;
+	}
+	async moveVideoClips(input, options) {
+		this.validator.validateMoveVideoClips(input, this.doc);
+		this.doc.transact((draft) => {
+			const items = mainTrackItems(draft);
+			if (items == null) return;
+			const beforeRanges = mainTrackRanges(draft);
+			for (const clip of input.clips) {
+				const layout = this.computeMainTrackLayout(draft);
+				const fromItem = layout.find((it) => it.part_id === clip.clip_id);
+				if (fromItem == null) throw new Error(`moveVideoClips: clip "${clip.clip_id}" disappeared mid-batch`);
+				const toIndex = this.indexForStartMs(layout, clip.new_start_ms, fromItem.index);
+				if (toIndex === fromItem.index) continue;
+				moveItem(items, fromItem.index, toIndex);
+			}
+			reparentSpeechesAfterMainTrackChange(draft, beforeRanges);
+		}, audit("MoveVideoClips", input, options));
+	}
+	async deleteVideoClips(input, options) {
+		this.validator.validateDeleteVideoClips(input, this.doc);
+		const targets = new Set(input.clip_ids);
+		const policy = input.on_anchored ?? "cascade";
+		this.doc.transact((draft) => {
+			const track = mainTrackRow(draft);
+			if (track?.items == null) return;
+			if (policy === "detach") for (const clipId of targets) detachAnchoredChildren(draft, clipId);
+			track.items = track.items.filter((item) => item.part_id == null || !targets.has(item.part_id));
+			for (const clipId of targets) {
+				if (policy === "cascade") deleteAnchoredSubtree(draft, clipId);
+				deletePart(draft, clipId);
+			}
+		}, audit("DeleteVideoClips", input, options));
+	}
+	async addVideoClips(input, options) {
+		this.validator.validateAddVideoClips(input, this.doc);
+		const insertIndex = this.computeAddInsertIndex(input);
+		this.doc.transact((draft) => {
+			const track = ensureMainTrack(draft);
+			track.items ??= [];
+			let at = insertIndex;
+			for (const clip of input.clips) {
+				const partId = generatePartId("clip");
+				setPart(draft, partId, { video_clip: {
+					id: partId,
+					kind: "video_clip",
+					play_in: clip.play_in ?? 0,
+					play_out: clip.play_out ?? clip.media_duration_ms,
+					volume: 0,
+					origin_media_id: clip.media_id
+				} });
+				track.items.splice(at, 0, {
+					part_id: partId,
+					time_position: { mode: "sequential" },
+					fallback_abs_ms: void 0
+				});
+				at += 1;
+			}
+		}, audit("AddVideoClips", input, options));
+	}
+	async adjustVideoClipVolume(input, options) {
+		this.validator.validateAdjustVideoClipVolume(input, this.doc);
+		this.doc.transact((draft) => {
+			for (const c of input.clips) {
+				const videoClip = draft.part_library?.[c.clip_id]?.video_clip;
+				if (videoClip == null) continue;
+				setPart(draft, c.clip_id, { video_clip: {
+					...videoClip,
+					kind: "video_clip",
+					volume: c.volume
+				} });
+			}
+		}, audit("AdjustVideoClipVolume", input, options));
+	}
+	async setVideoClipSpeedShift(input, options) {
+		this.validator.validateSetVideoClipSpeedShift(input, this.doc);
+		this.doc.transact((draft) => {
+			for (const clip of input.clips) {
+				const videoClip = draft.part_library?.[clip.clip_id]?.video_clip;
+				if (videoClip == null) continue;
+				const next = {
+					...videoClip,
+					kind: "video_clip",
+					speed_shift: normalizeSpeedShift(clip.speed_shift)
+				};
+				setPart(draft, clip.clip_id, { video_clip: next });
+			}
+		}, audit("SetVideoClipSpeedShift", input, options));
+	}
+	async adjustSpeechVolume(input, options) {
+		this.validator.validateAdjustSpeechVolume(input, this.doc);
+		this.doc.transact((draft) => {
+			for (const s of input.speeches) {
+				const speech = draft.part_library?.[s.speech_id]?.speech;
+				if (speech == null) continue;
+				setPart(draft, s.speech_id, { speech: {
+					...speech,
+					kind: "speech",
+					volume: s.volume
+				} });
+			}
+		}, audit("AdjustSpeechVolume", input, options));
+	}
+	async adjustBgmVolume(input, options) {
+		this.validator.validateAdjustBgmVolume(input, this.doc);
+		this.doc.transact((draft) => {
+			for (const b of input.bgm) {
+				const bgm = draft.part_library?.[b.bgm_id]?.bgm;
+				if (bgm == null) continue;
+				setPart(draft, b.bgm_id, { bgm: {
+					...bgm,
+					kind: "bgm",
+					volume: b.volume
+				} });
+			}
+		}, audit("AdjustBgmVolume", input, options));
+	}
+	/**
+	* Replace the media backing existing video clips. The new media's stable
+	* result (new media id, intrinsic length, reset trim window) is materialized
+	* upstream; the clip ids and their track items are unchanged. Only the part
+	* facts change — effective duration and downstream positions are derived by
+	* the projection on read.
+	*/
+	async replaceVideoClipContent(input, options) {
+		this.validator.validateReplaceVideoClipContent(input, this.doc);
+		this.doc.transact((draft) => {
+			for (const clip of input.clips) {
+				const videoClip = draft.part_library?.[clip.clip_id]?.video_clip;
+				if (videoClip == null) continue;
+				setPart(draft, clip.clip_id, { video_clip: {
+					...videoClip,
+					kind: "video_clip",
+					origin_media_id: clip.origin_media_id,
+					play_in: clip.play_in,
+					play_out: clip.play_out,
+					volume: clip.volume,
+					speed_shift: void 0
+				} });
+			}
+		}, audit("ReplaceVideoClipContent", input, options));
+	}
+	/**
+	* Re-trim clips. Only the `play_in` / `play_out` facts change; the new
+	* effective duration and the resulting downstream reflow are derived by the
+	* projection on read (anchored speeches follow their host clip automatically).
+	*/
+	async adjustVideoClipDuration(input, options) {
+		this.validator.validateAdjustVideoClipDuration(input, this.doc);
+		this.doc.transact((draft) => {
+			for (const clip of input.clips) {
+				const videoClip = draft.part_library?.[clip.clip_id]?.video_clip;
+				if (videoClip == null) continue;
+				setPart(draft, clip.clip_id, { video_clip: {
+					...videoClip,
+					kind: "video_clip",
+					play_in: clip.play_in,
+					play_out: clip.play_out
+				} });
+			}
+			refreshAnchoredFallbackAbs(draft);
+		}, audit("AdjustVideoClipDuration", input, options));
+	}
+	/**
+	* Add speeches (and their captions). TTS runs upstream; the materialized
+	* speech / caption parts arrive in `input`, each carrying its host clip
+	* `anchor_part_id` + `offset_ms`. The editor writes the parts and their
+	* `anchored` `time_position` facts verbatim — no write-time host-picking, no
+	* cascade. The projection derives absolute positions on read.
+	*/
+	async addSpeeches(input, options) {
+		this.validator.validateAddSpeeches(input, this.doc);
+		this.doc.transact((draft) => {
+			writeSpeechAssets(draft, input);
+		}, audit("AddSpeeches", input, options));
+	}
+	/** Delete speeches with their captions; the subtree is removed (§9.2). Surviving lanes keep their facts. */
+	async deleteSpeeches(input, options) {
+		this.validator.validateDeleteSpeeches(input, this.doc);
+		this.doc.transact((draft) => {
+			for (const speechId of input.speech_ids) deleteSpeechSubtree(draft, speechId);
+		}, audit("DeleteSpeeches", input, options));
+	}
+	/**
+	* Move speeches in time (§9.1). One forward positioning pass: anchor each
+	* speech to the main-track clip its new absolute start lands in and write the
+	* resulting `anchored` `time_position` fact. No cascade — the projection
+	* derives absolute positions on read.
+	*/
+	async moveSpeeches(input, options) {
+		this.validator.validateMoveSpeeches(input, this.doc);
+		this.doc.transact((draft) => {
+			const ranges = mainTrackRanges(draft);
+			const track = findLaneTrack(draft, "speech");
+			for (const move of input.speeches) {
+				const item = (track?.items ?? []).find((it) => it?.part_id === move.speech_id);
+				if (item == null) continue;
+				item.time_position = relativePositionForAbs(ranges, move.new_start_ms);
+				item.fallback_abs_ms = move.new_start_ms;
+			}
+		}, audit("MoveSpeeches", input, options));
+	}
+	/** Change a speech's script. Re-TTS runs upstream; the regenerated parts arrive materialized (no cascade). */
+	async changeSpeechScript(input, options) {
+		this.validator.validateChangeSpeechScript(input, this.doc);
+		this.doc.transact((draft) => {
+			writeSpeechAssets(draft, input);
+		}, audit("ChangeSpeechScript", input, options));
+	}
+	/** Change a speech's voice. Re-TTS runs upstream; the regenerated parts arrive materialized (no cascade). */
+	async changeSpeechVoice(input, options) {
+		this.validator.validateChangeSpeechVoice(input, this.doc);
+		this.doc.transact((draft) => {
+			writeSpeechAssets(draft, input);
+		}, audit("ChangeSpeechVoice", input, options));
+	}
+	/**
+	* Set the document BGM. The media's stable result arrives materialized.
+	*
+	* KNOWN GAP (non-blocking): when the BGM comes from the public library, the
+	* Director must also register project-level stock media ownership. That is a
+	* separate "register-only, no draft write" side effect Director does not yet
+	* expose; until it does, a public-library BGM set here will not auto-appear in
+	* the project media library. The document edit itself is complete and correct.
+	* See `docs/projects/medeo-integration/results/phase-4-op-side-effect-classification.md`.
+	*/
+	async setBgm(input, options) {
+		this.validator.validateSetBgm(input, this.doc);
+		this.doc.transact((draft) => {
+			const track = ensureLaneTrack(draft, "bgm");
+			for (const item of track.items ?? []) if (item?.part_id != null) deletePart(draft, item.part_id);
+			setPart(draft, input.bgm_id, { bgm: {
+				id: input.bgm_id,
+				kind: "bgm",
+				audio_storage_key: input.audio_storage_key,
+				volume: input.volume,
+				origin_media_id: input.origin_media_id
+			} });
+			track.items = [{
+				part_id: input.bgm_id,
+				time_position: {
+					mode: "absolute",
+					offsetMs: 0
+				},
+				fallback_abs_ms: void 0
+			}];
+		}, audit("SetBgm", input, options));
+	}
+	/** Remove the document BGM; clears the bgm lane and removes the part. */
+	async deleteBgm(input, options) {
+		this.validator.validateDeleteBgm(input, this.doc);
+		this.doc.transact((draft) => {
+			const track = findLaneTrack(draft, "bgm");
+			if (track == null) return;
+			for (const item of track.items ?? []) if (item?.part_id != null) deletePart(draft, item.part_id);
+			track.items = [];
+		}, audit("DeleteBgm", input, options));
+	}
+	/** Toggle caption visibility (caption track `is_hidden`). */
+	async setCaptionVisibility(input, options) {
+		this.validator.validateSetCaptionVisibility(input, this.doc);
+		this.doc.transact((draft) => {
+			const track = findLaneTrack(draft, "caption");
+			if (track == null) return;
+			track.is_hidden = input.is_hidden;
+		}, audit("SetCaptionVisibility", input, options));
+	}
+	/**
+	* Set the document-wide caption style. GLOBAL (no `caption_id`): the patch is
+	* merged onto EVERY caption part's `style`, mirroring the FE, which applies a
+	* single style to all captions (`caption-style.ts:persistCaptionStylePatch`).
+	*
+	* Merge, not replace: only the fields present in the input overwrite the
+	* caption's existing style; absent fields are carried forward. So a partial
+	* patch ("recolor only") keeps the caption's font size. Pure document edit, no
+	* cascade — positions are untouched.
+	*/
+	async setCaptionStyle(input, options) {
+		this.validator.validateSetCaptionStyle(input, this.doc);
+		this.doc.transact((draft) => {
+			const library = draft.part_library ?? {};
+			for (const partId of Object.keys(library)) {
+				const caption = library[partId]?.caption;
+				if (caption == null) continue;
+				setPart(draft, partId, { caption: {
+					...caption,
+					kind: "caption",
+					style: {
+						...caption.style,
+						...input
+					}
+				} });
+			}
+		}, audit("SetCaptionStyle", input, options));
+	}
+	/**
+	* Resolve the main-track sequential layout from `source`. Callers inside a
+	* `transact` MUST pass the live `draft` so item order reflects in-progress
+	* mutations; the default `this.doc.snapshot()` is only committed state and is
+	* correct for read-only callers outside a transaction. `readMainTrackItems` /
+	* `readPartDurationMs` accept both an immer draft and a raw snapshot.
+	*/
+	computeMainTrackLayout(source = this.doc.snapshot()) {
+		const items = readMainTrackItems(source);
+		const layout = [];
+		let cur = 0;
+		for (let i = 0; i < items.length; i++) {
+			const partId = items[i].part_id;
+			if (partId == null) continue;
+			const durationMs = readPartDurationMs(source, partId, 1e3);
+			layout.push({
+				index: i,
+				part_id: partId,
+				start_ms: cur,
+				end_ms: cur + durationMs
+			});
+			cur += durationMs;
+		}
+		return layout;
+	}
+	indexForStartMs(layout, newStartMs, selfIndex) {
+		const without = layout.filter((it) => it.index !== selfIndex);
+		let cur = 0;
+		let target = without.length;
+		for (let i = 0; i < without.length; i++) {
+			const it = without[i];
+			const durationMs = it.end_ms - it.start_ms;
+			if (newStartMs <= cur + durationMs / 2) {
+				target = i;
+				break;
+			}
+			cur += durationMs;
+		}
+		return Math.max(0, Math.min(target, layout.length - 1));
+	}
+	computeAddInsertIndex(input) {
+		const items = readMainTrackItems(this.doc.snapshot());
+		if (input.before_clip_id != null) {
+			const idx = items.findIndex((it) => it.part_id === input.before_clip_id);
+			return idx < 0 ? items.length : idx;
+		}
+		if (input.after_clip_id != null) {
+			const idx = items.findIndex((it) => it.part_id === input.after_clip_id);
+			return idx < 0 ? items.length : idx + 1;
+		}
+		const firstStart = input.clips[0]?.start_ms;
+		if (firstStart == null) return items.length;
+		const snapshot = this.doc.snapshot();
+		let cur = 0;
+		for (let i = 0; i < items.length; i++) {
+			const partId = items[i].part_id;
+			const durationMs = partId == null ? 1e3 : readPartDurationMs(snapshot, partId, 1e3);
+			if (firstStart <= cur + durationMs / 2) return i;
+			cur += durationMs;
+		}
+		return items.length;
+	}
+};
+function audit(kind, payload, options) {
+	return {
+		kind,
+		payload,
+		intent: options?.intent ?? null
+	};
+}
+function mainTrackRow(draft) {
+	return (draft.tracks ?? []).find((t) => t?.parts_kind === "video_clip");
+}
+/**
+* Locate the main (video_clip) track in the single `tracks` list, minting an
+* empty one in lane-stacking order if absent (reference/17 §4: lane =
+* `parts_kind`). Used by ops that add the first clips into an empty document.
+* Delegates to `ensureLaneTrack` so the caption → main → speech/bgm ordering is
+* enforced in one place.
+*/
+function ensureMainTrack(draft) {
+	return ensureLaneTrack(draft, "video_clip");
+}
+function mainTrackItems(draft) {
+	const track = mainTrackRow(draft);
+	if (track == null) return void 0;
+	track.items ??= [];
+	return track.items;
+}
+function moveItem(items, from, to) {
+	if (from === to) return;
+	const [moved] = items.splice(from, 1);
+	items.splice(to, 0, moved);
+}
+function setPart(draft, partId, part) {
+	draft.part_library ??= {};
+	draft.part_library[partId] = partUnionToDraft(part);
+}
+function deletePart(draft, partId) {
+	if (draft.part_library != null) delete draft.part_library[partId];
+}
+/**
+* The validated speed-shift input already matches the domain `SpeedShift` shape
+* (`category` enum + `config` linear/curve union, mirroring the IDL); this just
+* narrows `null` (clear speed back to 1×) to `undefined`.
+*/
+function normalizeSpeedShift(input) {
+	return input ?? void 0;
+}
+/**
+* Write a materialized speech subtree into the draft: upsert each speech +
+* caption part, and insert/update their lane items with `anchored` `time_position`
+* facts taken verbatim from the input (RFC 02 §4) — speech anchors to its host
+* video clip (`anchor_part_id` + `offset_ms`); caption anchors to its speech
+* (offset = caption part `start_ms`). No absolute time is written; the
+* projection derives it on read. On re-TTS the speech id is preserved, so an
+* existing item is re-positioned rather than duplicated.
+*/
+function writeSpeechAssets(draft, assets) {
+	const captionById = new Map(assets.captions.map((c) => [c.caption_id, c]));
+	const speechTrack = ensureLaneTrack(draft, "speech");
+	const captionTrack = ensureLaneTrack(draft, "caption");
+	speechTrack.items ??= [];
+	captionTrack.items ??= [];
+	const ranges = mainTrackRanges(draft);
+	const hostStartMs = (anchorPartId) => ranges.find((r) => r.partId === anchorPartId)?.startMs;
+	for (const speech of assets.speeches) {
+		const priorCaptionIds = draft.part_library?.[speech.speech_id]?.speech?.caption_ids ?? [];
+		const nextCaptionIds = new Set(speech.caption_ids);
+		const removedCaptionIds = priorCaptionIds.filter((id) => id != null && !nextCaptionIds.has(id));
+		for (const captionId of removedCaptionIds) deletePart(draft, captionId);
+		if (removedCaptionIds.length > 0) {
+			const removed = new Set(removedCaptionIds);
+			captionTrack.items = captionTrack.items.filter((it) => it?.part_id == null || !removed.has(it.part_id));
+		}
+		const priorSpeech = draft.part_library?.[speech.speech_id]?.speech;
+		setPart(draft, speech.speech_id, { speech: {
+			...priorSpeech,
+			id: speech.speech_id,
+			kind: "speech",
+			media_duration_ms: speech.duration_ms,
+			audio_script: speech.audio_script,
+			volume: speech.volume,
+			audio_storage_key: speech.audio_storage_key,
+			origin_speech_id: speech.origin_speech_id,
+			voice: speech.voice,
+			caption_ids: speech.caption_ids
+		} });
+		const hostStart = hostStartMs(speech.anchor_part_id);
+		const speechAbs = hostStart == null ? void 0 : hostStart + speech.offset_ms;
+		placeRelative(speechTrack.items, speech.speech_id, speech.anchor_part_id, speech.offset_ms, speechAbs);
+		for (const captionId of speech.caption_ids) {
+			const caption = captionById.get(captionId);
+			if (caption == null) continue;
+			const priorCaption = draft.part_library?.[captionId]?.caption;
+			setPart(draft, captionId, { caption: {
+				...priorCaption,
+				id: captionId,
+				kind: "caption",
+				initial_duration_ms: caption.duration_ms,
+				speech_part_id: speech.speech_id,
+				text: caption.text,
+				start_ms: caption.start_ms
+			} });
+			const captionAbs = speechAbs == null ? void 0 : speechAbs + caption.start_ms;
+			placeRelative(captionTrack.items, captionId, speech.speech_id, caption.start_ms, captionAbs);
+		}
+	}
+}
+/**
+* Insert a lane item with an `anchored` time position fact, or re-position it if
+* already present. `fallbackAbsMs` is the orphan-recovery snapshot (RFC 02
+* §11.1): the item's absolute landing the caller resolved from its anchor, so a
+* freshly-created anchored item can still be recovered if its anchor is later
+* concurrently deleted. Pass `undefined` only when the anchor's absolute
+* position cannot be resolved (no host clip yet).
+*/
+function placeRelative(items, partId, anchorPartId, offsetMs, fallbackAbsMs) {
+	const timePosition = {
+		mode: "anchored",
+		anchorPartId,
+		offsetMs: Math.max(0, Math.round(offsetMs))
+	};
+	const existing = items.find((it) => it?.part_id === partId);
+	if (existing != null) {
+		existing.time_position = timePosition;
+		if (fallbackAbsMs != null) existing.fallback_abs_ms = fallbackAbsMs;
+		return;
+	}
+	items.push({
+		part_id: partId,
+		time_position: timePosition,
+		fallback_abs_ms: fallbackAbsMs
+	});
+}
+/**
+* After the main-track flow order changes (move / reorder), re-parent each
+* anchored speech to the clip its *preserved* absolute landing now falls in
+* (RFC 02 §9.1). `beforeRanges` is the pre-change main-track layout, used only
+* to recover each speech's current absolute time; the new layout is read fresh.
+* Writes only the affected speech `position` facts — a single forward pass, not
+* a cascade. Captions follow their speech (relative to it), so they need no
+* rewrite.
+*/
+function reparentSpeechesAfterMainTrackChange(draft, beforeRanges) {
+	const speechTrack = findLaneTrack(draft, "speech");
+	if (speechTrack?.items == null) return;
+	const beforeStart = new Map(beforeRanges.map((r) => [r.partId, r.startMs]));
+	const afterRanges = mainTrackRanges(draft);
+	for (const item of speechTrack.items) {
+		const timePosition = item?.time_position;
+		if (timePosition?.mode !== "anchored") continue;
+		const hostStart = beforeStart.get(timePosition.anchorPartId);
+		if (hostStart == null) continue;
+		const currentAbs = hostStart + timePosition.offsetMs;
+		item.time_position = relativePositionForAbs(afterRanges, currentAbs);
+		item.fallback_abs_ms = currentAbs;
+	}
+}
+/**
+* Refresh the orphan-recovery snapshot (`fallback_abs_ms`, RFC 02 §11.1) of
+* every `anchored` speech from the current main-track layout, keeping the
+* `time_position` facts untouched. Called after an op that shifts clip positions
+* without re-parenting (e.g. re-trim), so a later orphan recovery uses an
+* absolute landing that matches the post-edit layout, not a stale one. Speeches
+* whose anchor clip is absent are left as-is (recovery handles them).
+*/
+function refreshAnchoredFallbackAbs(draft) {
+	const speechTrack = findLaneTrack(draft, "speech");
+	if (speechTrack?.items == null) return;
+	const startByPart = new Map(mainTrackRanges(draft).map((r) => [r.partId, r.startMs]));
+	for (const item of speechTrack.items) {
+		const timePosition = item?.time_position;
+		if (timePosition?.mode !== "anchored") continue;
+		const hostStart = startByPart.get(timePosition.anchorPartId);
+		if (hostStart == null) continue;
+		item.fallback_abs_ms = hostStart + timePosition.offsetMs;
+	}
+}
+/**
+* Remove a speech part, its captions, and all their lane items (RFC 02 §9.2
+* subtree). The cascade basis is the anchored `time_position`, not the speech's
+* `caption_ids` (reference/17 §6): a caption is deleted iff it is `anchored` to
+* this speech (`time_position.anchorPartId === speechId`). `caption_ids` stays as
+* a resource-intrinsic fact (reference/17 principle 4) but no longer drives
+* deletion — "what to delete" is decoupled from "what the resource is".
+*/
+function deleteSpeechSubtree(draft, speechId) {
+	const captionTrack = findLaneTrack(draft, "caption");
+	const anchoredCaptionIds = new Set((captionTrack?.items ?? []).filter((it) => it?.time_position?.mode === "anchored" && it.time_position.anchorPartId === speechId).map((it) => it.part_id).filter((id) => id != null));
+	deletePart(draft, speechId);
+	for (const captionId of anchoredCaptionIds) deletePart(draft, captionId);
+	const speechTrack = findLaneTrack(draft, "speech");
+	if (speechTrack?.items != null) speechTrack.items = speechTrack.items.filter((it) => it?.part_id !== speechId);
+	if (captionTrack?.items != null) captionTrack.items = captionTrack.items.filter((it) => it?.part_id == null || !anchoredCaptionIds.has(it.part_id));
+}
+/**
+* Detach the direct anchored children of a video clip (reference/17 §6 `detach`):
+* each speech anchored to `clipId` is re-pinned to `{ mode:'absolute' }` at its
+* current projected landing, so it stays on the timeline once the clip is gone.
+* Computed while the anchor chain is intact (call before removing the clip), so
+* the absolute landing is always resolvable — no `fallback_abs_ms` read needed.
+*
+* Only the *direct* children detach: a speech's captions anchor to the speech
+* (not the clip), so they keep following the speech and need no rewrite.
+*/
+function detachAnchoredChildren(draft, clipId) {
+	const speechTrack = findLaneTrack(draft, "speech");
+	if (speechTrack?.items == null) return;
+	const clipStart = new Map(mainTrackRanges(draft).map((r) => [r.partId, r.startMs])).get(clipId);
+	for (const item of speechTrack.items) {
+		const timePosition = item?.time_position;
+		if (timePosition?.mode !== "anchored" || timePosition.anchorPartId !== clipId) continue;
+		const abs = (clipStart ?? item.fallback_abs_ms ?? 0) + timePosition.offsetMs;
+		item.time_position = {
+			mode: "absolute",
+			offsetMs: Math.max(0, Math.round(abs))
+		};
+		item.fallback_abs_ms = void 0;
+	}
+}
+/** Delete every speech (with its captions) anchored to the given video clip (RFC 02 §9.2). */
+function deleteAnchoredSubtree(draft, clipId) {
+	const anchored = (findLaneTrack(draft, "speech")?.items ?? []).filter((it) => it?.time_position?.mode === "anchored" && it.time_position.anchorPartId === clipId).map((it) => it.part_id).filter((id) => id != null);
+	for (const speechId of anchored) deleteSpeechSubtree(draft, speechId);
+}
+//#endregion
+//#region src/editor/types.ts
+/** Runtime list of the frozen, implemented kinds (for guards / introspection). */
+const IMPLEMENTED_SEMANTIC_OP_KINDS = [
+	"MoveVideoClips",
+	"DeleteVideoClips",
+	"AddVideoClips",
+	"AdjustVideoClipVolume",
+	"SetVideoClipSpeedShift",
+	"ReplaceVideoClipContent",
+	"AdjustVideoClipDuration",
+	"AddSpeeches",
+	"DeleteSpeeches",
+	"MoveSpeeches",
+	"ChangeSpeechScript",
+	"ChangeSpeechVoice",
+	"AdjustSpeechVolume",
+	"SetCaptionVisibility",
+	"SetCaptionStyle",
+	"SetBgm",
+	"DeleteBgm",
+	"AdjustBgmVolume"
+];
+function isImplementedSemanticOpKind(kind) {
+	return IMPLEMENTED_SEMANTIC_OP_KINDS.includes(kind);
+}
+//#endregion
+//#region src/storage/medeo-http-doc-storage.ts
+/**
+* SSE-backed {@link Connection} for the mengine-server document stream.
+*
+* It owns the live SSE read loop and reflects its lifecycle as connection
+* status: `connecting` while (re)establishing, `connected` once the stream is
+* open, back to `connecting` on a drop (auto-reconnect), `closed` on
+* `disconnect`. Reporting a drop as a status change is the whole point — the
+* synchronizer watches `onStatusChanged` and, on any change, tears down and
+* re-runs its connect cycle, which re-issues `getDocDiff(doc.version())` and so
+* recovers whatever the stream missed while it was down. Recovery therefore
+* lives in the synchronizer (keyed on the real doc version), not here.
+*
+* Each SSE frame's updates are forwarded verbatim via `onUpdate`; this
+* connection keeps no version cursor and does no catch-up of its own. Dedup is
+* unnecessary because `LoroDoc.import` is idempotent by OpId/VV.
+*/
+var SseConnection = class {
+	client;
+	onUpdate;
+	reconnectDelayMs;
+	inner = void 0;
+	event = new EventBus();
+	streamTask = null;
+	_status = "idle";
+	_error;
+	constructor(client, onUpdate, reconnectDelayMs) {
+		this.client = client;
+		this.onUpdate = onUpdate;
+		this.reconnectDelayMs = reconnectDelayMs;
+	}
+	get status() {
+		return this._status;
+	}
+	get error() {
+		return this._error;
+	}
+	connect() {
+		if (this.streamTask != null) return;
+		const task = Task.spawn((scope) => this.runStreamLoop(scope.signal));
+		this.streamTask = task;
+		const release = () => {
+			if (this.streamTask === task) this.streamTask = null;
+		};
+		task.then(release, release);
+	}
+	disconnect() {
+		this.streamTask?.cancel();
+		this.streamTask = null;
+		this.setStatus("closed");
+	}
+	waitForConnected() {
+		return new Task((resolve, reject, scope) => {
+			if (this._status === "connected") {
+				resolve();
+				return;
+			}
+			const off = this.onStatusChanged((status, error) => {
+				if (status === "connected") {
+					off();
+					resolve();
+				} else if (status === "closed") {
+					off();
+					reject(error ?? /* @__PURE__ */ new Error("SSE connection closed"));
+				}
+			});
+			scope.disposer.add(off);
+		});
+	}
+	onStatusChanged(cb) {
+		return this.event.on("statusChanged", ({ status, error }) => cb(status, error));
+	}
+	setStatus(status, error) {
+		if (this._status === status && this._error === error) return;
+		this._status = status;
+		this._error = error;
+		this.event.emit("statusChanged", {
+			status,
+			error
+		});
+	}
+	async runStreamLoop(signal) {
+		while (!signal.aborted) {
+			this.setStatus("connecting");
+			try {
+				await readMengineEventStream({
+					client: this.client,
+					signal,
+					onOpen: () => this.setStatus("connected"),
+					onUpdate: (event) => {
+						for (const update of event.updates) this.onUpdate(update);
+					}
+				});
+			} catch (error) {
+				if (signal.aborted) break;
+				this.setStatus("connecting", error instanceof Error ? error : new Error(String(error)));
+			}
+			if (signal.aborted) break;
+			try {
+				await Task.delay(this.reconnectDelayMs).abortOn(signal);
+			} catch {
+				break;
+			}
+		}
+	}
+};
+/**
+* Adapts the mengine-server HTTP/SSE protocol to the engine `DocStorage`
+* contract so `ClientServerSynchronizer` can treat it as a remote peer.
+*
+* Deliberately thin (mirrors the socket `DocStorage` in the playground): it
+* forwards live SSE updates and exposes a version-vector diff, and keeps NO
+* sync state of its own.
+*
+* - `getDocDiff(docId, knownVersion)` pulls the server-computed VV-diff via
+*   `GET /sync?from=<vv>` — the synchronizer passes the real `doc.version()`, so
+*   the response carries exactly the ops the doc is missing. `getDoc` (full
+*   `/snapshot`) stays for cold start, when the caller holds no version yet.
+* - `pushDocUpdate` forwards a Loro update; the server appends it.
+* - `subscribeDocUpdate` registers a callback for live SSE updates. It does no
+*   catch-up and keeps no cursor: after an SSE drop the connection reports a
+*   status change, and the synchronizer re-runs its cycle to catch up via
+*   `getDocDiff(doc.version())`. `LoroDoc.import` is idempotent (OpId/VV), so
+*   re-forwarded or echoed updates are harmless.
+*
+* It is bound to a single `docId` because `MengineHttpClient` is per-document.
+*/
+var MedeoHttpDocStorage = class {
+	options;
+	connection;
+	client;
+	docId;
+	events = new EventBus();
+	constructor(options) {
+		this.options = options;
+		this.client = options.client;
+		this.docId = options.docId;
+		this.connection = new SseConnection(this.client, (update) => this.emitUpdate(update), options.sseReconnectDelayMs ?? 500);
+	}
+	get isReadonly() {
+		return this.options.readonlyMode ?? false;
+	}
+	async getDoc(docId) {
+		this.assertDocId(docId);
+		const snapshot = await this.client.fetchSnapshot();
+		const now = /* @__PURE__ */ new Date();
+		return {
+			docId,
+			data: base64ToBytes(snapshot.snapshot),
+			createdAt: now,
+			updatedAt: now
+		};
+	}
+	async getDocDiff(docId, knownVersion) {
+		this.assertDocId(docId);
+		const response = await this.client.sync(knownVersion);
+		return {
+			docId,
+			missing: base64ToBytes(response.update),
+			version: base64ToBytes(response.server_vv)
+		};
+	}
+	async pushDocUpdate(update, _origin) {
+		this.assertDocId(update.docId);
+		if (this.isReadonly || update.data.byteLength === 0) return;
+		await this.client.pushUpdate(update.data);
+	}
+	async deleteDoc(_docId) {
+		throw new Error("MedeoHttpDocStorage does not support deleteDoc");
+	}
+	subscribeDocUpdate(callback) {
+		return this.events.on("update", ({ update, origin }) => callback(update, origin));
+	}
+	assertDocId(docId) {
+		if (docId !== this.docId) throw new Error(`MedeoHttpDocStorage is bound to ${this.docId}, received ${docId}`);
+	}
+	emitUpdate(base64Update) {
+		this.events.emit("update", {
+			update: {
+				docId: this.docId,
+				data: base64ToBytes(base64Update)
+			},
+			origin: void 0
+		});
+	}
+};
+//#endregion
+//#region src/storage/memory-doc-storage.ts
+/**
+* Runtime-neutral local `DocStorage` backed by in-process memory.
+*
+* `IndexedDBDocStorage` is the browser-side local storage, but it requires
+* `indexedDB`/`idb`, which is absent in Node (FE/agent tests, unit tests, SSR).
+* The mengine runtime injects this implementation as the local peer in those
+* environments so the same `DocManager` + `ClientServerSynchronizer` wiring
+* works without a browser. It mirrors the merge-on-read and update-sequence
+* behavior of `IndexedDBDocStorage` so sync semantics are identical.
+*/
+var MemoryDocStorage = class extends BaseDocStorage {
+	connection = new DummyConnection();
+	entries = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		super(options);
+	}
+	async pushDocUpdate(update, origin) {
+		const entry = this.entry(update.docId);
+		if (entry.snapshot == null && entry.updates.length === 0) {
+			const now = this.now();
+			entry.snapshot = {
+				docId: update.docId,
+				data: update.data,
+				createdAt: now,
+				updatedAt: now
+			};
+		} else {
+			entry.seq += 1;
+			entry.updates.push({
+				docId: update.docId,
+				seq: entry.seq,
+				data: update.data,
+				createdAt: this.now()
+			});
+		}
+		this.event.emit("update", {
+			update: {
+				docId: update.docId,
+				data: update.data
+			},
+			origin
+		});
+	}
+	async deleteDoc(docId) {
+		this.entries.delete(docId);
+	}
+	async getDocSnapshot(docId) {
+		return this.entries.get(docId)?.snapshot ?? null;
+	}
+	async setDocSnapshot(snapshot) {
+		const entry = this.entry(snapshot.docId);
+		if (entry.snapshot == null || entry.snapshot.updatedAt <= snapshot.updatedAt) entry.snapshot = snapshot;
+		return true;
+	}
+	async getDocUpdates(docId) {
+		return [...this.entries.get(docId)?.updates ?? []];
+	}
+	async markUpdatesMerged(docId, updates) {
+		const entry = this.entries.get(docId);
+		if (!entry) return 0;
+		const merged = new Set(updates.map((update) => update.seq));
+		entry.updates = entry.updates.filter((update) => !merged.has(update.seq));
+		return merged.size;
+	}
+	entry(docId) {
+		let entry = this.entries.get(docId);
+		if (!entry) {
+			entry = {
+				snapshot: null,
+				updates: [],
+				seq: 0
+			};
+			this.entries.set(docId, entry);
+		}
+		return entry;
+	}
+	now() {
+		return /* @__PURE__ */ new Date();
+	}
+};
+//#endregion
+//#region src/session/mengine-doc-session.ts
+/**
+* A live editing session for one Medeo document — the single entry point clients
+* (FE draft driver, Agent, embeds) use to open, edit, and observe a document.
+*
+* It assembles the engine sync stack around one Medeo document:
+*
+*   local DocStorage  ─┐
+*                      ├─ ClientServerSynchronizer ── DocManager ── LoroDoc
+*   MedeoHttpDocStorage┘                                              │
+*                          (remote = Rust mengine-server)             ▼
+*                                                   MirrorVideoDocumentAdapter + SemanticEditor
+*
+* `DocManager` owns the `LoroDoc`: local edits committed on the adapter are
+* picked up via `subscribeLocalUpdates`, saved to local storage, then pushed to
+* the server by the synchronizer. Remote SSE updates flow server → synchronizer
+* → local storage → manager → `LoroDoc`. A single `LoroDoc.subscribe` turns any
+* resulting change into a snapshot event, so callers never track update ids by
+* hand.
+*
+* Replaces the per-consumer hand-written pull/SSE loops that previously lived in
+* the standalone client session and `MengineDraftDriver` with one verified path.
+*/
+var MengineDocSession = class {
+	options;
+	docId;
+	local;
+	server;
+	synchronizer;
+	manager;
+	events = new EventBus();
+	disposables = new DisposableSet();
+	adapterValue = null;
+	editorValue = null;
+	started = false;
+	constructor(options) {
+		this.options = options;
+		this.docId = options.docId;
+		this.local = options.localStorage ?? new MemoryDocStorage();
+		this.server = new MedeoHttpDocStorage({
+			docId: options.docId,
+			client: options.client,
+			sseReconnectDelayMs: options.sseReconnectDelayMs
+		});
+		this.synchronizer = new ClientServerSynchronizer(this.local, this.server);
+		this.manager = new DocManager(this.local, this.synchronizer);
+	}
+	/**
+	* The editor for local edits. Each op method validates, writes, and commits
+	* itself as one SemanticOp (single commit carrying its audit message), so
+	* callers just call `session.editor.someOp(...)` — there is no separate commit
+	* step. The committed change drives DocManager's local-update push.
+	*/
+	get editor() {
+		if (this.editorValue == null) throw new Error("mengine doc session is not started");
+		return this.editorValue;
+	}
+	/** Current document snapshot (read model). */
+	snapshot() {
+		if (this.adapterValue == null) throw new Error("mengine doc session is not started");
+		return this.adapterValue.snapshot();
+	}
+	/**
+	* Start the sync stack and connect the document.
+	*
+	* Returns once the local snapshot has loaded into the Loro doc so callers can
+	* read an initial snapshot. Remote convergence continues in the background and
+	* surfaces through `subscribe`.
+	*/
+	async start() {
+		if (this.started) return this.snapshot();
+		this.started = true;
+		this.local.connection.connect();
+		this.server.connection.connect();
+		this.disposables.add(() => this.local.connection.disconnect());
+		this.disposables.add(() => this.server.connection.disconnect());
+		this.synchronizer.start();
+		this.manager.start();
+		this.disposables.add(() => this.synchronizer.stop());
+		this.disposables.add(() => this.manager.stop());
+		const doc = this.manager.connectDoc(this.docId);
+		if (this.options.peerId != null) doc.setPeerId(this.options.peerId);
+		this.adapterValue = new MirrorVideoDocumentAdapter(doc);
+		this.editorValue = new SemanticEditor(this.adapterValue);
+		this.disposables.add(() => this.manager.disconnectDoc(this.docId));
+		const unsubscribe = doc.subscribe((event) => {
+			if (this.adapterValue == null) return;
+			this.events.emit("update", {
+				source: event.by === "local" ? "local" : "remote",
+				snapshot: this.adapterValue.snapshot()
+			});
+		});
+		this.disposables.add(unsubscribe);
+		this.disposables.add(this.manager.onDocStateChange(this.docId, (state) => this.events.emit("state", state)));
+		await this.waitForContent();
+		return this.snapshot();
+	}
+	subscribe(cb) {
+		return this.events.on("update", cb);
+	}
+	onStateChange(cb) {
+		return this.events.on("state", cb);
+	}
+	getState() {
+		return this.manager.getDocState(this.docId);
+	}
+	destroy() {
+		this.disposables.dispose();
+		this.events.clearAll();
+		this.adapterValue = null;
+		this.editorValue = null;
+		this.started = false;
+	}
+	/**
+	* Resolve once the Loro doc holds the document root.
+	*
+	* `DocManager` loads from local storage, which starts empty for a fresh
+	* client; the server snapshot arrives asynchronously via the first sync job.
+	* `loaded` only means the local load ran, so we wait for actual content
+	* (populated schema roots) instead, surfaced by the doc subscription set up
+	* in `start()`.
+	*/
+	async waitForContent() {
+		if (this.hasContent()) return;
+		await new Promise((resolve) => {
+			const off = this.events.on("update", () => {
+				if (this.hasContent()) {
+					off();
+					resolve();
+				}
+			});
+		});
+	}
+	hasContent() {
+		if (this.adapterValue == null) return false;
+		try {
+			return this.adapterValue.hasContent();
+		} catch {
+			return false;
+		}
+	}
+};
+//#endregion
+export { IMPLEMENTED_SEMANTIC_OP_KINDS, MedeoHttpDocStorage, MemoryDocStorage, MengineDocSession, MengineHttpClient, MengineHttpRequestError, MirrorVideoDocumentAdapter, SchemaValidator, SemanticEditor, TIMELINE_SKELETON_DURATION_MS, VIDEO_DOCUMENT_SCHEMA_VERSION, ValidationError, VideoDocumentValidationError, arrangeMainTrackSeamlessly, assertValidVideoDocument, base64ToBytes, buildSpeechHostMap, bytesToBase64, cascadeAfterVideoClipChanges, createMirrorVideoDocument, createMirrorVideoDocumentAdapter, derivePositionFromAbs, ensureLaneTrack, fillMainTrackTimeGaps, findLaneTrack, fromVideoDocument, generatePartId, getAt, hostForAbsMs, isEmptyVideoClip, isImplementedSemanticOpKind, isMap, mainTrackRanges, partDurationMs, partUnionSchema, readMainTrackItems, readMengineEventStream, readPart, readPartDurationMs, readVideoDocumentFromDraft, reassignSpeechesToVideoClipsByTime, recalculateTimelineDuration, relativePositionForAbs, resolveAllSpeechOverlaps, resolveSpeechOverlapByShiftingVideos, safeDurationMs, schemas_exports as schemas, snapshotToPlain, solveVideoDocument, syncAggregatedClipsTimePosition, toVideoDocument, validateVideoDocument, videoDocumentMirrorSchema, videoDocumentSchema };