@mengine/medeo-client 0.1.3 → 1.0.1-alpha.0

package/dist/index.js

@@ -1,24 +1,17 @@
-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 { A as isEmptyVideoClip, B as bytesToBase64, C as fillMainTrackTimeGaps, D as resolveSpeechOverlapByShiftingVideos, E as resolveAllSpeechOverlaps, F as speedOf, I as partUnionToDraft, L as recordEntries, M as safeDurationMs, N as VIDEO_DOCUMENT_SCHEMA_VERSION, O as syncAggregatedClipsTimePosition, P as effectiveVideoClipDurationMs, R as videoDocumentMirrorSchema, S as arrangeMainTrackSeamlessly, T as recalculateTimelineDuration, _ as videoDocumentSchema, a as createMirrorVideoDocument, b as solveVideoDocument, c as readVideoDocumentFromDraft, d as fromVideoDocument, f as toVideoDocument, g as partUnionSchema, h as validateVideoDocument, i as MirrorVideoDocumentAdapter, j as partDurationMs, k as TIMELINE_SKELETON_DURATION_MS, l as buildSpeechHostMap, m as assertValidVideoDocument, n as createPlainMemoryAdapter, o as createMirrorVideoDocumentAdapter, p as VideoDocumentValidationError, r as generatePartId, s as writeVideoDocumentToDraft, t as PlainMemoryAdapter, u as derivePositionFromAbs, v as ensureLaneTrack, w as reassignSpeechesToVideoClipsByTime, x as cascadeAfterVideoClipChanges, y as findLaneTrack, z as base64ToBytes } from "./document-DgffKwRw.js";
+import { addSpeechesInputSchema, addVideoClipsInputSchema, adjustBgmVolumeInputSchema, adjustSpeechVolumeInputSchema, adjustVideoClipDurationInputSchema, adjustVideoClipVolumeInputSchema, changeSpeechScriptInputSchema, changeSpeechVoiceInputSchema, deleteBgmInputSchema, deleteSpeechesInputSchema, deleteVideoClipsInputSchema, moveSpeechesInputSchema, moveVideoClipsInputSchema, replaceVideoClipContentInputSchema, setBgmInputSchema, setCaptionStyleInputSchema, setCaptionVisibilityInputSchema, setVideoClipSpeedShiftInputSchema, t as schemas_exports } from "./schemas.js";
 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
+/**
+* Public route prefix of the mengine doc-collaboration API. Must stay in lockstep
+* with `apps/mengine-server`'s `API_PREFIX` — the two form the private wire
+* contract between this client and the relay server. Versioned, mengine-owned
+* namespace (mirrors the cluster's `/oapi/v1` precedent for an independent
+* subsystem) rather than folding into the shared `/api/v2/*` space.
+*/
+const MENGINE_API_PREFIX = "/api/mengine/v1";
 var MengineHttpRequestError = class extends Error {
 	status;
 	payload;
@@ -99,7 +92,7 @@ var MengineHttpClient = class {
 		return payload;
 	}
 	endpoint(path) {
-		return `${this.options.httpOrigin.replace(/\/$/, "")}/api/mengine/docs/${encodeURIComponent(this.options.docId)}/${path}`;
+		return `${this.options.httpOrigin.replace(/\/$/, "")}${MENGINE_API_PREFIX}/docs/${encodeURIComponent(this.options.docId)}/${path}`;
 	}
 };
 async function safeReadJson(response) {
@@ -163,1886 +156,6 @@ function findSseFrameBoundary(buffer) {
 	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;
@@ -2350,9 +463,11 @@ function readPartLibrary(draft) {
 var SemanticEditor = class {
 	doc;
 	validator;
-	constructor(doc, validator = new SchemaValidator()) {
+	idFactory;
+	constructor(doc, validator = new SchemaValidator(), idFactory = generatePartId) {
 		this.doc = doc;
 		this.validator = validator;
+		this.idFactory = idFactory;
 	}
 	async moveVideoClips(input, options) {
 		this.validator.validateMoveVideoClips(input, this.doc);
@@ -2394,7 +509,7 @@ var SemanticEditor = class {
 			track.items ??= [];
 			let at = insertIndex;
 			for (const clip of input.clips) {
-				const partId = generatePartId("clip");
+				const partId = this.idFactory("clip");
 				setPart(draft, partId, { video_clip: {
 					id: partId,
 					kind: "video_clip",
@@ -2934,6 +1049,105 @@ function deleteAnchoredSubtree(draft, clipId) {
 	for (const speechId of anchored) deleteSpeechSubtree(draft, speechId);
 }
 //#endregion
+//#region src/editor/journal.ts
+/**
+* Wire a plain-memory adapter + editor that share a recording id factory, so
+* every mutating transact lands in `journal` with ordered `generated_ids`.
+*/
+function createEditSandbox(document, options) {
+	const adapter = createPlainMemoryAdapter(document, options);
+	return {
+		adapter,
+		editor: new SemanticEditor(adapter, new SchemaValidator(), adapter.idFactory),
+		journal: adapter.journal
+	};
+}
+/**
+* Re-drive `doc` from a recorded journal, forcing each entry's `generated_ids`
+* through a queue-backed id factory. Never mints fresh ids: an empty queue on
+* demand throws `unrecorded id`; leftover ids after an entry throws
+* `unconsumed ids`. Legacy entries without `generated_ids` are treated as `[]`.
+*/
+async function replayJournal(doc, journal) {
+	const queue = [];
+	const idFactory = (_prefix) => {
+		const id = queue.shift();
+		if (id == null) throw new Error("unrecorded id");
+		return id;
+	};
+	const editor = new SemanticEditor(doc, new SchemaValidator(), idFactory);
+	for (const entry of journal) {
+		queue.push(...entry.generated_ids ?? []);
+		await dispatchEntry(editor, entry);
+		if (queue.length > 0) throw new Error("unconsumed ids");
+	}
+}
+/** Dispatch one journal entry to the matching editor method; payload is passed through. */
+async function dispatchEntry(editor, entry) {
+	const payload = entry.payload;
+	const options = entry.intent != null ? { intent: entry.intent } : void 0;
+	switch (entry.kind) {
+		case "MoveVideoClips":
+			await editor.moveVideoClips(payload, options);
+			return;
+		case "DeleteVideoClips":
+			await editor.deleteVideoClips(payload, options);
+			return;
+		case "AddVideoClips":
+			await editor.addVideoClips(payload, options);
+			return;
+		case "AdjustVideoClipVolume":
+			await editor.adjustVideoClipVolume(payload, options);
+			return;
+		case "SetVideoClipSpeedShift":
+			await editor.setVideoClipSpeedShift(payload, options);
+			return;
+		case "ReplaceVideoClipContent":
+			await editor.replaceVideoClipContent(payload, options);
+			return;
+		case "AdjustVideoClipDuration":
+			await editor.adjustVideoClipDuration(payload, options);
+			return;
+		case "AddSpeeches":
+			await editor.addSpeeches(payload, options);
+			return;
+		case "DeleteSpeeches":
+			await editor.deleteSpeeches(payload, options);
+			return;
+		case "MoveSpeeches":
+			await editor.moveSpeeches(payload, options);
+			return;
+		case "ChangeSpeechScript":
+			await editor.changeSpeechScript(payload, options);
+			return;
+		case "ChangeSpeechVoice":
+			await editor.changeSpeechVoice(payload, options);
+			return;
+		case "AdjustSpeechVolume":
+			await editor.adjustSpeechVolume(payload, options);
+			return;
+		case "SetCaptionVisibility":
+			await editor.setCaptionVisibility(payload, options);
+			return;
+		case "SetCaptionStyle":
+			await editor.setCaptionStyle(payload, options);
+			return;
+		case "SetBgm":
+			await editor.setBgm(payload, options);
+			return;
+		case "DeleteBgm":
+			await editor.deleteBgm(payload, options);
+			return;
+		case "AdjustBgmVolume":
+			await editor.adjustBgmVolume(payload, options);
+			return;
+		default: {
+			const _exhaustive = entry.kind;
+			throw new Error(`replayJournal: unsupported kind ${String(_exhaustive)}`);
+		}
+	}
+}
+//#endregion
 //#region src/editor/types.ts
 /** Runtime list of the frozen, implemented kinds (for guards / introspection). */
 const IMPLEMENTED_SEMANTIC_OP_KINDS = [
@@ -3286,6 +1500,24 @@ var MengineDocSession = class {
 		if (this.editorValue == null) throw new Error("mengine doc session is not started");
 		return this.editorValue;
 	}
+	/**
+	* Opaque version token of the local oplog (base64 `VersionVector.encode`).
+	* Equality-comparable only: equal means no observed change (local or
+	* remote-arrived) since the token was taken. Throws when not started.
+	*/
+	version() {
+		if (this.adapterValue == null) throw new Error("mengine doc session is not started");
+		return bytesToBase64(this.adapterValue.doc.oplogVersion().encode());
+	}
+	/**
+	* The live document adapter, exposed for journal replay (commit channel).
+	* Replaying through it still goes SemanticEditor → Loro → mengine-server —
+	* no write bypass. Typed by the narrow interface on purpose.
+	*/
+	get documentAdapter() {
+		if (this.adapterValue == null) throw new Error("mengine doc session is not started");
+		return this.adapterValue;
+	}
 	/** Current document snapshot (read model). */
 	snapshot() {
 		if (this.adapterValue == null) throw new Error("mengine doc session is not started");
@@ -3372,4 +1604,4 @@ var MengineDocSession = class {
 	}
 };
 //#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 };
+export { IMPLEMENTED_SEMANTIC_OP_KINDS, MedeoHttpDocStorage, MemoryDocStorage, MengineDocSession, MengineHttpClient, MengineHttpRequestError, MirrorVideoDocumentAdapter, PlainMemoryAdapter, SchemaValidator, SemanticEditor, TIMELINE_SKELETON_DURATION_MS, VIDEO_DOCUMENT_SCHEMA_VERSION, ValidationError, VideoDocumentValidationError, arrangeMainTrackSeamlessly, assertValidVideoDocument, base64ToBytes, buildSpeechHostMap, bytesToBase64, cascadeAfterVideoClipChanges, createEditSandbox, createMirrorVideoDocument, createMirrorVideoDocumentAdapter, createPlainMemoryAdapter, derivePositionFromAbs, effectiveVideoClipDurationMs, ensureLaneTrack, fillMainTrackTimeGaps, findLaneTrack, fromVideoDocument, generatePartId, getAt, hostForAbsMs, isEmptyVideoClip, isImplementedSemanticOpKind, isMap, mainTrackRanges, partDurationMs, partUnionSchema, readMainTrackItems, readMengineEventStream, readPart, readPartDurationMs, readVideoDocumentFromDraft, reassignSpeechesToVideoClipsByTime, recalculateTimelineDuration, relativePositionForAbs, replayJournal, resolveAllSpeechOverlaps, resolveSpeechOverlapByShiftingVideos, safeDurationMs, schemas_exports as schemas, snapshotToPlain, solveVideoDocument, speedOf, syncAggregatedClipsTimePosition, toVideoDocument, validateVideoDocument, videoDocumentMirrorSchema, videoDocumentSchema, writeVideoDocumentToDraft };