@mengine/medeo-client 2.0.1-alpha.4 → 2.0.1-alpha.6

package/dist/document-N-8GwtOX.js

@@ -0,0 +1,4589 @@
+import { u as volumeSchema } from "./shared-iWnU2osE.js";
+import { Mirror, schema } from "loro-mirror";
+import { z } from "zod";
+import { LoroDoc, LoroMap, LoroMovableList, LoroText, UndoManager } from "loro-crdt";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { produce } from "immer";
+//#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/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$1 = 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({
+	display_cues: schema.String({ required: false }).transform(jsonTransform()),
+	id: schema.String(),
+	initial_duration_ms: schema.Number(),
+	speech_part_id: schema.String({ required: false }),
+	text: schema.String(),
+	start_ms: schema.Number(),
+	style: captionStyle$1
+}, {
+	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";
+/** A server-derived compatibility view, never an editor write authority. */
+const ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION = "video-document/entity-projection-v1";
+/** 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;
+}
+/**
+* The `timeline.unit_time_ms` the read-view states when the document states none.
+*
+* One frame at 30fps. A document legitimately has no such fact (display
+* granularity is the editor's, not the timeline's), but the read-view IDL marks
+* the field `@required`, so the projection has to name a value. This one is a
+* usable granularity; `0` — which a downstream consumer had been defaulting to —
+* is not, and passes any `>= 0` guard on its way to an editor that cannot use it.
+*/
+const DEFAULT_UNIT_TIME_MS = 33.333;
+//#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;
+	const derivedFillerPartIds = /* @__PURE__ */ new Set();
+	if (document.meta.schema_version === "video-document/entity-projection-v1") {
+		for (const track of document.tracks ?? []) if (track.items?.some((item) => item.time_position.mode === "sequential" || item.time_position.mode === "anchored" && !Number.isSafeInteger(item.fallback_abs_ms))) throw new Error("An entity timeline projection must contain resolved placement facts");
+		recalculateTimelineDuration(doc);
+	} else cascadeAfterVideoClipChanges(doc, () => {
+		const partId = `empty_${counter++}`;
+		derivedFillerPartIds.add(partId);
+		return { partId };
+	});
+	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,
+		derivedFillerPartIds
+	};
+}
+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));
+}
+/**
+* The four lanes in top-to-bottom stack order — the order a `tracks` list holds
+* them in (see {@link laneRank}).
+*
+* Exported so a document can be seeded with all four lanes up front. That seed is
+* not cosmetic: {@link ensureLaneTrack} is find-then-mint over a `LoroMovableList`,
+* so two concurrent writers that each mint the same absent lane both keep their
+* row, and the merged document holds two tracks for one lane. For the main lane
+* that is fatal — `videoDocumentSchema` allows at most one `video_clip` track, so
+* the merged document stops being projectable at all, symmetrically on both
+* replicas. Pre-seeding every lane makes `ensureLaneTrack` always take its find
+* branch, which removes the race by construction rather than by detection.
+*
+* What closes the race is that a track with the lane's `parts_kind` EXISTS — the
+* lookup is by kind, not by id. So a seed is only safe if it covers every lane:
+* a partial seed leaves the uncovered lanes exactly as exposed as before.
+*/
+const LANE_KINDS_IN_STACK_ORDER = [
+	"caption",
+	"video_clip",
+	"speech",
+	"bgm"
+];
+/**
+* The conventional track id for a lane (`main_track`, `<kind>_track`). Shared by
+* the up-front seed and {@link ensureLaneTrack}'s lazy mint so a document's lane
+* ids do not depend on which of the two created the track.
+*
+* Ids are cosmetic to the merge itself — lane lookup goes by `parts_kind`, so
+* drifting them apart would not reopen the concurrent-mint race. They matter to
+* readers that address a lane by id (the FE editor's panes, fixtures), which is
+* why there is one convention rather than two.
+*/
+function laneTrackId(kind) {
+	return kind === "video_clip" ? "main_track" : `${kind}_track`;
+}
+/**
+* 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
+* comes from {@link laneTrackId}, shared with the up-front seed.
+*
+* The mint branch is a concurrency hazard, not a convenience: see
+* {@link LANE_KINDS_IN_STACK_ORDER}. A document seeded with all four lanes never
+* reaches it.
+*/
+function ensureLaneTrack(draft, kind) {
+	draft.tracks ??= [];
+	let track = draft.tracks.find((t) => t?.parts_kind === kind);
+	if (track == null) {
+		track = {
+			id: laneTrackId(kind),
+			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 = 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.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().optional(),
+	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.enum([VIDEO_DOCUMENT_SCHEMA_VERSION, ENTITY_TIMELINE_PROJECTION_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");
+	validateLaneTrackUniqueness(doc, issues);
+	validateSpeechCaptionReferences(partLibrary, issues);
+	validatePositionReferences(doc, partLibrary, issues);
+	return issues;
+}
+/**
+* Report a duplicated lane: two tracks sharing the same `id`, or two secondary
+* tracks of the same `parts_kind`.
+*
+* Found by the Phase 6 M0/S2 concurrency probe. `ensureLaneTrack` locates a lane
+* by `parts_kind` and mints `<kind>_track` when absent, so two replicas that both
+* start without (say) a caption track each create one; `tracks` is a
+* `LoroMovableList`, so the merge keeps BOTH. The lane is then split across two
+* same-id tracks, and the projection's `find`-by-kind returns only one of them —
+* so an item can be authoritative yet invisible in the pane a reader looks at.
+*
+* Flagged **recoverable**, not `error`, for two reasons. It is a reachable
+* outcome of ordinary concurrent editing, and hard-rejecting would make an
+* unavoidable merge result un-projectable — the same argument §11.1 makes for
+* orphans. And the projection already tolerates it: `solveVideoDocument`
+* concatenates every track of a kind, so the cascade sees all items regardless.
+* The defect is a *reader-visible* split, so the right response is to surface it
+* (loudly, in a channel someone reads), not to block the document.
+*
+* The main track is exempt from the kind check: `parts_kind === 'video_clip'` may
+* legitimately appear on several tracks (the projection treats only the first as
+* the main pane), so only its `id` collision is reported.
+*/
+function validateLaneTrackUniqueness(doc, issues) {
+	const tracks = doc.tracks ?? [];
+	const seenIds = /* @__PURE__ */ new Set();
+	const seenSecondaryKinds = /* @__PURE__ */ new Set();
+	for (const [idx, track] of tracks.entries()) {
+		const id = track?.id;
+		if (id != null && id !== "") if (seenIds.has(id)) issues.push({
+			code: "duplicate_lane_track",
+			path: `/tracks/${idx}/id`,
+			message: `Track "tracks/${idx}" reuses track id "${id}"`,
+			severity: "recoverable"
+		});
+		else seenIds.add(id);
+		const kind = track?.parts_kind;
+		if (kind == null || kind === "video_clip") continue;
+		if (seenSecondaryKinds.has(kind)) issues.push({
+			code: "duplicate_lane_track",
+			path: `/tracks/${idx}/parts_kind`,
+			message: `Lane "${kind}" is split across more than one track (at "tracks/${idx}")`,
+			severity: "recoverable"
+		});
+		else seenSecondaryKinds.add(kind);
+	}
+}
+/**
+* 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$1(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: 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.
+*
+* The read-view is a compatibility contract, and the IDL declares
+* `Timeline.unit_time_ms` and `Track.is_hidden` `@required`
+* (`video_draft_comp.smithy`) — so a projection that omitted them handed every
+* consumer a payload that violated the shape it claims to satisfy, leaving each
+* one to invent its own default. Two already had, and they disagreed: the agent
+* harness used `unit_time_ms: 0`, director used a frame at 30fps. Defaulting here
+* makes the contract true at the one place that produces it.
+*
+* These two are defaultable because the projection knows their values on its own:
+* absent `unit_time_ms` means "no display granularity was ever stated" and absent
+* `is_hidden` means "this track was never hidden". `version` is NOT defaultable
+* here — its only honest value is server state (`update_seq`) that a
+* `VideoDocument` cannot see, so it stays absent and the HTTP layer fills it.
+*/
+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 ?? 33.333
+		},
+		video_creation_settings: clone$1(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, view.derivedFillerPartIds),
+		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`.
+*
+* `derivedFillerPartIds` are skipped: the solve minted them to lay the track out
+* and they are not part of the document (see `fromVideoDocument`). An empty clip a
+* writer placed deliberately is NOT in that set and is projected normally.
+*/
+function toReadViewPartLibrary(partLibrary, durationMs, derivedFillerPartIds) {
+	const out = {};
+	for (const [partId, part] of Object.entries(partLibrary)) {
+		if (derivedFillerPartIds.has(partId)) continue;
+		if (part.video_clip != null) {
+			const clip = clone$1(part.video_clip);
+			out[partId] = { video_clip: {
+				...clip,
+				duration_ms: effectiveVideoClipDurationMs(clip)
+			} };
+		} else if (part.speech != null) {
+			const speech = clone$1(part.speech);
+			out[partId] = { speech: {
+				...speech,
+				duration_ms: speech.media_duration_ms
+			} };
+		} else if (part.caption != null) {
+			const caption = clone$1(part.caption);
+			out[partId] = { caption: {
+				...caption,
+				duration_ms: caption.initial_duration_ms
+			} };
+		} else if (part.bgm != null) out[partId] = { bgm: {
+			...clone$1(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$1(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$1(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 ?? false,
+		items: (track.items ?? []).map((item) => ({
+			part_id: item.part_id,
+			abs_time_position: absByPartId.get(item.part_id) ?? 0
+		}))
+	};
+}
+function clone$1(value) {
+	if (Array.isArray(value)) return value.map((item) => clone$1(item));
+	if (value != null && typeof value === "object") {
+		const result = {};
+		for (const [key, child] of Object.entries(value)) result[key] = clone$1(child);
+		return result;
+	}
+	return value;
+}
+//#endregion
+//#region src/document/initial-document.ts
+/**
+* Build the `VideoDocument` a newly created project starts from: the caller's
+* project facts, no parts, and one empty track per lane.
+*
+* The empty lane tracks are the reason this function exists rather than callers
+* assembling a document inline. Lane tracks are otherwise minted lazily by the
+* first op that needs one (`ensureLaneTrack`), which is find-then-mint over a
+* CRDT list — so if the Agent's first generation and a user edit race on an
+* empty document, each mints its own copy of the same lane and the merge keeps
+* both. Two video_clip tracks violate the at-most-one-main-track rule, and the
+* merged document becomes unprojectable for *every* reader (editor, render,
+* share) with no winning replica to fall back on. Seeding all four lanes up
+* front means `ensureLaneTrack` only ever finds, never mints, so the race cannot
+* happen on a document created here.
+*
+* All four, not just the main lane: the secondary lanes fail less loudly (a
+* duplicate pane rather than an unreadable document), but they fail by the same
+* mechanism, and covering only the fatal one would leave three live races.
+*
+* `timeline` is left absent: `unit_time_ms` is a display concern the editor
+* supplies, and total duration is derived on read (RFC 02 §6), so a new document
+* has no timeline fact to state.
+*/
+function buildInitialVideoDocument(facts) {
+	return {
+		meta: {
+			schema_version: VIDEO_DOCUMENT_SCHEMA_VERSION,
+			draft_id: facts.draftId,
+			project_id: facts.projectId,
+			owner_id: facts.ownerId,
+			thumbnail_storage_key: void 0,
+			chat_session_id: facts.chatSessionId,
+			video_creation_settings: facts.videoCreationSettings,
+			version: void 0
+		},
+		timeline: void 0,
+		tracks: emptyLaneTracks(),
+		part_library: {}
+	};
+}
+/** One empty track per lane, in lane-stacking order, with the conventional ids. */
+function emptyLaneTracks() {
+	return LANE_KINDS_IN_STACK_ORDER.map((kind) => ({
+		id: laneTrackId(kind),
+		parts_kind: kind,
+		is_hidden: void 0,
+		items: []
+	}));
+}
+//#endregion
+//#region ../medeo-dsl/src/entities.ts
+function hasSequence(entity) {
+	if (isKnownNonSequenceKind(entity.entityKind) || isReservedEntityKind(entity.entityKind)) return false;
+	return isSequenceFields(entity);
+}
+function isSequenceFields(value) {
+	if (!isRecord$1(value)) return false;
+	const extent = value.extent;
+	if (!isRecord$1(extent) || !("start" in extent) || extent.start === void 0) return false;
+	if (extent.kind === "bounded" && (!("end" in extent) || extent.end === void 0)) return false;
+	if (extent.kind === "unbounded" && "end" in extent) return false;
+	if (extent.kind !== "bounded" && extent.kind !== "unbounded") return false;
+	if (value.sampling !== "native" && value.sampling !== "constant" && value.sampling !== "derived") return false;
+	return "coordinateSpace" in value && value.coordinateSpace !== void 0;
+}
+function isKnownSequenceKind(kind) {
+	return isMediaAssetVariantKind(kind) || kind === "caption" || kind === "axvideo";
+}
+function isMediaAssetVariantKind(kind) {
+	return kind === "video" || kind === "image" || kind === "audio" || kind === "voice";
+}
+function isKnownEntityKind(kind) {
+	return isKnownSequenceKind(kind) || isKnownNonSequenceKind(kind);
+}
+function isReservedEntityKind(kind) {
+	const normalized = kind.toLowerCase().replaceAll("-", "").replaceAll("_", "");
+	return normalized === "speech" || normalized === "videodocument";
+}
+function isKnownNonSequenceKind(kind) {
+	return kind === "timeline" || kind === "track" || kind === "clip" || kind === "asset" || kind === "sequence-marker" || kind === "viewport" || kind === "audio-script" || kind === "phonetic-script";
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+//#endregion
+//#region ../medeo-dsl/src/ids.ts
+function createEntityId(value) {
+	return createId(value, "EntityId");
+}
+function createRelationId(value) {
+	return createId(value, "RelationId");
+}
+function createId(value, label) {
+	if (value.length === 0 || value.trim() !== value) throw new Error(`${label} must be a non-empty trimmed string`);
+	return value;
+}
+//#endregion
+//#region ../medeo-dsl/src/json-values.ts
+const nativeObjectConstructorSource = Function.prototype.toString.call(Object);
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && isJsonValue(value, /* @__PURE__ */ new Set());
+}
+function isJsonValue(value, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object") return false;
+	if (!Array.isArray(value) && !isPlainObject(value)) return false;
+	if (ancestors.has(value)) return false;
+	ancestors.add(value);
+	const valid = Array.isArray(value) ? value.every((item) => isJsonValue(item, ancestors)) : Object.values(value).every((item) => isJsonValue(item, ancestors));
+	ancestors.delete(value);
+	return valid;
+}
+/** Recognize an ordinary object from any VM realm without admitting class instances. */
+function isPlainObject(value) {
+	try {
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype === null) return true;
+		if (Object.getPrototypeOf(prototype) !== null) return false;
+		const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
+		return typeof constructor === "function" && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === nativeObjectConstructorSource;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region ../medeo-dsl/src/composition.ts
+/** Assembly fails explicitly when declared bases cannot provide valid, unambiguous content. */
+var ScriptCompositionError = class extends Error {
+	code;
+	entityId;
+	constructor(code, entityId, message) {
+		super(message);
+		this.code = code;
+		this.entityId = entityId;
+		this.name = "ScriptCompositionError";
+	}
+};
+/** Direct base IDs are structural fields, never ordinary Relation endpoints. */
+function variantBaseEntityIds(entity) {
+	if (!Object.hasOwn(entity.payload, "baseEntityIds")) return [];
+	const ids = entity.payload.baseEntityIds;
+	if (!Array.isArray(ids) || ids.length === 0 || !ids.every((id) => typeof id === "string" && id.trim() === id && id.length > 0) || new Set(ids).size !== ids.length) throw new ScriptCompositionError("invalid_bases", entity.entityId, `Entity "${entity.entityId}" requires non-empty, unique baseEntityIds`);
+	return ids.map(createEntityId);
+}
+/** Validate all base providers before applying explicit own fields; ordering cannot resolve ambiguity. */
+function assembleEntityContent(rows, entityId) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const row of rows.entities) {
+		if (byId.has(row.entityId)) throw new ScriptCompositionError("composition_ambiguous", row.entityId, `duplicate entity id "${row.entityId}"`);
+		byId.set(row.entityId, row);
+	}
+	const active = /* @__PURE__ */ new Set();
+	const cache = /* @__PURE__ */ new Map();
+	const visit = (id) => {
+		const cached = cache.get(id);
+		if (cached !== void 0) return cached;
+		if (active.has(id)) throw new ScriptCompositionError("composition_cycle", id, `Cyclic baseEntityIds at "${id}"`);
+		const row = byId.get(id);
+		if (row === void 0) throw new ScriptCompositionError("composition_dangling", id, `Missing base entity "${id}" in this document`);
+		if (!isJsonObject(row.payload) || Object.hasOwn(row.payload, "entityId") || Object.hasOwn(row.payload, "entityKind")) throw new ScriptCompositionError("invalid_bases", id, `Entity "${id}" requires JSON own fields without reserved identity fields`);
+		active.add(id);
+		const inherited = {};
+		const providers = /* @__PURE__ */ new Map();
+		for (const baseId of variantBaseEntityIds(row)) {
+			const base = visit(baseId);
+			for (const [field, value] of Object.entries(base.payload)) {
+				if (field === "baseEntityIds") continue;
+				const previous = providers.get(field);
+				if (previous !== void 0) throw new ScriptCompositionError("field_conflict", id, `Entity "${id}" field "${field}" conflicts between bases "${previous}" and "${baseId}"; own fields cannot resolve base ambiguity`);
+				providers.set(field, baseId);
+				Object.defineProperty(inherited, field, {
+					value,
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+		}
+		const assembled = {
+			...row,
+			payload: JSON.parse(JSON.stringify({
+				...inherited,
+				...row.payload
+			}))
+		};
+		active.delete(id);
+		cache.set(id, assembled);
+		return assembled;
+	};
+	return visit(entityId);
+}
+/** Resolve a field's declaring entity after validating the entire composition. */
+function resolveEntityFieldOwner(rows, entityId, field) {
+	assembleEntityContent(rows, entityId);
+	const byId = new Map(rows.entities.map((row) => [row.entityId, row]));
+	const find = (id) => {
+		const row = byId.get(id);
+		if (Object.hasOwn(row.payload, field)) return id;
+		if (field === "baseEntityIds") return void 0;
+		for (const baseId of variantBaseEntityIds(row)) {
+			const owner = find(baseId);
+			if (owner !== void 0) return owner;
+		}
+	};
+	return find(entityId) ?? entityId;
+}
+/** Patch assembled fields without copying inherited fields into the variant's stored payload. */
+function updateEntityFields(rows, entityId, fields) {
+	assembleEntityContent(rows, entityId);
+	if (!isJsonObject(fields) || Object.hasOwn(fields, "entityId") || Object.hasOwn(fields, "entityKind")) throw new ScriptCompositionError("invalid_bases", entityId, "Field updates require JSON without reserved identity fields");
+	const updates = /* @__PURE__ */ new Map();
+	for (const [field, value] of Object.entries(fields)) {
+		const ownerId = resolveEntityFieldOwner(rows, entityId, field);
+		const owner = updates.get(ownerId) ?? rows.entities.find((row) => row.entityId === ownerId);
+		updates.set(ownerId, {
+			...owner,
+			payload: {
+				...owner.payload,
+				[field]: value
+			}
+		});
+	}
+	return [...updates.values()].map((row) => JSON.parse(JSON.stringify(row)));
+}
+/** Find the actual AudioScript text owner through direct variant bases. */
+function findComposedAudioScript(rows, variantEntityId, variantKind) {
+	const variant = requireEntityKind(rows, variantEntityId, variantKind);
+	assembleEntityContent(rows, variantEntityId);
+	const sources = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (row) => {
+		for (const id of variantBaseEntityIds(row)) {
+			if (seen.has(id)) continue;
+			seen.add(id);
+			const base = rows.entities.find((candidate) => candidate.entityId === id);
+			if (base.entityKind === "audio-script") sources.set(id, assembleEntityContent(rows, id));
+			else visit(base);
+		}
+	};
+	visit(variant);
+	if (sources.size !== 1) throw new ScriptCompositionError(sources.size === 0 ? "composition_missing" : "composition_ambiguous", variantEntityId, `${variantKind} "${variantEntityId}" baseEntityIds must resolve one AudioScript text owner, got ${sources.size}`);
+	return [...sources.values()][0];
+}
+/** Join the whole AudioScript text in segment order. */
+function assembleScriptText(script) {
+	return scriptSegments(script).map((segment) => segment.text).join("");
+}
+function scriptSegments(script) {
+	const segments = script.payload.segments;
+	if (!Array.isArray(segments)) throw new ScriptCompositionError("composition_dangling", script.entityId, `AudioScript "${script.entityId}" requires segments`);
+	if (!segments.every(isScriptSegment) || new Set(segments.map((s) => s.segmentId)).size !== segments.length) throw new ScriptCompositionError("invalid_script", script.entityId, "AudioScript requires valid segments with unique local segmentId and text");
+	return segments;
+}
+function isScriptSegment(value) {
+	if (typeof value !== "object" || value == null || Array.isArray(value)) return false;
+	const segment = value;
+	return typeof segment.segmentId === "string" && segment.segmentId.trim() !== "" && typeof segment.text === "string" && (segment.language === void 0 || typeof segment.language === "string");
+}
+/** Assemble selected text after base-field validation and explicit variant overrides. */
+function assembleCaptionContent(rows, captionEntityId) {
+	requireEntityKind(rows, captionEntityId, "caption");
+	const caption = assembleEntityContent(rows, captionEntityId);
+	const script = findComposedAudioScript(rows, captionEntityId, "caption");
+	const segment = selectAudioScriptSegment({
+		...script,
+		payload: caption.payload
+	}, captionSelection(caption));
+	return {
+		caption,
+		audioScript: script,
+		segments: [segment],
+		text: segment.text
+	};
+}
+/**
+* Assemble the complete Phonetic Script content for TTS: the composed
+* AudioScript's base text plus the variant's own phoneme and prosody fields.
+*/
+function assemblePhoneticScriptContent(rows, phoneticScriptEntityId) {
+	requireEntityKind(rows, phoneticScriptEntityId, "phonetic-script");
+	const phoneticScript = assembleEntityContent(rows, phoneticScriptEntityId);
+	const audioScript = findComposedAudioScript(rows, phoneticScriptEntityId, "phonetic-script");
+	const segments = scriptSegments({
+		...audioScript,
+		payload: phoneticScript.payload
+	});
+	return {
+		phoneticScript,
+		audioScript,
+		segments,
+		text: segments.map((segment) => segment.text).join("")
+	};
+}
+function captionSelection(caption) {
+	if (Object.hasOwn(caption.payload, "selections") || !isSegmentSelection(caption.payload.selection)) throw new ScriptCompositionError("invalid_selection", caption.entityId, "Caption requires one selection object with segmentId and optional textRange; selections arrays are forbidden");
+	return caption.payload.selection;
+}
+function isSegmentSelection(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value) && typeof value.segmentId === "string" && value.segmentId.trim() !== "" && Object.keys(value).every((key) => key === "segmentId" || key === "textRange");
+}
+/** Select source text without creating another authoritative text field. */
+function selectAudioScriptSegment(script, selection) {
+	if (!isSegmentSelection(selection)) throw new ScriptCompositionError("invalid_selection", script.entityId, "Caption requires one selection object with segmentId and optional textRange");
+	const bySegmentId = new Map(scriptSegments(script).map((segment) => [segment.segmentId, segment]));
+	const selected = (() => {
+		const segment = bySegmentId.get(selection.segmentId);
+		if (segment === void 0) throw new ScriptCompositionError("unknown_segment", script.entityId, `Caption selection "${selection.segmentId}" does not name a segment of AudioScript "${script.entityId}"`);
+		if (selection.textRange === void 0) return segment;
+		const range = selection.textRange;
+		const points = Array.from(segment.text);
+		if (typeof range !== "object" || range === null || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start || range.end > points.length || Object.keys(range).some((key) => key !== "start" && key !== "end")) throw new ScriptCompositionError("invalid_selection", script.entityId, "Caption textRange must be a non-empty half-open Unicode code-point range within its source segment");
+		return {
+			...segment,
+			text: points.slice(range.start, range.end).join("")
+		};
+	})();
+	if (!selected.text.trim()) throw new ScriptCompositionError("empty_selection", script.entityId, "Caption selection must contain visible source text");
+	return selected;
+}
+function requireEntityKind(rows, entityIdValue, entityKind) {
+	const entity = rows.entities.find((candidate) => candidate.entityId === entityIdValue);
+	if (entity === void 0) throw new ScriptCompositionError("composition_dangling", entityIdValue, `Entity "${entityIdValue}" does not exist`);
+	if (entity.entityKind !== entityKind) throw new ScriptCompositionError("composition_dangling", entityIdValue, `Entity "${entityIdValue}" must have kind "${entityKind}", got "${entity.entityKind}"`);
+	return entity;
+}
+//#endregion
+//#region ../medeo-dsl/src/rows.ts
+function entityToRow(entity) {
+	const { entityId, entityKind, ...payload } = entity;
+	if (!isJsonObject(payload)) throw new Error(`Entity "${entityId}" payload must contain only JSON values`);
+	return {
+		entityId,
+		entityKind,
+		payload
+	};
+}
+//#endregion
+//#region ../medeo-dsl/src/invariants.ts
+/**
+* Media variants own their Asset identity directly: a `physical-asset`
+* Relation may not bind them. Caption may associate with a physical text Asset
+* independently of its AudioScript composition.
+*/
+function validateMediaAssetIdentity(entity, index) {
+	return [...index.relationsOf(entity)].filter((relation) => relation.kind === "physical-asset").map(() => ({
+		code: "media_physical_asset_forbidden",
+		entityId: entity.entityId,
+		message: `Media entity "${entity.entityId}" owns its Asset identity; remove its physical-asset Relation`
+	}));
+}
+/** Validates one complete set of entities and its authoritative Relation rows. */
+function validateEntityRelationSet(entityRefs, index, options) {
+	const { entities, issues } = collectRelatedEntities(entityRefs, index);
+	const entityIds = new Set(entities.map((entity) => entity.entityId));
+	const rows = {
+		entities: entities.map((entity) => entityToRow(entity.current())),
+		relations: []
+	};
+	for (const entity of entities) try {
+		assembleEntityContent(rows, entity.entityId);
+	} catch (error) {
+		issues.push({
+			code: "invalid_variant_composition",
+			entityId: entity.entityId,
+			message: error instanceof Error ? error.message : "Invalid variant composition"
+		});
+	}
+	for (const entity of entities) {
+		const current = entity.current();
+		const entityIssues = validateEntity(entity, entityIds);
+		issues.push(...entityIssues);
+		if (isMediaAssetVariantKind(current.entityKind)) issues.push(...validateMediaAssetIdentity(entity, index));
+		if (entityIssues.some((issue) => issue.code === "invalid_entity_payload")) continue;
+		if (current.entityKind === "sequence-marker") {
+			const marker = entity;
+			issues.push(...validateMarkerUse(entity, index));
+			issues.push(...validateMarkerRanges(marker, {
+				source: (left, right) => options.compareMarkerPoints(marker, "source", left, right),
+				target: (left, right) => options.compareMarkerPoints(marker, "target", left, right)
+			}));
+			issues.push(...validateMarkerSourceBounds(marker, index, (left, right) => options.compareMarkerPoints(marker, "source", left, right)));
+		}
+		if (current.entityKind === "clip") {
+			issues.push(...validateClipAdmission(entity, index));
+			issues.push(...validateClipPlacement(entity, index));
+		}
+		if (current.entityKind === "axvideo") issues.push(...validateAXVideoAdmission(entity, index));
+		if (current.entityKind === "caption") issues.push(...validateCaptionComposition(entity, index, entities));
+		if (current.entityKind === "phonetic-script") issues.push(...validatePhoneticComposition(entity, index, entities));
+		issues.push(...validateSequenceComposition(entity));
+	}
+	issues.push(...validateClipAnchorCycles(entities, index));
+	return issues;
+}
+function validateMarkerUse(marker, index) {
+	const relations = [...index.relationsOf(marker)];
+	const clipEdges = ofKind(relations, "clip-marker");
+	const axVideoEdges = ofKind(relations, "axvideo-marker");
+	const contentEdges = ofKind(relations, "marker-content");
+	const timelineEdges = ofKind(relations, "marker-timeline");
+	const scriptEdges = ofKind(relations, "audio-script-marker");
+	const issues = [];
+	if (scriptEdges.length > 0) {
+		if (clipEdges.length + axVideoEdges.length + contentEdges.length + timelineEdges.length > 0) issues.push({
+			code: "marker_container_xor",
+			entityId: marker.entityId,
+			message: "An AudioScript annotation Marker must not carry Clip, AXVideo, content, or Timeline relations"
+		});
+		const ranges = marker.current().segmentRanges;
+		if (!ranges?.length) issues.push({
+			code: "invalid_entity_payload",
+			entityId: marker.entityId,
+			message: "An AudioScript annotation Marker requires segmentRanges"
+		});
+		for (const relation of scriptEdges) {
+			const script = relation.other(marker)?.deref()?.current();
+			if (script?.entityKind !== "audio-script") continue;
+			const segments = script.segments;
+			if (!Array.isArray(segments)) continue;
+			const segmentIds = new Set(segments.map((segment) => segment.segmentId));
+			if (ranges?.some((range) => !segmentIds.has(range.segmentId))) issues.push({
+				code: "invalid_entity_payload",
+				entityId: marker.entityId,
+				message: "Annotation segmentRanges must name segments of the related AudioScript"
+			});
+		}
+		return issues;
+	}
+	if (marker.current().segmentRanges !== void 0) issues.push({
+		code: "invalid_entity_payload",
+		entityId: marker.entityId,
+		message: "segmentRanges belongs to an AudioScript annotation Marker, not a display Marker"
+	});
+	if (clipEdges.length + axVideoEdges.length !== 1) issues.push({
+		code: "marker_container_xor",
+		entityId: marker.entityId,
+		message: "Sequence Marker must have exactly one Clip XOR AXVideo container relation"
+	});
+	if (contentEdges.length + timelineEdges.length !== 1) issues.push({
+		code: "marker_content_xor",
+		entityId: marker.entityId,
+		message: "Sequence Marker must have exactly one Sequence content XOR Timeline relation"
+	});
+	if (clipEdges.length === 1 && timelineEdges.length === 1 || axVideoEdges.length === 1 && contentEdges.length === 1) issues.push({
+		code: "marker_pair_mismatch",
+		entityId: marker.entityId,
+		message: "Only Clip+Content or AXVideo+Timeline Marker relation pairs are valid"
+	});
+	return issues;
+}
+function validateClipAdmission(clip, index) {
+	const markerEdges = ofKind([...index.relationsOf(clip)], "clip-marker");
+	if (markerEdges.length !== 1) return [{
+		code: "clip_marker_cardinality",
+		entityId: clip.entityId,
+		message: "Clip must have exactly one authoritative Clip-Marker Relation"
+	}];
+	const marker = markerEdges[0]?.other(clip)?.deref();
+	if (marker == null) return [{
+		code: "clip_content_cardinality",
+		entityId: clip.entityId,
+		message: "Clip must resolve one live Sequence Marker and one content Relation"
+	}];
+	const contentEdges = ofKind([...index.relationsOf(marker)], "marker-content");
+	if (contentEdges.length !== 1) return [{
+		code: "clip_content_cardinality",
+		entityId: clip.entityId,
+		message: "Clip Marker must resolve exactly one content Relation"
+	}];
+	const content = contentEdges[0]?.other(marker)?.deref()?.current();
+	if (content == null) return [{
+		code: "clip_content_cardinality",
+		entityId: clip.entityId,
+		message: "Clip Marker content Relation must resolve one live entity"
+	}];
+	if (!hasSequence(content)) return [{
+		code: "clip_content_not_sequence",
+		entityId: clip.entityId,
+		message: `Clip Marker resolves to non-Sequence entity "${content.entityId}"`
+	}];
+	return [];
+}
+function validateAXVideoAdmission(axVideo, index) {
+	const markerEdges = ofKind([...index.relationsOf(axVideo)], "axvideo-marker");
+	if (markerEdges.length === 1 && markerEdges[0]?.other(axVideo)?.deref() != null) return [];
+	return [{
+		code: "axvideo_marker_cardinality",
+		entityId: axVideo.entityId,
+		message: "AXVideo must have exactly one live AXVideo-Marker Relation"
+	}];
+}
+/** Validate a Caption against the complete entity set, including its directly held bases. */
+function validateCaptionComposition(caption, index, entities = []) {
+	return validateVariantComposition(caption, index, entities, "caption");
+}
+function validatePhoneticComposition(phonetic, index, entities = []) {
+	return validateVariantComposition(phonetic, index, entities, "phonetic-script");
+}
+function validateVariantComposition(variant, index, entities, kind) {
+	const issues = [];
+	const rows = {
+		entities: collectRelatedEntities([...entities, variant], index).entities.map((ref) => entityToRow(ref.current())),
+		relations: []
+	};
+	try {
+		if (kind === "caption") assembleCaptionContent(rows, variant.entityId);
+		else assemblePhoneticScriptContent(rows, variant.entityId);
+	} catch (error) {
+		issues.push({
+			code: kind === "caption" ? "caption_composition_required" : "phonetic_script_composition_required",
+			entityId: variant.entityId,
+			message: error instanceof Error ? error.message : "Invalid variant composition"
+		});
+	}
+	return issues;
+}
+function validateClipPlacement(clip, index) {
+	const marker = ofKind([...index.relationsOf(clip)], "clip-marker")[0]?.other(clip)?.deref();
+	if (marker?.current().entityKind !== "sequence-marker") return [];
+	const markerValue = marker.current();
+	const anchors = ofKind([...index.relationsOf(clip)], "clip-anchor").filter((relation) => relation.endpoints[0].deref() === clip);
+	const hasOrder = clip.current().order !== void 0;
+	const hasTarget = markerValue.targetRange !== void 0;
+	const hasAnchorOffset = markerValue.anchorOffset !== void 0;
+	const issues = [];
+	if (anchors.length > 1) issues.push({
+		code: "clip_anchor_cardinality",
+		entityId: clip.entityId,
+		message: "A Clip may follow at most one host Clip"
+	});
+	const hasAnchor = anchors.length === 1;
+	if (hasAnchor && (!hasAnchorOffset || hasOrder || hasTarget) || !hasAnchor && (hasAnchorOffset || Number(hasOrder) + Number(hasTarget) !== 1)) issues.push({
+		code: "clip_placement_invalid",
+		entityId: clip.entityId,
+		message: "Clip placement must be exactly one of Clip.order, Marker.targetRange, or clip-anchor with Marker.anchorOffset"
+	});
+	if (markerValue.durationPolicy === "timeline") {
+		const content = ofKind([...index.relationsOf(marker)], "marker-content")[0]?.other(marker)?.deref()?.current();
+		const track = ofKind([...index.relationsOf(clip)], "track-clip")[0]?.other(clip)?.deref()?.current();
+		const trackRole = track?.entityKind === "track" ? track.role : void 0;
+		if (content?.entityKind !== "audio" || trackRole !== "bgm" || !hasOrder && !hasTarget) issues.push({
+			code: "timeline_duration_policy_invalid",
+			entityId: marker.entityId,
+			message: "Marker durationPolicy \"timeline\" is only valid for ordered or absolutely placed Audio Clips on the bgm Track"
+		});
+	}
+	return issues;
+}
+function validateClipAnchorCycles(entities, index) {
+	const hostByChild = /* @__PURE__ */ new Map();
+	for (const entity of entities) {
+		if (entity.current().entityKind !== "clip") continue;
+		for (const relation of ofKind([...index.relationsOf(entity)], "clip-anchor")) {
+			if (relation.endpoints[0].deref() !== entity) continue;
+			const host = relation.endpoints[1].deref();
+			if (host != null) hostByChild.set(entity.entityId, host.entityId);
+		}
+	}
+	const issues = [];
+	for (const child of hostByChild.keys()) {
+		const seen = /* @__PURE__ */ new Set();
+		let current = child;
+		while (current !== void 0 && !seen.has(current)) {
+			seen.add(current);
+			current = hostByChild.get(current);
+		}
+		if (current === void 0) continue;
+		issues.push({
+			code: "clip_anchor_cycle",
+			entityId: child,
+			message: "clip-anchor Relations must form an acyclic dependency graph"
+		});
+	}
+	return issues;
+}
+function validateMarkerRanges(marker, compare) {
+	const current = marker.current();
+	const issues = [];
+	if (!(compare.source(current.sourceRange.start, current.sourceRange.end) < 0)) issues.push({
+		code: "marker_source_range_empty",
+		entityId: marker.entityId,
+		message: "Sequence Marker sourceRange must be a non-empty half-open interval"
+	});
+	if (current.targetRange != null && !(compare.target(current.targetRange.start, current.targetRange.end) < 0)) issues.push({
+		code: "marker_target_range_empty",
+		entityId: marker.entityId,
+		message: "Sequence Marker targetRange must be a non-empty half-open interval"
+	});
+	return issues;
+}
+function validateMarkerSourceBounds(marker, index, compare) {
+	const contentEdges = ofKind([...index.relationsOf(marker)], "marker-content");
+	if (contentEdges.length !== 1) return [];
+	const content = contentEdges[0]?.other(marker)?.deref()?.current();
+	if (content == null || !hasSequence(content)) return [];
+	const sourceRange = marker.current().sourceRange;
+	const startVsExtent = compare(sourceRange.start, content.extent.start);
+	const endVsExtent = content.extent.kind === "bounded" ? compare(sourceRange.end, content.extent.end) : void 0;
+	if (!Number.isNaN(startVsExtent) && startVsExtent >= 0 && (endVsExtent == null || !Number.isNaN(endVsExtent) && endVsExtent <= 0)) return [];
+	return [{
+		code: "marker_source_out_of_bounds",
+		entityId: marker.entityId,
+		message: `Sequence Marker sourceRange must stay within content "${content.entityId}" extent`
+	}];
+}
+function validateSequenceComposition(entity) {
+	const current = entity.current();
+	const expected = expectedSequenceShape(current.entityKind);
+	if (expected == null) return [];
+	if (hasSequence(current) && current.extent.kind === expected.extent && current.sampling === expected.sampling) return [];
+	return [{
+		code: "invalid_sequence_composition",
+		entityId: current.entityId,
+		message: `${current.entityKind} must compose ${expected.extent} / ${expected.sampling} Sequence semantics`
+	}];
+}
+function validateEntity(entity, entityIds = /* @__PURE__ */ new Set()) {
+	const current = entity.current();
+	const issues = [];
+	if (isReservedEntityKind(current.entityKind)) issues.push({
+		code: "forbidden_entity_kind",
+		entityId: current.entityId,
+		message: `Entity kind "${current.entityKind}" is explicitly outside the Medeo DSL`
+	});
+	for (const problem of validateKnownEntityPayload(current)) issues.push({
+		code: "invalid_entity_payload",
+		entityId: current.entityId,
+		message: `Entity "${current.entityKind}" ${problem}`
+	});
+	const peerIdPaths = [...collectPeerEntityIdPaths(current, current.entityKind), ...collectPeerEntityValuePaths(current, current.entityKind, current.entityId, entityIds)];
+	const uniquePeerIdPaths = [...new Set(peerIdPaths)].sort();
+	if (uniquePeerIdPaths.length > 0) issues.push({
+		code: "peer_entity_id_field",
+		entityId: current.entityId,
+		message: `Entity embeds forbidden peer-ID field/value path(s): ${uniquePeerIdPaths.join(", ")}`
+	});
+	return issues;
+}
+function validateKnownEntityPayload(entity) {
+	const value = entity;
+	const problems = [];
+	if (value.lifecycle !== void 0 && !isRecord(value.lifecycle)) problems.push("lifecycle must be an object when present");
+	if (entity.entityKind === "audio-script" || entity.entityKind === "phonetic-script") {
+		for (const key of [
+			"extent",
+			"sampling",
+			"coordinateSpace",
+			"sourceRange",
+			"targetRange",
+			"duration",
+			"startMs",
+			"endMs"
+		]) if (Object.hasOwn(value, key)) problems.push(`${key} is not intrinsic script data; assign an external annotation Marker`);
+	}
+	switch (entity.entityKind) {
+		case "track":
+			validateOptionalField(value, "hidden", "boolean", problems);
+			validateOptionalField(value, "role", "string", problems);
+			validateOptionalFiniteNumber(value, "order", problems);
+			break;
+		case "video":
+		case "audio":
+		case "voice":
+		case "caption":
+			validateSequencePayload(value, "bounded", "native", problems);
+			if (entity.entityKind !== "caption") validateMediaAssetFields(value, problems);
+			if (entity.entityKind === "voice") validateVoicePayload(value, problems);
+			if (entity.entityKind === "caption") validateCaptionPayload(value, problems);
+			break;
+		case "image":
+			validateSequencePayload(value, "unbounded", "constant", problems);
+			validateMediaAssetFields(value, problems);
+			break;
+		case "axvideo":
+			validateSequencePayload(value, "bounded", "derived", problems);
+			break;
+		case "sequence-marker":
+			validateMarkerPayload(value, problems);
+			break;
+		case "audio-script":
+			validateScriptPayload(value, problems);
+			break;
+		case "phonetic-script":
+			validatePhoneticScriptPayload(value, problems);
+			break;
+		case "timeline":
+		case "viewport": break;
+		case "clip":
+			validateOptionalFiniteNumber(value, "order", problems);
+			validateOptionalFiniteNumber(value, "volume", problems);
+			if (typeof value.volume === "number" && (value.volume < -60 || value.volume > 20)) problems.push("volume must be decibels between -60 and 20");
+			break;
+		case "asset":
+			validateAssetPayload(value, problems);
+			break;
+		default: break;
+	}
+	return problems;
+}
+function validateSequencePayload(value, expectedExtent, expectedSampling, problems) {
+	const extent = value.extent;
+	if (!isRecord(extent)) problems.push("extent must be an object");
+	else {
+		if (extent.kind !== expectedExtent) problems.push(`extent.kind must be "${expectedExtent}"`);
+		if (!Object.hasOwn(extent, "start") || extent.start === void 0) problems.push("extent.start is required");
+		if (expectedExtent === "bounded" && (!Object.hasOwn(extent, "end") || extent.end === void 0)) problems.push("extent.end is required for bounded sequences");
+		if (expectedExtent === "unbounded" && Object.hasOwn(extent, "end")) problems.push("extent.end is forbidden for unbounded sequences");
+	}
+	if (value.sampling !== expectedSampling) problems.push(`sampling must be "${expectedSampling}"`);
+	if (!Object.hasOwn(value, "coordinateSpace") || value.coordinateSpace === void 0) problems.push("coordinateSpace is required");
+}
+function validateMarkerPayload(value, problems) {
+	validateRange(value.sourceRange, "sourceRange", true, problems);
+	if (Object.hasOwn(value, "targetRange") && value.targetRange !== void 0) validateRange(value.targetRange, "targetRange", true, problems);
+	const duration = value.duration;
+	if (!isRecord(duration)) problems.push("duration must be an object");
+	else if (duration.mode === "fixed") {
+		if (!Object.hasOwn(duration, "value") || duration.value === void 0) problems.push("duration.value is required when duration.mode is \"fixed\"");
+	} else if (duration.mode !== "from-source") problems.push("duration.mode must be \"from-source\" or \"fixed\"");
+	if (value.anchorOffset === void 0 && Object.hasOwn(value, "anchorOffset")) problems.push("anchorOffset cannot be undefined when present");
+	if (value.durationPolicy !== void 0 && value.durationPolicy !== "timeline") problems.push("durationPolicy must be \"timeline\" when present");
+	if (value.segmentRanges !== void 0) validateSegmentRanges(value.segmentRanges, problems);
+}
+/** Annotation Marker time values are directly assigned facts; no cross-references are allowed. */
+function validateSegmentRanges(value, problems) {
+	if (!Array.isArray(value)) {
+		problems.push("segmentRanges must be an array when present");
+		return;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const [index, entry] of value.entries()) {
+		if (!isRecord(entry)) {
+			problems.push(`segmentRanges[${index}] must be an object`);
+			continue;
+		}
+		if (typeof entry.segmentId !== "string") problems.push(`segmentRanges[${index}].segmentId must be a string`);
+		else if (seen.has(entry.segmentId)) problems.push(`segmentRanges[${index}].segmentId must be unique within the Marker`);
+		else seen.add(entry.segmentId);
+		for (const key of ["startMs", "endMs"]) {
+			const point = entry[key];
+			if (typeof point !== "number" || !Number.isFinite(point)) problems.push(`segmentRanges[${index}].${key} must be a finite number`);
+		}
+		if (typeof entry.startMs === "number" && Number.isFinite(entry.startMs) && typeof entry.endMs === "number" && Number.isFinite(entry.endMs) && entry.startMs > entry.endMs) problems.push(`segmentRanges[${index}].startMs must not exceed segmentRanges[${index}].endMs`);
+	}
+}
+function validateAssetPayload(value, problems) {
+	validateExternalLocator(value, problems);
+	validateStorageKey(value, problems);
+	if (value.inline !== void 0) problems.push("inline is not a physical location; text is domain content owned by its AudioScript");
+}
+/**
+* Media variants own their Asset locator directly: `external` is required and
+* textual domain content is owned by AudioScript; the physical-location
+* vocabularies cannot mix.
+*/
+function validateMediaAssetFields(value, problems) {
+	if (value.external === void 0) problems.push("external is required; media variants own their Asset identity");
+	else validateExternalLocator(value, problems);
+	validateStorageKey(value, problems);
+	if (value.inline !== void 0) problems.push("media variants use external locators, not inline domain text");
+}
+function validateExternalLocator(value, problems) {
+	const external = value.external;
+	if (external === void 0) return;
+	if (!isRecord(external)) {
+		problems.push("external must be an object when present");
+		return;
+	}
+	if (external.system !== "memota" && external.system !== "memota-speech") problems.push("external.system must be \"memota\" or \"memota-speech\"");
+	if (typeof external.key !== "string" || external.key.trim() === "") problems.push("external.key must be a non-empty string");
+}
+function validateStorageKey(value, problems) {
+	if (value.storageKey !== void 0 && (typeof value.storageKey !== "string" || value.storageKey.trim() === "")) problems.push("storageKey must be a non-empty string when present");
+}
+function validateVoicePayload(value, problems) {
+	const voice = value.voice;
+	if (voice === void 0) return;
+	if (!isRecord(voice)) {
+		problems.push("voice must be an object when present");
+		return;
+	}
+	if (voice.system !== "voice-library") problems.push("voice.system must be \"voice-library\"");
+	if (typeof voice.key !== "string" || voice.key.trim() === "") problems.push("voice.key must be a non-empty string");
+	if (voice.name !== void 0 && typeof voice.name !== "string") problems.push("voice.name must be a string when present");
+}
+function validateCaptionPayload(value, problems) {
+	validateExternalLocator(value, problems);
+	if (value.segmentRanges !== void 0) validateSegmentRanges(value.segmentRanges, problems);
+	if (Object.hasOwn(value, "selections")) problems.push("selections is forbidden; Caption requires one selection object");
+	const selection = value.selection;
+	if (!isRecord(selection)) problems.push("selection must be one AudioScript segment selection object, not an array");
+	else {
+		if (typeof selection.segmentId !== "string" || !selection.segmentId.trim()) problems.push("selection.segmentId must be a non-empty string");
+		if (Object.keys(selection).some((key) => key !== "segmentId" && key !== "textRange")) problems.push("selection may only contain segmentId and textRange");
+		const range = selection.textRange;
+		if (range !== void 0 && (!isRecord(range) || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start || Object.keys(range).some((key) => key !== "start" && key !== "end"))) problems.push("selection.textRange must be a non-empty half-open code-point range");
+		if (Array.isArray(value.segmentRanges) && (value.segmentRanges.length !== 1 || !isRecord(value.segmentRanges[0]) || value.segmentRanges[0].segmentId !== selection.segmentId)) problems.push("Caption segmentRanges must contain only the selected segment timing");
+	}
+	const style = value.style;
+	if (style === void 0) return;
+	if (!isRecord(style)) {
+		problems.push("style must be an object when present");
+		return;
+	}
+	const font = style.font;
+	if (font !== void 0) if (!isRecord(font)) problems.push("style.font must be an object when present");
+	else {
+		if (font.system !== "font-library") problems.push("style.font.system must be \"font-library\"");
+		if (typeof font.key !== "string" || font.key.trim() === "") problems.push("style.font.key must be a non-empty string");
+	}
+	for (const key of [
+		"fontSize",
+		"fontWeight",
+		"entranceAnimationDurationMs",
+		"strokeWidth",
+		"positionX",
+		"positionY"
+	]) validateOptionalFiniteNumber(style, key, problems, `style.${key}`);
+	for (const key of [
+		"fontColor",
+		"entranceAnimation",
+		"strokeColor"
+	]) if (style[key] !== void 0 && typeof style[key] !== "string") problems.push(`style.${key} must be a string`);
+}
+function validateRange(value, path, required, problems) {
+	if (!isRecord(value)) {
+		if (required) problems.push(`${path} must be an object`);
+		return;
+	}
+	if (!Object.hasOwn(value, "start") || value.start === void 0) problems.push(`${path}.start is required`);
+	if (!Object.hasOwn(value, "end") || value.end === void 0) problems.push(`${path}.end is required`);
+}
+/** Phonetic variants store pronunciation fields only; base text stays in the AudioScript. */
+function validatePhoneticScriptPayload(value, problems) {
+	if (value.segments !== void 0) validateScriptPayload(value, problems);
+	if (value.phonemeScript !== void 0 && (typeof value.phonemeScript !== "string" || value.phonemeScript.trim() === "")) problems.push("phonemeScript must be a non-empty string when present");
+	if (value.prosody !== void 0 && !isRecord(value.prosody)) problems.push("prosody must be an object when present");
+}
+function validateScriptPayload(value, problems) {
+	if (!Array.isArray(value.segments)) {
+		problems.push("segments must be an array");
+		return;
+	}
+	for (const [index, segment] of value.segments.entries()) {
+		if (!isRecord(segment)) {
+			problems.push(`segments[${index}] must be an object`);
+			continue;
+		}
+		for (const key of [
+			"startMs",
+			"endMs",
+			"start_ms",
+			"end_ms",
+			"sourceRange",
+			"targetRange",
+			"duration"
+		]) if (Object.hasOwn(segment, key)) problems.push(`segments[${index}].${key} is timing; attach an AudioScript annotation Marker instead`);
+		if (typeof segment.segmentId !== "string") problems.push(`segments[${index}].segmentId must be a string`);
+		if (typeof segment.text !== "string") problems.push(`segments[${index}].text must be a string`);
+		if (segment.language !== void 0 && typeof segment.language !== "string") problems.push(`segments[${index}].language must be a string when present`);
+	}
+}
+function validateOptionalField(value, key, expectedType, problems) {
+	if (value[key] !== void 0 && typeof value[key] !== expectedType) problems.push(`${key} must be a ${expectedType} when present`);
+}
+function validateOptionalFiniteNumber(value, key, problems, label = key) {
+	if (value[key] !== void 0 && (typeof value[key] !== "number" || !Number.isFinite(value[key]))) problems.push(`${label} must be a finite number when present`);
+}
+function collectPeerEntityIdPaths(value, entityKind) {
+	const paths = [];
+	visitPeerEntityIdPaths(value, entityKind, "", /* @__PURE__ */ new Set(), paths);
+	return paths;
+}
+function visitPeerEntityIdPaths(value, entityKind, parentPath, ancestors, paths) {
+	if (typeof value !== "object" || value == null) return;
+	if (ancestors.has(value)) return;
+	ancestors.add(value);
+	if (Array.isArray(value)) for (const [index, item] of value.entries()) visitPeerEntityIdPaths(item, entityKind, `${parentPath}[${index}]`, ancestors, paths);
+	else for (const [key, child] of Object.entries(value)) {
+		const path = parentPath.length === 0 ? key : `${parentPath}.${key}`;
+		if (parentPath.length === 0 && key === "baseEntityIds") continue;
+		if (!(parentPath.length === 0 && key === "entityId") && !isOwnedLocalIdPath(entityKind, path) && isEntityIdFieldName(key)) paths.push(path);
+		visitPeerEntityIdPaths(child, entityKind, path, ancestors, paths);
+	}
+	ancestors.delete(value);
+}
+function collectPeerEntityValuePaths(value, entityKind, ownEntityId, entityIds) {
+	const paths = [];
+	visitPeerEntityValues(value, entityKind, ownEntityId, entityIds, "", /* @__PURE__ */ new Set(), paths);
+	return paths;
+}
+function visitPeerEntityValues(value, entityKind, ownEntityId, entityIds, path, ancestors, paths) {
+	if (typeof value === "string") {
+		if (value !== ownEntityId && entityIds.has(value) && !isOwnedLocalEntityValuePath(entityKind, path)) paths.push(path);
+		return;
+	}
+	if (typeof value !== "object" || value == null || ancestors.has(value)) return;
+	ancestors.add(value);
+	if (Array.isArray(value)) for (const [index, item] of value.entries()) visitPeerEntityValues(item, entityKind, ownEntityId, entityIds, `${path}[${index}]`, ancestors, paths);
+	else for (const [key, child] of Object.entries(value)) {
+		if (path.length === 0 && (key === "entityId" || key === "entityKind" || key === "baseEntityIds")) continue;
+		visitPeerEntityValues(child, entityKind, ownEntityId, entityIds, path.length === 0 ? key : `${path}.${key}`, ancestors, paths);
+	}
+	ancestors.delete(value);
+}
+function isOwnedLocalEntityValuePath(entityKind, path) {
+	if (entityKind === "track" && path === "role") return true;
+	if ([
+		"video",
+		"audio",
+		"voice",
+		"image",
+		"caption",
+		"axvideo"
+	].includes(entityKind) && /^(?:sampling|coordinateSpace|coordinateSpace\.unit|extent\.kind)$/.test(path)) return true;
+	if (entityKind === "sequence-marker" && /^(?:durationPolicy|duration\.mode|timeRemapping\.(?:kind|mode))$/.test(path)) return true;
+	if ((entityKind === "sequence-marker" || entityKind === "caption") && /^segmentRanges\[\d+\]\.segmentId$/.test(path)) return true;
+	if (entityKind === "asset" && /^(?:external\.(?:system|key)|storageKey)$/.test(path)) return true;
+	if (isMediaAssetVariantKind(entityKind) && /^(?:external\.(?:system|key)|storageKey)$/.test(path)) return true;
+	if (entityKind === "voice" && /^voice\.(?:system|key|name)$/.test(path)) return true;
+	if (entityKind === "caption" && (path.startsWith("style.") || path === "selection.segmentId")) return true;
+	if ([
+		"audio-script",
+		"caption",
+		"phonetic-script"
+	].includes(entityKind) && /^segments\[\d+\]\.(?:segmentId|text|language)$/.test(path)) return true;
+	return false;
+}
+function isOwnedLocalIdPath(entityKind, path) {
+	if (path === "lifecycle.actorId") return true;
+	if ([
+		"audio-script",
+		"caption",
+		"phonetic-script"
+	].includes(entityKind) && /^segments\[\d+\]\.segmentId$/.test(path)) return true;
+	if (entityKind === "caption" && path === "selection.segmentId") return true;
+	if ((entityKind === "sequence-marker" || entityKind === "caption") && /^segmentRanges\[\d+\]\.segmentId$/.test(path)) return true;
+	if (entityKind === "asset" && /^(?:tracks\[\d+\]\.trackId|renditions\[\d+\]\.renditionId)$/.test(path)) return true;
+	return false;
+}
+function isEntityIdFieldName(key) {
+	return key.endsWith("Id") || key.endsWith("Ids") || key.endsWith("ID") || key.endsWith("IDs") || /_ids?$/i.test(key);
+}
+function isRecord(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function collectRelatedEntities(entityRefs, index) {
+	const byId = /* @__PURE__ */ new Map();
+	const queue = [...entityRefs];
+	const issues = [];
+	while (queue.length > 0) {
+		const entity = queue.shift();
+		if (entity == null) continue;
+		const existing = byId.get(entity.entityId);
+		if (existing != null) {
+			if (existing !== entity) issues.push({
+				code: "duplicate_entity_id",
+				entityId: entity.entityId,
+				message: `Entity id "${entity.entityId}" has more than one live EntityRef`
+			});
+			continue;
+		}
+		byId.set(entity.entityId, entity);
+		for (const relation of index.relationsOf(entity)) for (const endpoint of relation.endpoints) {
+			const ref = endpoint.deref();
+			if (ref != null && !byId.has(ref.entityId)) queue.push(ref);
+		}
+	}
+	return {
+		entities: [...byId.values()],
+		issues
+	};
+}
+function expectedSequenceShape(kind) {
+	if (kind === "video" || kind === "audio" || kind === "voice" || kind === "caption") return {
+		extent: "bounded",
+		sampling: "native"
+	};
+	if (kind === "image") return {
+		extent: "unbounded",
+		sampling: "constant"
+	};
+	if (kind === "axvideo") return {
+		extent: "bounded",
+		sampling: "derived"
+	};
+}
+function ofKind(relations, kind) {
+	return relations.filter((relation) => relation.kind === kind);
+}
+//#endregion
+//#region ../medeo-dsl/src/relation-specs.ts
+const timelineTrackRelationSpec = emptySpec("timeline-track", "timeline", "track");
+const trackClipRelationSpec = emptySpec("track-clip", "track", "clip");
+const clipMarkerRelationSpec = emptySpec("clip-marker", "clip", "sequence-marker");
+const axVideoMarkerRelationSpec = emptySpec("axvideo-marker", "axvideo", "sequence-marker");
+const markerTimelineRelationSpec = emptySpec("marker-timeline", "sequence-marker", "timeline");
+const markerContentRelationSpec = Object.freeze({
+	kind: "marker-content",
+	validateEndpoints: (endpoints) => hasMarkerAndSequence(endpoints),
+	validateMetadata: isEmptyMetadata
+});
+const physicalAssetRelationSpec = Object.freeze({
+	kind: "physical-asset",
+	validateEndpoints: (endpoints) => hasAssetAndSequence(endpoints),
+	validateMetadata: isAssetBinding
+});
+/** `generated(output, input)` means endpoint 0 was generated from endpoint 1. */
+const generatedRelationSpec = Object.freeze({
+	kind: "generated",
+	validateEndpoints: (endpoints) => endpoints.every((endpoint) => isGeneratedMedia(endpoint.current())),
+	validateMetadata: isEmptyMetadata
+});
+const captionAlignmentRelationSpec = Object.freeze({
+	kind: "caption-alignment",
+	validateEndpoints: (endpoints) => hasKinds(endpoints, new Set(["caption"]), new Set(["audio", "voice"])),
+	validateMetadata: isCaptionAlignmentMetadata
+});
+/** `clip-anchor(child, host)` means endpoint 0 follows endpoint 1. */
+const clipAnchorRelationSpec = Object.freeze({
+	kind: "clip-anchor",
+	validateEndpoints: (endpoints) => endpoints[0].current().entityKind === "clip" && endpoints[1].current().entityKind === "clip",
+	validateMetadata: isEmptyMetadata
+});
+/** Voice is generated from PhoneticScript; kinds determine roles regardless of endpoint positions. */
+const phoneticScriptRenderRelationSpec = Object.freeze({
+	kind: "phonetic-script-render",
+	validateEndpoints: (endpoints) => hasKinds(endpoints, new Set(["voice"]), new Set(["phonetic-script"])),
+	validateMetadata: isEmptyMetadata
+});
+/** AudioScript was transcribed from Audio, Video, or recorded Voice; kinds determine roles. */
+const audioScriptSourceRelationSpec = Object.freeze({
+	kind: "audio-script-source",
+	validateEndpoints: (endpoints) => hasKinds(endpoints, new Set(["audio-script"]), new Set([
+		"audio",
+		"video",
+		"voice"
+	])),
+	validateMetadata: isEmptyMetadata
+});
+/**
+* `audio-script-marker(script, marker)` attaches an annotation Sequence Marker
+* whose `segmentRanges` hold directly assigned per-Segment time values. The
+* script keeps no Sequence and no Clip admission; annotation Markers cannot
+* enter Clip/AXVideo use chains (enforced by the marker-use invariant).
+*/
+const audioScriptMarkerRelationSpec = Object.freeze({
+	kind: "audio-script-marker",
+	validateEndpoints: (endpoints) => hasKinds(endpoints, new Set(["audio-script"]), new Set(["sequence-marker"])),
+	validateMetadata: isEmptyMetadata
+});
+/** Built-in kinds are reserved; callers may add specs only under new names. */
+const builtInRelationSpecs = Object.freeze([
+	timelineTrackRelationSpec,
+	trackClipRelationSpec,
+	clipMarkerRelationSpec,
+	markerContentRelationSpec,
+	axVideoMarkerRelationSpec,
+	markerTimelineRelationSpec,
+	physicalAssetRelationSpec,
+	generatedRelationSpec,
+	captionAlignmentRelationSpec,
+	clipAnchorRelationSpec,
+	phoneticScriptRenderRelationSpec,
+	audioScriptSourceRelationSpec,
+	audioScriptMarkerRelationSpec
+]);
+function emptySpec(kind, a, b) {
+	return metadataSpec(kind, a, b, isEmptyMetadata);
+}
+function metadataSpec(kind, a, b, validateMetadata) {
+	return Object.freeze({
+		kind,
+		validateEndpoints: (endpoints) => hasKinds(endpoints, new Set([a]), new Set([b])),
+		validateMetadata
+	});
+}
+function hasKinds(endpoints, aKinds, bKinds) {
+	const first = endpoints[0].current().entityKind;
+	const second = endpoints[1].current().entityKind;
+	return aKinds.has(first) && bKinds.has(second) || aKinds.has(second) && bKinds.has(first);
+}
+function hasMarkerAndSequence(endpoints) {
+	const first = endpoints[0].current();
+	const second = endpoints[1].current();
+	return first.entityKind === "sequence-marker" && hasSequence(second) || second.entityKind === "sequence-marker" && hasSequence(first);
+}
+function hasAssetAndSequence(endpoints) {
+	const first = endpoints[0].current();
+	const second = endpoints[1].current();
+	return first.entityKind === "asset" && hasSequence(second) || second.entityKind === "asset" && hasSequence(first);
+}
+function isGeneratedMedia(entity) {
+	return entity.entityKind === "video" || entity.entityKind === "image" || entity.entityKind === "audio" || entity.entityKind === "voice";
+}
+function isEmptyMetadata(value) {
+	return isJsonObject(value) && Object.keys(value).length === 0;
+}
+function isAssetBinding(value) {
+	if (!isJsonObject(value)) return false;
+	const orderingKey = /(order|ordinal|position|rank|index|z[_-]?index)/i;
+	return Object.keys(value).every((key) => !orderingKey.test(key));
+}
+function isCaptionAlignmentMetadata(value) {
+	return isJsonObject(value) && Object.hasOwn(value, "alignment");
+}
+//#endregion
+//#region ../medeo-dsl/src/relations.ts
+function createEntityRef(entity) {
+	return {
+		entityId: entity.entityId,
+		current: () => entity
+	};
+}
+//#endregion
+//#region ../medeo-dsl/src/relation-index.ts
+var RelationEdge = class {
+	relationId;
+	kind;
+	metadata;
+	trace;
+	endpoints;
+	constructor(relationId, kind, endpoints, metadata, trace) {
+		this.relationId = relationId;
+		this.kind = kind;
+		this.metadata = metadata;
+		this.trace = trace;
+		this.endpoints = [new WeakRef(endpoints[0]), new WeakRef(endpoints[1])];
+	}
+	other(entity) {
+		const first = this.endpoints[0].deref();
+		const second = this.endpoints[1].deref();
+		if (first === entity) return this.endpoints[1];
+		if (second === entity) return this.endpoints[0];
+	}
+	toRow() {
+		const first = this.endpoints[0].deref();
+		const second = this.endpoints[1].deref();
+		if (first == null || second == null) return void 0;
+		return {
+			relationId: this.relationId,
+			endpoint0EntityId: first.entityId,
+			endpoint1EntityId: second.entityId,
+			relationKind: this.kind,
+			metadata: this.metadata,
+			trace: this.trace
+		};
+	}
+	isStale() {
+		return this.endpoints[0].deref() == null || this.endpoints[1].deref() == null;
+	}
+};
+/** Endpoint-agnostic secondary index. Relation rows remain the persistence authority. */
+var BiRelationIndex = class {
+	byEntity = /* @__PURE__ */ new WeakMap();
+	canonicalRefs = /* @__PURE__ */ new Map();
+	byRelationId = /* @__PURE__ */ new Map();
+	link(input) {
+		if (input.spec.kind === "generated") throw new Error("Author generated Relations with linkGenerated({ output, input })");
+		if (input.spec.kind === "clip-anchor" || input.spec.kind === "phonetic-script-render" || input.spec.kind === "audio-script-source") throw new Error(`Author ordered ${input.spec.kind} Relations with the dedicated role-named method`);
+		return this.linkValidated(input);
+	}
+	/** Author `generated(output, input)` without exposing positional arguments. */
+	linkGenerated(input) {
+		return this.linkValidated({
+			relationId: input.relationId,
+			spec: generatedRelationSpec,
+			endpoints: [input.output, input.input],
+			metadata: {},
+			trace: input.trace
+		});
+	}
+	/** Author `clip-anchor(child, host)` without exposing positional arguments. */
+	linkClipAnchor(input) {
+		return this.linkValidated({
+			relationId: input.relationId,
+			spec: clipAnchorRelationSpec,
+			endpoints: [input.child, input.host],
+			metadata: {},
+			trace: input.trace
+		});
+	}
+	/** Author `phonetic-script-render(output, phoneticScript)` without exposing positional arguments. */
+	linkPhoneticScriptRender(input) {
+		return this.linkValidated({
+			relationId: input.relationId,
+			spec: phoneticScriptRenderRelationSpec,
+			endpoints: [input.output, input.phoneticScript],
+			metadata: {},
+			trace: input.trace
+		});
+	}
+	/** Author `audio-script-source(script, source)` without exposing positional arguments. */
+	linkAudioScriptSource(input) {
+		return this.linkValidated({
+			relationId: input.relationId,
+			spec: audioScriptSourceRelationSpec,
+			endpoints: [input.script, input.source],
+			metadata: {},
+			trace: input.trace
+		});
+	}
+	/**
+	* Rehydrate a persisted row after resolving its spec and endpoint refs.
+	*
+	* This is a storage-boundary escape hatch, not an authoring API: persisted
+	* positions already are the semantic assertion made by their relation kind.
+	*/
+	linkRuntime(input) {
+		return this.linkValidated(input);
+	}
+	linkValidated(input) {
+		const [first, second] = input.endpoints;
+		if (first.entityId === second.entityId) throw new Error("A Relation cannot connect an entity to itself");
+		this.assertRelationIdAvailable(input.relationId);
+		const builtInSpec = builtInSpecByKind.get(input.spec.kind);
+		if (builtInSpec != null && builtInSpec !== input.spec) throw new Error(`Relation kind "${input.spec.kind}" must use its built-in specification`);
+		if (isForbiddenAuthoritativeRelation(input.spec.kind, input.endpoints)) throw new Error("A direct Clip-Content Relation is derived-only and cannot be authoritative");
+		if (!input.spec.validateEndpoints(input.endpoints)) throw new Error(`Relation "${input.spec.kind}" received invalid endpoints`);
+		if (!input.spec.validateMetadata(input.metadata)) throw new Error(`Relation "${input.spec.kind}" received invalid metadata`);
+		this.assertCanonicalRefAvailable(first);
+		this.assertCanonicalRefAvailable(second);
+		const relation = new RelationEdge(input.relationId, input.spec.kind, input.endpoints, input.metadata, input.trace ?? {});
+		this.rememberCanonicalRef(first);
+		this.rememberCanonicalRef(second);
+		this.add(first, relation);
+		this.add(second, relation);
+		this.byRelationId.set(input.relationId, new WeakRef(relation));
+		return relation;
+	}
+	relationsOf(entity) {
+		this.registerCanonicalRef(entity);
+		const relations = this.byEntity.get(entity);
+		if (relations == null) return /* @__PURE__ */ new Set();
+		for (const relation of relations) if (relation instanceof RelationEdge && relation.isStale()) this.unlink(relation);
+		return new Set(relations);
+	}
+	unlink(relation) {
+		for (const endpoint of relation.endpoints) {
+			const ref = endpoint.deref();
+			if (ref != null) this.byEntity.get(ref)?.delete(relation);
+		}
+		if (this.byRelationId.get(relation.relationId)?.deref() === relation) this.byRelationId.delete(relation.relationId);
+	}
+	add(entity, relation) {
+		const relations = this.byEntity.get(entity) ?? /* @__PURE__ */ new Set();
+		relations.add(relation);
+		this.byEntity.set(entity, relations);
+	}
+	registerCanonicalRef(entity) {
+		this.assertCanonicalRefAvailable(entity);
+		this.rememberCanonicalRef(entity);
+	}
+	assertCanonicalRefAvailable(entity) {
+		const existing = this.canonicalRefs.get(entity.entityId)?.deref();
+		if (existing != null && existing !== entity) throw new Error(`Entity "${entity.entityId}" already has a live canonical EntityRef`);
+	}
+	rememberCanonicalRef(entity) {
+		this.canonicalRefs.set(entity.entityId, new WeakRef(entity));
+	}
+	assertRelationIdAvailable(relationId) {
+		if (this.byRelationId.get(relationId)?.deref() != null) throw new Error(`Relation id "${relationId}" already exists`);
+		this.byRelationId.delete(relationId);
+	}
+};
+const builtInSpecByKind = new Map(builtInRelationSpecs.map((spec) => [spec.kind, spec]));
+function isForbiddenAuthoritativeRelation(kind, endpoints) {
+	if (kind === "clip-content") return true;
+	const first = endpoints[0].current();
+	const second = endpoints[1].current();
+	return first.entityKind === "clip" && hasSequence(second) || second.entityKind === "clip" && hasSequence(first);
+}
+//#endregion
+//#region ../medeo-dsl/src/entity-relation-rows.ts
+var InvalidEntityRelationRowsError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(`Invalid Medeo entity/relation rows:\n- ${issues.join("\n- ")}`);
+		this.issues = issues;
+		this.name = "InvalidEntityRelationRowsError";
+	}
+};
+/** Decodes database rows into flat entities and validates the complete relation set. */
+function decodeEntityRelationRows(rows, options) {
+	const issues = [];
+	const entitiesById = /* @__PURE__ */ new Map();
+	const extensionEntityKinds = new Set(options.entityKinds ?? []);
+	for (const row of rows.entities) {
+		let entity = decodeEntityRow(row, extensionEntityKinds, issues);
+		if (entity != null) try {
+			entity = decodeEntityRow(assembleEntityContent(rows, row.entityId), extensionEntityKinds, issues);
+		} catch (error) {
+			issues.push(errorMessage(error));
+			continue;
+		}
+		if (entity == null) continue;
+		const ref = createEntityRef(entity);
+		if (entitiesById.has(ref.entityId)) {
+			issues.push(`duplicate entity id "${ref.entityId}"`);
+			continue;
+		}
+		entitiesById.set(ref.entityId, ref);
+	}
+	const specsByKind = collectRelationSpecs(options.relationSpecs ?? [], issues);
+	const relationIndex = new BiRelationIndex();
+	const relations = [];
+	const relationIds = /* @__PURE__ */ new Set();
+	for (const row of rows.relations) {
+		let relationId;
+		try {
+			relationId = createRelationId(row.relationId);
+		} catch (error) {
+			issues.push(errorMessage(error));
+			continue;
+		}
+		if (relationIds.has(relationId)) {
+			issues.push(`duplicate relation id "${relationId}"`);
+			continue;
+		}
+		relationIds.add(relationId);
+		if (!isTrimmedNonEmpty(row.relationKind)) {
+			issues.push(`relation "${relationId}" has an empty or untrimmed kind`);
+			continue;
+		}
+		const spec = specsByKind.get(row.relationKind);
+		if (spec == null) {
+			issues.push(`relation "${relationId}" has no registered spec for kind "${row.relationKind}"`);
+			continue;
+		}
+		let endpoint0EntityId;
+		let endpoint1EntityId;
+		try {
+			endpoint0EntityId = createEntityId(row.endpoint0EntityId);
+			endpoint1EntityId = createEntityId(row.endpoint1EntityId);
+		} catch (error) {
+			issues.push(errorMessage(error));
+			continue;
+		}
+		const endpoint0 = entitiesById.get(endpoint0EntityId);
+		const endpoint1 = entitiesById.get(endpoint1EntityId);
+		if (endpoint0 == null || endpoint1 == null) {
+			const missing = [endpoint0 == null ? endpoint0EntityId : void 0, endpoint1 == null ? endpoint1EntityId : void 0].filter((value) => value != null).join(", ");
+			issues.push(`relation "${relationId}" references missing entity id(s): ${missing}`);
+			continue;
+		}
+		if (!isJsonObject(row.metadata) || !isJsonObject(row.trace)) {
+			issues.push(`relation "${relationId}" metadata and trace must contain only JSON values`);
+			continue;
+		}
+		try {
+			relations.push(relationIndex.linkRuntime({
+				relationId,
+				spec,
+				endpoints: [endpoint0, endpoint1],
+				metadata: row.metadata,
+				trace: row.trace
+			}));
+		} catch (error) {
+			issues.push(errorMessage(error));
+		}
+	}
+	if (issues.length === 0) for (const issue of validateEntityRelationSet([...entitiesById.values()], relationIndex, options)) issues.push(`${issue.code}: ${issue.message}`);
+	if (issues.length > 0) throw new InvalidEntityRelationRowsError(issues);
+	return {
+		entitiesById,
+		relationIndex,
+		relations
+	};
+}
+function decodeEntityRow(row, extensionEntityKinds, issues) {
+	let entityId;
+	try {
+		entityId = createEntityId(row.entityId);
+	} catch (error) {
+		issues.push(errorMessage(error));
+		return;
+	}
+	if (!isTrimmedNonEmpty(row.entityKind)) {
+		issues.push(`entity "${entityId}" has an empty or untrimmed kind`);
+		return;
+	}
+	if (isReservedEntityKind(row.entityKind)) {
+		issues.push(`entity "${entityId}" uses reserved kind "${row.entityKind}"`);
+		return;
+	}
+	if (!isKnownEntityKind(row.entityKind) && !extensionEntityKinds.has(row.entityKind)) {
+		issues.push(`entity "${entityId}" has unregistered extension kind "${row.entityKind}"`);
+		return;
+	}
+	if (!isJsonObject(row.payload)) {
+		issues.push(`entity "${entityId}" payload must contain only JSON values`);
+		return;
+	}
+	const reserved = ["entityId", "entityKind"].filter((key) => Object.hasOwn(row.payload, key));
+	if (reserved.length > 0) {
+		issues.push(`entity "${entityId}" payload contains reserved field(s): ${reserved.join(", ")}`);
+		return;
+	}
+	return {
+		...row.payload,
+		entityId,
+		entityKind: row.entityKind
+	};
+}
+function collectRelationSpecs(extensionSpecs, issues) {
+	const specs = /* @__PURE__ */ new Map();
+	for (const spec of builtInRelationSpecs) specs.set(spec.kind, spec);
+	for (const spec of extensionSpecs) {
+		if (!isTrimmedNonEmpty(spec.kind)) {
+			issues.push("extension relation spec has an empty or untrimmed kind");
+			continue;
+		}
+		if (specs.has(spec.kind)) {
+			issues.push(`relation spec kind "${spec.kind}" is already registered`);
+			continue;
+		}
+		specs.set(spec.kind, spec);
+	}
+	return specs;
+}
+function isTrimmedNonEmpty(value) {
+	return value.length > 0 && value.trim() === value;
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/document/entity-projection-values.ts
+/** A graph cannot be represented faithfully by the compatibility reader. */
+var EntityTimelineProjectionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "EntityTimelineProjectionError";
+	}
+};
+function fail(message) {
+	throw new EntityTimelineProjectionError(message);
+}
+function object(value) {
+	return value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function finite(value, label) {
+	if (typeof value !== "number" || !Number.isFinite(value)) fail(`${label} must be finite`);
+	return value;
+}
+function positive(value, label) {
+	const result = finite(value, label);
+	if (result <= 0) fail(`${label} must be positive`);
+	return result;
+}
+function milliseconds(value, label) {
+	const result = finite(value, label);
+	if (!Number.isSafeInteger(result) || result < 0) fail(`${label} must be non-negative whole milliseconds`);
+	return result;
+}
+function range(value, label) {
+	if (!object(value)) fail(`${label} must be a numeric range`);
+	const start = finite(value.start, `${label}.start`);
+	const end = finite(value.end, `${label}.end`);
+	if (start >= end) fail(`${label} must be non-empty`);
+	return {
+		start,
+		end
+	};
+}
+//#endregion
+//#region src/document/entity-timeline-layout.ts
+/** Validated graph lookup shared by the compatibility layout and projection. */
+var EntityProjectionGraph = class {
+	rows;
+	entities;
+	timeline;
+	constructor(rows) {
+		this.rows = rows;
+		const decoded = decodeEntityRelationRows(rows, { compareMarkerPoints: (_marker, _range, left, right) => finite(left, "range point") - finite(right, "range point") });
+		this.entities = new Map([...decoded.entitiesById.values()].map((ref) => [String(ref.entityId), entityToRow(ref.current())]));
+		const roots = [...this.entities.values()].filter((row) => row.entityKind === "timeline");
+		if (roots.length !== 1) fail("compatibility projection requires exactly one Timeline");
+		this.timeline = roots[0];
+	}
+	entity(id, kind) {
+		const row = this.entities.get(id);
+		if (row === void 0 || kind !== void 0 && row.entityKind !== kind) fail(`Expected ${kind ?? "Entity"} ${id}`);
+		return row;
+	}
+	adjacent(id, kind) {
+		return [...new Set(this.rows.relations.filter((row) => row.relationKind === kind && (row.endpoint0EntityId === id || row.endpoint1EntityId === id)).map((row) => row.endpoint0EntityId === id ? row.endpoint1EntityId : row.endpoint0EntityId))].map((entityId) => this.entity(entityId));
+	}
+	one(id, relation, kind) {
+		const values = this.adjacent(id, relation);
+		if (values.length !== 1 || kind !== void 0 && values[0]?.entityKind !== kind) fail(`entity ${id} requires exactly one ${relation}${kind === void 0 ? "" : ` to ${kind}`}`);
+		return values[0];
+	}
+};
+const roleOrder = {
+	caption: 0,
+	video_clip: 1,
+	speech: 2,
+	bgm: 3
+};
+/**
+* Resolve only entity-owned placement facts. This does not choose new anchors,
+* manufacture clips, or mutate a graph while reading. Write-side operations
+* must express any detach/reparent/overlap decision in their entity plan.
+*/
+function resolveEntityTimelineLayout(rows) {
+	return resolveGraphLayout(new EntityProjectionGraph(rows));
+}
+function resolveGraphLayout(graph) {
+	const facts = /* @__PURE__ */ new Map();
+	const seenRoles = /* @__PURE__ */ new Set();
+	const tracks = graph.adjacent(graph.timeline.entityId, "timeline-track").map((track) => {
+		const role = track.payload.role;
+		if (track.entityKind !== "track" || typeof role !== "string" || !Object.hasOwn(roleOrder, role)) fail(`unsupported compatibility Track role on ${track.entityId}`);
+		if (seenRoles.has(role)) fail(`The compatibility editor supports only one ${role} Track`);
+		seenRoles.add(role);
+		const typedRole = role;
+		if (track.payload.hidden !== void 0 && typeof track.payload.hidden !== "boolean") fail("Track hidden must be boolean");
+		const order = track.payload.order === void 0 ? roleOrder[typedRole] : finite(track.payload.order, "Track order");
+		const trackFacts = graph.adjacent(track.entityId, "track-clip").map((clip) => {
+			if (clip.entityKind !== "clip" || graph.adjacent(clip.entityId, "track-clip").length !== 1) fail(`Clip ${clip.entityId} must belong to exactly one Track`);
+			const marker = graph.one(clip.entityId, "clip-marker", "sequence-marker");
+			const content = graph.one(marker.entityId, "marker-content");
+			if (!(typedRole === "video_clip" ? ["image", "video"] : typedRole === "speech" ? ["voice"] : typedRole === "caption" ? ["caption"] : ["audio"]).includes(content.entityKind)) fail(`unsupported compatibility content kind ${content.entityKind} on ${typedRole} Track`);
+			const space = content.payload.coordinateSpace;
+			if (space !== "ms" && space !== "milliseconds" && (!object(space) || space.unit !== "ms" && space.unit !== "milliseconds")) fail(`media ${content.entityId} must state millisecond coordinates for this reader`);
+			const source = range(marker.payload.sourceRange, "sourceRange");
+			const durationFact = marker.payload.duration;
+			if (!object(durationFact)) fail(`Marker ${marker.entityId} requires duration`);
+			const duration = positive(durationFact.mode === "from-source" ? source.end - source.start : durationFact.value, "duration");
+			if (!Number.isSafeInteger(duration)) fail("Compatibility duration must be whole milliseconds");
+			const fillTimeline = marker.payload.durationPolicy === "timeline";
+			if (marker.payload.durationPolicy !== void 0 && (!fillTimeline || typedRole !== "bgm")) fail("durationPolicy is only supported for timeline-filling background Audio");
+			const anchors = graph.rows.relations.filter((row) => row.relationKind === "clip-anchor" && row.endpoint0EntityId === clip.entityId);
+			if (anchors.length > 1) fail(`Clip ${clip.entityId} has multiple anchors`);
+			const target = marker.payload.targetRange === void 0 ? void 0 : range(marker.payload.targetRange, "targetRange");
+			const anchorId = anchors[0]?.endpoint1EntityId;
+			let mode;
+			let absoluteStart;
+			let anchorOffset;
+			let clipOrder;
+			if (anchorId !== void 0) {
+				if (target !== void 0) fail(`Anchored Marker ${marker.entityId} cannot also have targetRange`);
+				mode = "anchored";
+				anchorOffset = milliseconds(marker.payload.anchorOffset, "anchorOffset");
+			} else {
+				if (marker.payload.anchorOffset !== void 0) fail(`Marker ${marker.entityId} has anchorOffset without a clip-anchor Relation`);
+				if (target !== void 0) {
+					mode = "absolute";
+					absoluteStart = milliseconds(target.start, "target start");
+					milliseconds(target.end, "target end");
+					if (Math.abs(target.end - target.start - duration) > 1e-6) fail(`Marker ${marker.entityId} targetRange must match its effective duration`);
+				} else {
+					mode = "sequential";
+					if (clip.payload.order === void 0) fail(`Clip ${clip.entityId} has no placement: targetRange or explicit order is required`);
+					clipOrder = finite(clip.payload.order, "Clip order");
+				}
+			}
+			const fact = {
+				clip,
+				marker,
+				content,
+				trackId: track.entityId,
+				role: typedRole,
+				duration,
+				mode,
+				order: clipOrder,
+				absoluteStart,
+				anchorId,
+				anchorOffset,
+				fillTimeline
+			};
+			facts.set(clip.entityId, fact);
+			return fact;
+		});
+		if (typedRole === "bgm" && trackFacts.length > 1) fail("The compatibility editor supports only one background Audio Clip");
+		const sequential = trackFacts.filter((fact) => fact.mode === "sequential").sort((left, right) => left.order - right.order);
+		if (new Set(sequential.map((fact) => fact.order)).size !== sequential.length) fail("sequential Clips must have distinct order values");
+		sequential.forEach((fact, index) => {
+			fact.predecessor = sequential[index - 1]?.clip.entityId;
+		});
+		return {
+			entityId: String(track.entityId),
+			role: typedRole,
+			order,
+			hidden: track.payload.hidden === true,
+			trackFacts
+		};
+	});
+	tracks.sort((left, right) => left.order - right.order || left.entityId.localeCompare(right.entityId));
+	const resolved = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	const resolve = (id) => {
+		const cached = resolved.get(id);
+		if (cached !== void 0) return cached;
+		if (visiting.has(id)) fail(`Cyclic Clip placement dependency at ${id}`);
+		visiting.add(id);
+		const fact = facts.get(id);
+		if (fact === void 0) fail(`Placement refers to unplaced Clip ${id}`);
+		let start = fact.absoluteStart ?? 0;
+		if (fact.mode === "anchored") {
+			const host = resolve(fact.anchorId);
+			if (fact.role === "speech" && !["video_clip", "bgm"].includes(facts.get(host.clipEntityId).role)) fail("An anchored Voice must use a visual or BGM Clip as its host");
+			start = host.start + fact.anchorOffset;
+		} else if (fact.predecessor !== void 0) {
+			const prior = resolve(fact.predecessor);
+			start = prior.start + prior.duration;
+		}
+		milliseconds(start + fact.duration, "Clip end");
+		const result = {
+			clipEntityId: id,
+			markerEntityId: fact.marker.entityId,
+			contentEntityId: fact.content.entityId,
+			trackEntityId: fact.trackId,
+			start: milliseconds(start, "Clip start"),
+			duration: fact.duration,
+			mode: fact.mode,
+			...fact.anchorId === void 0 ? {} : {
+				anchorClipEntityId: fact.anchorId,
+				anchorOffset: fact.anchorOffset
+			}
+		};
+		visiting.delete(id);
+		resolved.set(id, result);
+		return result;
+	};
+	for (const id of facts.keys()) resolve(id);
+	const durationMs = Math.max(0, ...[...resolved.values()].filter((clip) => facts.get(clip.clipEntityId).role !== "bgm").map((clip) => clip.start + clip.duration));
+	for (const [id, fact] of facts) if (fact.fillTimeline) {
+		const clip = resolved.get(id);
+		resolved.set(id, {
+			...clip,
+			duration: durationMs
+		});
+	}
+	return {
+		durationMs,
+		clips: resolved,
+		tracks: tracks.map(({ trackFacts, ...track }) => ({
+			...track,
+			clips: trackFacts.map((fact) => resolved.get(fact.clip.entityId)).sort((left, right) => left.start - right.start || left.clipEntityId.localeCompare(right.clipEntityId))
+		}))
+	};
+}
+//#endregion
+//#region src/document/entity-projection.ts
+/**
+* One-way compatibility view over the Entity graph. A legacy part is never
+* consulted as an editing fact. Peer IDs appear only in this derived read
+* contract, reconstructed from relations; they are not stored in payloads.
+*/
+function projectEntityTimeline(rows, meta) {
+	const graph = new EntityProjectionGraph(rows);
+	const layout = resolveGraphLayout(graph);
+	for (const track of layout.tracks) {
+		if (track.role !== "video_clip") continue;
+		for (let index = 1; index < track.clips.length; index += 1) {
+			const previous = track.clips[index - 1];
+			if (track.clips[index].start < previous.start + previous.duration) fail("Overlapping visual Clips require an explicit overlay adapter; the current editor supports one visual lane");
+		}
+	}
+	const parts = {};
+	for (const track of layout.tracks) for (const placement of track.clips) {
+		const clip = graph.entity(placement.clipEntityId, "clip");
+		const marker = graph.entity(placement.markerEntityId, "sequence-marker");
+		const content = graph.entity(placement.contentEntityId);
+		const volume = volumeSchema.safeParse(clip.payload.volume ?? 0);
+		if (!volume.success) fail("Clip volume must be decibels between -60 and 20");
+		if (track.role === "video_clip") {
+			const asset = mediaAssetFacts(graph, content);
+			const source = range(marker.payload.sourceRange, "sourceRange");
+			const external = externalLocator(asset, "memota");
+			const speed = videoSpeed(content, marker, placement);
+			parts[clip.entityId] = { video_clip: {
+				id: clip.entityId,
+				kind: "video_clip",
+				origin_media_id: external.key,
+				play_in: content.entityKind === "image" && speed === void 0 ? 0 : source.start,
+				play_out: content.entityKind === "image" && speed === void 0 ? placement.duration : source.end,
+				volume: volume.data,
+				...speed === void 0 ? {} : { speed_shift: speed }
+			} };
+		} else if (track.role === "speech") {
+			const asset = mediaAssetFacts(graph, content);
+			requireUntrimmedAudio(content, marker, placement);
+			const external = externalLocator(asset, "memota-speech");
+			const assembled = graph.adjacent(content.entityId, "phonetic-script-render").length > 0 || content.payload.voice !== void 0 ? assemblePhoneticScriptContent(rows, graph.one(content.entityId, "phonetic-script-render", "phonetic-script").entityId) : void 0;
+			const voice = content.payload.voice;
+			if (voice !== void 0 && (!object(voice) || voice.system !== "voice-library" || typeof voice.key !== "string")) fail("Voice must use an explicit voice-library locator");
+			const captionIds = layout.tracks.flatMap((candidate) => candidate.role === "caption" ? candidate.clips.filter((caption) => caption.anchorClipEntityId === clip.entityId).map((caption) => caption.clipEntityId) : []);
+			parts[clip.entityId] = { speech: {
+				id: clip.entityId,
+				kind: "speech",
+				media_duration_ms: placement.duration,
+				audio_storage_key: storageKey(asset),
+				origin_speech_id: external.key,
+				audio_script: assembled?.text ?? (graph.adjacent(content.entityId, "audio-script-source").length > 0 ? assembleScriptText(graph.one(content.entityId, "audio-script-source", "audio-script")) : ""),
+				volume: volume.data,
+				voice: object(voice) ? {
+					id: typeof voice.key === "string" ? voice.key : void 0,
+					name: typeof voice.name === "string" ? voice.name : void 0
+				} : void 0,
+				caption_ids: captionIds
+			} };
+		} else if (track.role === "caption") {
+			const assembled = assembleCaptionContent(rows, content.entityId);
+			const text = assembled.text;
+			const cues = captionDisplayCues(assembled, marker, placement.duration);
+			if (marker.payload.timeRemapping !== void 0) fail("Caption timeRemapping is not supported by this reader");
+			const style = captionStyle(content.payload.style);
+			const anchor = placement.anchorClipEntityId === void 0 ? void 0 : layout.clips.get(placement.anchorClipEntityId);
+			const anchoredToSpeech = anchor !== void 0 && trackRoleOf(layout, anchor.trackEntityId) === "speech";
+			parts[clip.entityId] = { caption: {
+				id: clip.entityId,
+				kind: "caption",
+				text,
+				...cues === void 0 ? {} : { display_cues: cues },
+				speech_part_id: anchoredToSpeech ? placement.anchorClipEntityId : void 0,
+				start_ms: anchoredToSpeech ? placement.anchorOffset : 0,
+				initial_duration_ms: placement.duration,
+				...style === void 0 ? {} : { style }
+			} };
+		} else {
+			const asset = mediaAssetFacts(graph, content);
+			const external = externalLocator(asset, "memota");
+			if (marker.payload.durationPolicy !== "timeline") fail("Background Audio requires an explicit timeline-fill durationPolicy");
+			if (marker.payload.timeRemapping !== void 0) fail("BGM timeRemapping is not supported by this reader");
+			const source = range(marker.payload.sourceRange, "sourceRange");
+			const extent = content.payload.extent;
+			if (!object(extent) || extent.start !== source.start || extent.end !== source.end) fail("Background Audio compatibility requires the complete source");
+			parts[clip.entityId] = { bgm: {
+				id: clip.entityId,
+				kind: "bgm",
+				audio_storage_key: storageKey(asset),
+				origin_media_id: external.key,
+				volume: volume.data
+			} };
+		}
+	}
+	const document = {
+		meta: {
+			...structuredClone(meta),
+			schema_version: ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION
+		},
+		timeline: graph.timeline.payload.unit_time_ms === void 0 ? void 0 : { unit_time_ms: positive(graph.timeline.payload.unit_time_ms, "unit_time_ms") },
+		tracks: layout.tracks.map((track) => ({
+			id: track.entityId,
+			parts_kind: track.role,
+			is_hidden: track.hidden,
+			items: track.clips.map((clip) => clip.mode === "anchored" ? {
+				part_id: clip.clipEntityId,
+				time_position: {
+					mode: "anchored",
+					anchorPartId: clip.anchorClipEntityId,
+					offsetMs: clip.anchorOffset
+				},
+				fallback_abs_ms: clip.start
+			} : {
+				part_id: clip.clipEntityId,
+				time_position: {
+					mode: "absolute",
+					offsetMs: clip.start
+				}
+			})
+		})),
+		part_library: parts
+	};
+	assertValidVideoDocument(document);
+	return document;
+}
+function trackRoleOf(layout, trackEntityId) {
+	return layout.tracks.find((track) => track.entityId === trackEntityId)?.role;
+}
+/**
+* Media facts are read from the variant itself: a media variant owns its
+* Asset identity and carries `external`/`storageKey` directly. Dual-entity
+* media graphs are rejected instead of being resolved through a legacy
+* `physical-asset` binding.
+*/
+function mediaAssetFacts(graph, content) {
+	if (graph.adjacent(content.entityId, "physical-asset").length > 0) fail("Media " + content.entityId + " owns its Asset identity; remove its physical-asset Relation");
+	if (!object(content.payload.external)) fail("Media " + content.entityId + " must carry its own Asset external identity");
+	return {
+		entityId: String(content.entityId),
+		payload: content.payload
+	};
+}
+function externalLocator(asset, system) {
+	const value = asset.payload.external;
+	if (!object(value) || value.system !== system || typeof value.key !== "string" || value.key.trim() === "") fail("Asset " + asset.entityId + " requires an explicit " + system + " external key");
+	return { key: value.key };
+}
+function storageKey(asset) {
+	if (typeof asset.payload.storageKey !== "string" || asset.payload.storageKey.trim() === "") fail("Asset " + asset.entityId + " requires its factual storageKey");
+	return asset.payload.storageKey;
+}
+function captionStyle(value) {
+	if (value === void 0) return void 0;
+	if (!object(value)) fail("Caption style must be an object");
+	const { font, ...owned } = structuredClone(value);
+	const fields = {
+		fontSize: "font_size",
+		fontColor: "font_color",
+		fontWeight: "font_weight",
+		entranceAnimation: "entrance_animation",
+		entranceAnimationDurationMs: "entrance_animation_duration_ms",
+		strokeColor: "stroke_color",
+		strokeWidth: "stroke_width",
+		positionX: "position_x",
+		positionY: "position_y"
+	};
+	const style = {};
+	for (const [key, field] of Object.entries(owned)) {
+		if (!Object.hasOwn(fields, key)) fail("Unsupported Caption style field " + key);
+		style[fields[key]] = field;
+	}
+	if (font !== void 0) {
+		if (!object(font) || font.system !== "font-library" || typeof font.key !== "string") fail("Caption font requires a font-library locator");
+		return {
+			...style,
+			font_id: font.key
+		};
+	}
+	return style;
+}
+function requireUntrimmedAudio(content, marker, placement) {
+	const source = range(marker.payload.sourceRange, "sourceRange");
+	const extent = content.payload.extent;
+	if (!object(extent) || extent.start !== source.start || extent.end !== source.end || placement.duration !== source.end - source.start || marker.payload.timeRemapping !== void 0) fail("Voice compatibility requires the complete, unremapped take");
+}
+function videoSpeed(content, marker, placement) {
+	const remapping = marker.payload.timeRemapping;
+	if (content.entityKind === "image" && remapping === void 0) return void 0;
+	const source = range(marker.payload.sourceRange, "sourceRange");
+	if (remapping !== void 0) {
+		if (!object(remapping) || remapping.kind !== "linear") fail("unsupported timeRemapping on " + marker.entityId);
+		if (Object.keys(remapping).some((key) => key !== "kind" && key !== "rate" && key !== "mode")) fail("Unsupported linear timeRemapping fields");
+		const rate = positive(remapping.rate, "linear remapping rate");
+		if (Math.round((source.end - source.start) / rate) !== placement.duration) fail("timeRemapping on " + marker.entityId + " must agree with Marker duration");
+		if (remapping.mode !== void 0 && typeof remapping.mode !== "string") fail("Linear remapping mode must be a string");
+		return {
+			category: "linear",
+			mode: typeof remapping.mode === "string" ? remapping.mode : "constant",
+			config: { linear: { speed: rate } }
+		};
+	}
+	const rate = (source.end - source.start) / placement.duration;
+	return rate === 1 ? void 0 : {
+		category: "linear",
+		mode: "constant",
+		config: { linear: { speed: rate } }
+	};
+}
+/** Preserve selected text intervals without minting synthetic editable Clip identities. */
+function captionDisplayCues(assembled, marker, duration) {
+	const ranges = assembled.caption.payload.segmentRanges;
+	if (!Array.isArray(ranges)) return void 0;
+	const source = range(marker.payload.sourceRange, "Caption sourceRange");
+	const scale = duration / (source.end - source.start);
+	return assembled.segments.flatMap((segment) => {
+		const timing = ranges.find((entry) => object(entry) && entry.segmentId === segment.segmentId);
+		if (!object(timing)) fail(`Caption timing is missing for selected segment ${segment.segmentId}`);
+		const intrinsic = range({
+			start: timing.startMs,
+			end: timing.endMs
+		}, "Caption segmentRange");
+		const start = Math.max(source.start, intrinsic.start);
+		const end = Math.min(source.end, intrinsic.end);
+		if (end <= start) return [];
+		const startMs = Math.round((start - source.start) * scale);
+		const endMs = Math.round((end - source.start) * scale);
+		return endMs > startMs ? [{
+			segmentId: segment.segmentId,
+			text: segment.text,
+			startMs,
+			durationMs: endMs - startMs
+		}] : [];
+	});
+}
+//#endregion
+//#region src/entity-crdt/field-changes.ts
+const atomicFields = new Set([
+	"sequence",
+	"sourceRange",
+	"targetRange",
+	"duration",
+	"extent",
+	"timeRemapping",
+	"textRange",
+	"selection",
+	"external",
+	"coordinateSpace"
+]);
+const textFields = new Set(["text", "phonemeScript"]);
+const orderedFields = new Set([
+	"segments",
+	"segmentRanges",
+	"baseEntityIds"
+]);
+const unsafeKeys = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+function listElementId(value) {
+	const id = typeof value === "string" ? value : isJsonObject(value) ? value.segmentId : void 0;
+	if (typeof id !== "string" || !id.trim()) throw new Error("List elements require a nonempty segmentId or string identity");
+	return id;
+}
+function assertFieldChanges(changes) {
+	if (!Array.isArray(changes) || changes.length === 0) throw new Error("changes must be a nonempty array");
+	for (const change of changes) {
+		if (!isJsonObject(change) || ![
+			"set",
+			"unset",
+			"text.splice",
+			"list.insert",
+			"list.move",
+			"list.remove"
+		].includes(change.op)) throw new Error("Unknown field operation");
+		if (!Array.isArray(change.path) || !change.path.length || typeof change.path[0] !== "string") throw new Error("Field paths must start with a field name");
+		for (const part of change.path) if (typeof part === "string") {
+			if (!part || unsafeKeys.has(part)) throw new Error("Invalid field name");
+		} else if (!isJsonObject(part) || Object.keys(part).length !== 1 || typeof part.elementId !== "string" || !part.elementId.trim()) throw new Error("List paths require { elementId }; numeric indices are not supported");
+	}
+}
+/** Resolve against the sequential causal view; the numeric path never crosses the API boundary. */
+function resolveFieldPath(payload, path) {
+	let value = payload;
+	const resolved = [];
+	for (const [index, part] of path.entries()) if (typeof part === "string") {
+		if (!isJsonObject(value)) throw new Error(`Field path does not reach a map: ${part}`);
+		if (index < path.length - 1 && atomicFields.has(part)) throw new Error(`Atomic field ${part} must be changed as one value`);
+		resolved.push(part);
+		value = value[part];
+	} else {
+		if (!Array.isArray(value)) throw new Error("Element selector requires a list");
+		const matches = value.flatMap((item, i) => listElementId(item) === part.elementId ? [i] : []);
+		if (matches.length !== 1) throw new Error(`Missing or ambiguous list element ${part.elementId}`);
+		resolved.push(matches[0]);
+		value = value[matches[0]];
+	}
+	return resolved;
+}
+/** Detached plan evaluation. Native compilation replays the original operations, not this snapshot. */
+function applyFieldChanges(payload, changes) {
+	assertFieldChanges(changes);
+	const result = structuredClone(payload);
+	for (const change of changes) {
+		const path = resolveFieldPath(result, change.path);
+		const key = path.at(-1);
+		if (typeof key !== "string") throw new Error("Change fields inside a list element or use list operations");
+		let parent = result;
+		for (const part of path.slice(0, -1)) parent = parent[part];
+		if (!isJsonObject(parent)) throw new Error("Field parent is not a map");
+		const mutable = parent;
+		const value = mutable[key];
+		if ([
+			"entityId",
+			"entityKind",
+			"entity_id",
+			"entity_kind",
+			"segmentId"
+		].includes(key)) throw new Error(`Identity field ${key} cannot be edited`);
+		switch (change.op) {
+			case "set":
+				if (textFields.has(key) || orderedFields.has(key) || !atomicFields.has(key) && (isJsonObject(value) || isJsonObject(change.value) || Array.isArray(value) || Array.isArray(change.value))) throw new Error(`Field ${key} requires a text, list, or leaf operation; snapshot replacement is not allowed`);
+				if (change.value === void 0 || !isJsonObject({ value: change.value })) throw new Error("set requires a JSON value");
+				if (value !== void 0 && value !== null && change.value !== null && typeof value !== typeof change.value) throw new Error(`Field ${key} cannot change type`);
+				mutable[key] = structuredClone(change.value);
+				break;
+			case "unset":
+				if (!Object.hasOwn(parent, key)) throw new Error(`Field ${key} is absent`);
+				delete mutable[key];
+				break;
+			case "text.splice": {
+				if (!textFields.has(key) || typeof value !== "string") throw new Error(`Field ${key} is not collaborative text`);
+				const chars = Array.from(value);
+				if (!Number.isSafeInteger(change.index) || !Number.isSafeInteger(change.deleteCount) || change.index < 0 || change.deleteCount < 0 || change.index + change.deleteCount > chars.length || typeof change.text !== "string") throw new Error("Invalid text splice range");
+				chars.splice(change.index, change.deleteCount, ...Array.from(change.text));
+				mutable[key] = chars.join("");
+				break;
+			}
+			default: {
+				if (!orderedFields.has(key) || !Array.isArray(value)) throw new Error(`Field ${key} is not a collaborative list`);
+				const ids = value.map(listElementId);
+				if (new Set(ids).size !== ids.length) throw new Error("Duplicate collaborative list identity");
+				const requireIndex = (id) => {
+					const index = ids.indexOf(id);
+					if (index < 0) throw new Error(`Unknown list element ${id}`);
+					return index;
+				};
+				if (change.op === "list.remove") value.splice(requireIndex(change.elementId), 1);
+				else {
+					if (change.beforeElementId !== null && typeof change.beforeElementId !== "string") throw new Error("beforeElementId must be an identity or null");
+					const before = change.beforeElementId === null ? value.length : requireIndex(change.beforeElementId);
+					if (change.op === "list.insert") {
+						const id = listElementId(change.value);
+						if (ids.includes(id)) throw new Error(`Duplicate list element ${id}`);
+						value.splice(before, 0, structuredClone(change.value));
+					} else {
+						if (change.elementId === change.beforeElementId) throw new Error("Cannot move a list element before itself");
+						const from = requireIndex(change.elementId);
+						const [item] = value.splice(from, 1);
+						value.splice(before > from ? before - 1 : before, 0, item);
+					}
+				}
+			}
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/entity-crdt/json-containers.ts
+function equalJson(a, b) {
+	return canonicalJson(a) === canonicalJson(b);
+}
+function canonicalJson(value) {
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+/** Compile only the changed fields; untouched containers retain their operation identity. */
+function writeObject(map, before, after) {
+	for (const key of Object.keys(before)) if (!Object.hasOwn(after, key)) map.delete(key);
+	for (const [key, value] of Object.entries(after)) {
+		if (equalJson(before[key], value)) continue;
+		if (atomicFields.has(key)) map.set(key, value);
+		else if (typeof value === "string" && textFields.has(key)) map.ensureMergeableText(key).update(value);
+		else if (Array.isArray(value) && orderedFields.has(key)) writeList(map.ensureMergeableMovableList(key), value);
+		else if (isJsonObject(value)) writeObject(map.ensureMergeableMap(key), isJsonObject(before[key]) ? before[key] : {}, value);
+		else map.set(key, value);
+	}
+}
+function readItem(list, index) {
+	const value = list.get(index);
+	return value instanceof LoroMap ? value.toJSON() : value;
+}
+function writeList(list, values) {
+	const wanted = values.map(listElementId);
+	if (new Set(wanted).size !== wanted.length) throw new Error("Duplicate collaborative list identity");
+	for (let index = list.length - 1; index >= 0; index--) if (!wanted.includes(listElementId(readItem(list, index)))) list.delete(index, 1);
+	for (let index = 0; index < values.length; index++) {
+		const value = values[index];
+		const key = wanted[index];
+		let found = -1;
+		for (let cursor = index; cursor < list.length; cursor++) if (listElementId(readItem(list, cursor)) === key) {
+			found = cursor;
+			break;
+		}
+		if (found === -1) if (isJsonObject(value)) writeObject(list.insertContainer(index, new LoroMap()), {}, value);
+		else list.insert(index, value);
+		else {
+			if (found !== index) list.move(found, index);
+			const current = list.get(index);
+			if (isJsonObject(value)) {
+				if (!(current instanceof LoroMap)) throw new Error("Collaborative list item changed type");
+				writeObject(current, current.toJSON(), value);
+			}
+		}
+	}
+}
+function requireText(map, path) {
+	let value = map;
+	for (const part of path) if (value instanceof LoroMap && typeof part === "string") value = value.get(part);
+	else if (value instanceof LoroMovableList && typeof part === "number") value = value.get(part);
+	else throw new Error("Invalid collaborative text path");
+	if (!(value instanceof LoroText)) throw new Error("Field is not collaborative text");
+	return value;
+}
+/** Apply the authored operation directly, preserving text positions and moved item identity. */
+function applyNativeFieldChange(map, path, change) {
+	let parent = map;
+	for (const part of path.slice(0, -1)) if (parent instanceof LoroMap && typeof part === "string") parent = parent.get(part);
+	else if (parent instanceof LoroMovableList && typeof part === "number") parent = parent.get(part);
+	else throw new Error("Invalid native field path");
+	const key = path.at(-1);
+	if (!(parent instanceof LoroMap) || typeof key !== "string") throw new Error("Invalid native field parent");
+	if (change.op === "set") {
+		parent.set(key, change.value);
+		return;
+	}
+	if (change.op === "unset") {
+		parent.delete(key);
+		return;
+	}
+	const value = parent.get(key);
+	if (change.op === "text.splice") {
+		if (!(value instanceof LoroText)) throw new Error("Field is not collaborative text");
+		const start = value.convertPos(change.index, "unicode", "utf16");
+		const end = value.convertPos(change.index + change.deleteCount, "unicode", "utf16");
+		value.splice(start, end - start, change.text);
+		return;
+	}
+	if (!(value instanceof LoroMovableList)) throw new Error("Field is not a collaborative list");
+	applyNativeListChange(value, change);
+}
+function applyNativeListChange(list, change) {
+	const ids = Array.from({ length: list.length }, (_, i) => listElementId(readItem(list, i)));
+	const index = (id) => {
+		const found = ids.indexOf(id);
+		if (found < 0) throw new Error(`Unknown list element ${id}`);
+		return found;
+	};
+	if (change.op === "list.remove") {
+		list.delete(index(change.elementId), 1);
+		return;
+	}
+	const before = change.beforeElementId === null ? list.length : index(change.beforeElementId);
+	if (change.op === "list.insert") if (isJsonObject(change.value)) writeObject(list.insertContainer(before, new LoroMap()), {}, change.value);
+	else list.insert(before, change.value);
+	else {
+		const from = index(change.elementId);
+		const to = before > from ? before - 1 : before;
+		if (from !== to) list.move(from, to);
+	}
+}
+//#endregion
+//#region src/entity-crdt/audio-script-assets.ts
+/** A resource is a snapshot of text; the native Loro text remains the editing authority. */
+function audioScriptAssetContent(payload) {
+	assembleScriptText({
+		entityId: createEntityId("script-validation"),
+		entityKind: "audio-script",
+		payload
+	});
+	return { segments: structuredClone(payload.segments) };
+}
+function audioScriptAssetHash(payload) {
+	return bytesToHex(sha256(new TextEncoder().encode(canonicalJson(audioScriptAssetContent(payload)))));
+}
+function hasAudioScriptAsset(payload) {
+	return isJsonObject(payload.external) && payload.external.system === "memota" && typeof payload.external.key === "string";
+}
+/** Internal fingerprint prevents a resource from silently describing an older text revision. */
+function audioScriptAssetFields(payload, assetId) {
+	if (!assetId.trim()) throw new Error("AudioScript resource writer returned an empty asset ID");
+	return {
+		external: {
+			system: "memota",
+			key: assetId
+		},
+		assetContentHash: audioScriptAssetHash(payload)
+	};
+}
+//#endregion
+//#region src/entity-crdt/ordering.ts
+/** Domain order is scoped by membership; relation storage has no global order. */
+function entityOrderGroups(rows) {
+	const entities = new Map(rows.entities.map((row) => [String(row.entityId), row]));
+	const groups = /* @__PURE__ */ new Map();
+	for (const relation of rows.relations) {
+		const childKind = relation.relationKind === "timeline-track" ? "track" : relation.relationKind === "track-clip" ? "clip" : null;
+		if (!childKind) continue;
+		const endpoints = [relation.endpoint0EntityId, relation.endpoint1EntityId];
+		const childId = endpoints.find((id) => entities.get(id)?.entityKind === childKind);
+		if (!childId) continue;
+		const child = entities.get(childId);
+		if (typeof child.payload.order !== "number") continue;
+		const parent = endpoints.find((id) => id !== childId);
+		const values = groups.get(parent) ?? [];
+		values.push({
+			id: childId,
+			order: child.payload.order
+		});
+		groups.set(parent, values);
+	}
+	return new Map([...groups].map(([parent, values]) => [parent, values.sort((a, b) => a.order - b.order || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).map((item) => item.id)]));
+}
+function ordering(doc) {
+	const map = doc.getMap("medeo").get("ordering");
+	if (!(map instanceof LoroMap)) throw new Error("Missing native entity ordering");
+	return map;
+}
+/** Returns a derived ordinal while the stable element retains its native move identity. */
+function entityOrdinal(doc, root) {
+	let found;
+	for (const key of ordering(doc).keys()) {
+		const list = ordering(doc).get(key);
+		if (!(list instanceof LoroMovableList)) throw new Error("Invalid entity order container");
+		const index = list.toArray().indexOf(root);
+		if (index < 0) continue;
+		if (found !== void 0) throw new Error("Entity belongs to multiple ordered groups");
+		found = index;
+	}
+	return found;
+}
+/** Move existing elements, insert new identities and delete removed members on the causal list. */
+function writeEntityOrder(doc, group, roots, token) {
+	if (new Set(roots).size !== roots.length) throw new Error("Duplicate ordered entity identity");
+	const list = ordering(doc).ensureMergeableMovableList(group);
+	const before = list.toArray();
+	for (let index = list.length - 1; index >= 0; index--) if (!roots.includes(String(list.get(index)))) list.delete(index, 1);
+	roots.forEach((root, index) => {
+		const current = list.toArray().indexOf(root);
+		if (current < 0) list.insert(index, root);
+		else if (current !== index) list.move(current, index);
+	});
+	if (token) {
+		const editing = doc.getMap("medeo").get("editing");
+		for (const root of new Set([...before, ...roots])) {
+			if (before.indexOf(root) < 0 || before.indexOf(root) === roots.indexOf(root)) continue;
+			editing.get(root).get("changes").set(token, true);
+		}
+	}
+}
+//#endregion
+//#region src/entity-crdt/entity-document.ts
+const LORO_ENTITY_SCHEMA = "medeo.entities.loro.v1";
+const MATERIALIZE_ORIGIN = "medeo.materialize";
+function hash(value) {
+	return bytesToHex(sha256(new TextEncoder().encode(canonicalJson(value))));
+}
+function clone(value) {
+	return structuredClone(value);
+}
+function root(doc) {
+	return doc.getMap("medeo");
+}
+function requireMap(parent, key) {
+	const value = parent.get(key);
+	if (!(value instanceof LoroMap)) throw new Error(`Missing Loro map ${key}`);
+	return value;
+}
+function section(doc, key) {
+	return requireMap(root(doc), key);
+}
+function workspace(doc, id) {
+	const value = section(doc, "editing").get(id);
+	if (!(value instanceof LoroMap)) throw new Error(`Unknown entity editing identity ${id}`);
+	return value;
+}
+function content(map) {
+	return requireMap(map, "content").toJSON();
+}
+function entityContent(doc, key) {
+	const payload = content(workspace(doc, key));
+	const order = entityOrdinal(doc, key);
+	return order === void 0 ? payload : {
+		...payload,
+		order
+	};
+}
+function bases(map) {
+	const links = requireMap(map, "bases");
+	return links.keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0).map((key) => String(links.get(key)));
+}
+function owned(payload) {
+	const { baseEntityIds: _bases, ...fields } = payload;
+	return fields;
+}
+function baseIds(payload) {
+	const ids = payload.baseEntityIds ?? [];
+	if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string") || new Set(ids).size !== ids.length) throw new Error("baseEntityIds must contain unique entity IDs");
+	return ids;
+}
+function family(doc, id) {
+	const value = section(doc, "origins").get(id);
+	if (typeof value === "string") return value;
+	for (const [key, value] of currentIds(doc)) if (value === id) return key;
+	throw new Error(`Unknown entity ${id}`);
+}
+function currentIds(doc) {
+	const result = /* @__PURE__ */ new Map();
+	for (const key of section(doc, "editing").keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0)) {
+		const map = workspace(doc, key);
+		if (map.get("deleted") === true) continue;
+		const tokens = requireMap(map, "changes").keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+		const initial = section(doc, "entities").get(key);
+		const { id: _id, kind: _kind, ...initialPayload } = isJsonObject(initial) ? initial : {};
+		const payload = entityContent(doc, key);
+		const changed = tokens.length > 0 || initial !== void 0 && !equalJson(owned(initialPayload), payload);
+		result.set(key, changed ? `entity_${hash([
+			key,
+			tokens,
+			payload
+		])}` : key);
+	}
+	return result;
+}
+function currentId(doc, id, ids = currentIds(doc)) {
+	const resolved = ids.get(family(doc, id));
+	if (resolved === void 0) throw new Error(`Referenced entity ${id} was deleted`);
+	return resolved;
+}
+/** Plain domain objects assembled from native Loro state, never a second writable authority. */
+function readEntityDocument(doc, allowSelectionConflicts = false) {
+	if (root(doc).get("schema") !== "medeo.entities.loro.v1") throw new Error("Document has no Loro entity state");
+	const ids = currentIds(doc);
+	const entities = [...ids].map(([key, entityId]) => {
+		const map = workspace(doc, key);
+		const baseEntityIds = bases(map).map((id) => currentId(doc, id, ids));
+		return {
+			entityId: createEntityId(entityId),
+			entityKind: map.get("kind"),
+			payload: {
+				...entityContent(doc, key),
+				...baseEntityIds.length ? { baseEntityIds } : {}
+			}
+		};
+	});
+	const relations = [];
+	for (const key of section(doc, "relations").keys().sort((a, b) => a < b ? -1 : a > b ? 1 : 0)) {
+		const map = section(doc, "relations").get(key);
+		if (!(map instanceof LoroMap) || map.get("deleted") === true) continue;
+		const original = map.get("identity");
+		if (original.endpoints.some((id) => !ids.has(family(doc, id)))) continue;
+		const endpoints = original.endpoints.map((id) => currentId(doc, id, ids));
+		const relationId = equalJson(endpoints, original.endpoints) ? key : `relation_${hash([key, endpoints])}`;
+		relations.push({
+			relationId: createRelationId(relationId),
+			relationKind: original.kind,
+			endpoint0EntityId: createEntityId(endpoints[0]),
+			endpoint1EntityId: createEntityId(endpoints[1]),
+			metadata: requireMap(map, "metadata").toJSON(),
+			trace: requireMap(map, "trace").toJSON()
+		});
+	}
+	const project = {};
+	for (const [key, value] of Object.entries(section(doc, "attachments").toJSON())) {
+		if (typeof value !== "string") throw new Error(`Invalid project attachment ${key}`);
+		project[key] = currentId(doc, value, ids);
+	}
+	const state = {
+		rows: {
+			entities,
+			relations
+		},
+		project
+	};
+	if (!allowSelectionConflicts) for (const [key, id] of ids) {
+		const fingerprint = selectionFingerprint(state.rows, id);
+		if (fingerprint !== void 0 && workspace(doc, key).get("selectionBaseline") !== fingerprint) throw new Error(`Caption text selection conflict at ${id}: source text changed; revise its text ranges explicitly`);
+	}
+	return state;
+}
+/** Native editing containers survive domain version changes and merge independently. */
+var LoroEntityDocument = class LoroEntityDocument {
+	doc;
+	validate;
+	undoManager;
+	constructor(doc, validate) {
+		this.doc = doc;
+		this.validate = validate;
+		this.undoManager = new UndoManager(doc, {
+			mergeInterval: 0,
+			excludeOriginPrefixes: [MATERIALIZE_ORIGIN]
+		});
+	}
+	/** Open a causal snapshot using the same Loro runtime as the compiler. */
+	static fromSnapshot(snapshot, validate) {
+		const doc = new LoroDoc();
+		doc.import(snapshot);
+		readEntityDocument(doc);
+		return new LoroEntityDocument(doc, validate);
+	}
+	static create(rows, project = {}, peerId) {
+		const doc = new LoroDoc();
+		if (peerId !== void 0) doc.setPeerId(peerId);
+		root(doc).set("schema", LORO_ENTITY_SCHEMA);
+		for (const name of [
+			"editing",
+			"entities",
+			"origins",
+			"relations",
+			"project",
+			"attachments",
+			"ordering"
+		]) root(doc).ensureMergeableMap(name);
+		for (const row of rows.entities) apply(doc, {
+			type: "create",
+			row
+		});
+		for (const row of rows.relations) apply(doc, {
+			type: "relation",
+			row
+		});
+		for (const [slot, entityId] of Object.entries(project)) apply(doc, {
+			type: "attach",
+			slot,
+			entityId
+		});
+		for (const [group, ids] of entityOrderGroups(rows)) writeEntityOrder(doc, group, ids);
+		const initialState = readEntityDocument(doc, true);
+		for (const row of initialState.rows.entities) {
+			const fingerprint = selectionFingerprint(initialState.rows, row.entityId);
+			if (fingerprint !== void 0) workspace(doc, row.entityId).set("selectionBaseline", fingerprint);
+		}
+		assertState(readEntityDocument(doc));
+		materialize(doc);
+		doc.commit({ origin: MATERIALIZE_ORIGIN });
+		return new LoroEntityDocument(doc);
+	}
+	snapshot() {
+		return readEntityDocument(this.doc);
+	}
+	relationsOf(entityId) {
+		const id = currentIds(this.doc).get(family(this.doc, entityId));
+		if (id === void 0) return [];
+		return this.snapshot().rows.relations.filter((row) => row.endpoint0EntityId === id || row.endpoint1EntityId === id);
+	}
+	/** Resolve a queued edit target through its native identity without changing history. */
+	resolveCurrentEntityId(id) {
+		return currentId(this.doc, id);
+	}
+	getVersion(id) {
+		const entity = section(this.doc, "entities").get(id);
+		if (!isJsonObject(entity)) return void 0;
+		const { id: entityId, kind, ...payload } = entity;
+		if (typeof entityId !== "string") throw new Error("Invalid stored entity ID");
+		return {
+			entityId: createEntityId(entityId),
+			entityKind: kind,
+			payload
+		};
+	}
+	/** The callback and every domain validation execute on a causally complete fork first. */
+	transact(edit) {
+		const probe = this.doc.fork();
+		const draft = new LoroEntityDraft(probe);
+		edit(draft);
+		draft.captureSelectionBaselines();
+		const state = readEntityDocument(probe);
+		assertState(state);
+		this.validate?.(state);
+		materialize(probe);
+		const from = this.doc.oplogVersion();
+		for (const command of draft.commands) apply(this.doc, command);
+		this.doc.commit({ origin: "medeo.edit" });
+		materialize(this.doc);
+		this.doc.commit({ origin: MATERIALIZE_ORIGIN });
+		return this.doc.export({
+			mode: "update",
+			from
+		});
+	}
+	/** Import preserves native operation identities; projection errors never discard remote operations. */
+	import(update) {
+		this.doc.import(update);
+		const state = this.snapshot();
+		assertState(state);
+		this.validate?.(state);
+		materialize(this.doc);
+		this.doc.commit({ origin: MATERIALIZE_ORIGIN });
+	}
+	/** Bind a saved snapshot without rewriting text operations or resolving selection conflicts. */
+	bindAudioScriptAsset(entityId, assetId, expectedContentHash) {
+		const key = family(this.doc, entityId);
+		const map = workspace(this.doc, key);
+		if (map.get("kind") !== "audio-script" || map.get("deleted") === true) throw new Error("Resource binding requires an active AudioScript");
+		const payload = entityContent(this.doc, key);
+		if (audioScriptAssetHash(payload) !== expectedContentHash) throw new Error("AudioScript changed while saving its resource");
+		const from = this.doc.oplogVersion();
+		writeObject(requireMap(map, "content"), payload, {
+			...payload,
+			...audioScriptAssetFields(payload, assetId)
+		});
+		this.doc.commit({ origin: "medeo.asset-sync" });
+		materialize(this.doc, true);
+		this.doc.commit({ origin: MATERIALIZE_ORIGIN });
+		return this.doc.export({
+			mode: "update",
+			from
+		});
+	}
+	canUndo() {
+		return this.undoManager.canUndo();
+	}
+	canRedo() {
+		return this.undoManager.canRedo();
+	}
+	undo() {
+		return this.historyEdit(() => this.undoManager.undo());
+	}
+	redo() {
+		return this.historyEdit(() => this.undoManager.redo());
+	}
+	historyEdit(run) {
+		const before = new Map(this.snapshot().rows.entities.map((row) => [family(this.doc, row.entityId), row]));
+		if (!run()) return false;
+		const after = this.snapshot();
+		for (const row of after.rows.entities) {
+			const id = family(this.doc, row.entityId);
+			const previous = before.get(id);
+			if (previous && !equalJson(owned(previous.payload), owned(row.payload))) workspace(this.doc, id).ensureMergeableMap("changes").set(globalThis.crypto.randomUUID(), true);
+		}
+		materialize(this.doc);
+		this.doc.commit({ origin: MATERIALIZE_ORIGIN });
+		return true;
+	}
+};
+var LoroEntityDraft = class {
+	doc;
+	commands = [];
+	selectedRoots = /* @__PURE__ */ new Set();
+	relationAliases = /* @__PURE__ */ new Map();
+	constructor(doc) {
+		this.doc = doc;
+		for (const row of this.snapshot().rows.relations) this.relationAliases.set(row.relationId, this.relationRoot(row.relationId));
+	}
+	snapshot() {
+		return readEntityDocument(this.doc, true);
+	}
+	order(groupId, entityIds) {
+		this.record({
+			type: "order",
+			group: family(this.doc, groupId),
+			roots: entityIds.map((id) => family(this.doc, id)),
+			token: globalThis.crypto.randomUUID()
+		});
+	}
+	/** Project the final scalar placement intents onto the existing native ordering containers. */
+	reconcileOrder(rows) {
+		const before = new Map([...entityOrderGroups(this.snapshot().rows)].map(([id, ids]) => [family(this.doc, id), ids.map((id) => family(this.doc, id))]));
+		const after = new Map([...entityOrderGroups(rows)].map(([id, ids]) => [family(this.doc, id), ids.map((id) => family(this.doc, id))]));
+		for (const group of new Set([...before.keys(), ...after.keys()])) {
+			const next = after.get(group) ?? [];
+			if (!equalJson(before.get(group) ?? [], next)) this.order(group, next);
+		}
+	}
+	create(row) {
+		this.record({
+			type: "create",
+			row: clone(row)
+		});
+	}
+	delete(entityId) {
+		this.record({
+			type: "delete",
+			root: family(this.doc, entityId)
+		});
+	}
+	attach(slot, entityId) {
+		this.record({
+			type: "attach",
+			slot,
+			entityId
+		});
+	}
+	link(row) {
+		this.record({
+			type: "relation",
+			row: clone(row)
+		});
+	}
+	patchRelation(relationId, metadata, trace) {
+		this.record({
+			type: "relation-fields",
+			root: this.relationRoot(relationId),
+			metadata: clone(metadata),
+			trace: clone(trace)
+		});
+	}
+	unlink(relationId) {
+		this.record({
+			type: "unlink",
+			root: this.relationRoot(relationId)
+		});
+	}
+	relationRoot(relationId) {
+		const alias = this.relationAliases.get(relationId);
+		if (alias !== void 0) return alias;
+		const ids = currentIds(this.doc);
+		for (const key of section(this.doc, "relations").keys()) {
+			const map = section(this.doc, "relations").get(key);
+			if (!(map instanceof LoroMap) || map.get("deleted") === true) continue;
+			const identity = map.get("identity");
+			if (identity.endpoints.some((id) => !ids.has(family(this.doc, id)))) continue;
+			const endpoints = identity.endpoints.map((id) => currentId(this.doc, id, ids));
+			if ((equalJson(endpoints, identity.endpoints) ? key : `relation_${hash([key, endpoints])}`) === relationId || key === relationId) return key;
+		}
+		throw new Error(`Unknown relation ${relationId}`);
+	}
+	update(entityId, fields) {
+		const state = this.snapshot();
+		const id = createEntityId(currentId(this.doc, entityId));
+		const updates = /* @__PURE__ */ new Map();
+		for (const [field, value] of Object.entries(fields)) {
+			const owner = resolveEntityFieldOwner(state.rows, id, field);
+			const payload = updates.get(owner) ?? clone(state.rows.entities.find((row) => row.entityId === owner).payload);
+			updates.set(owner, {
+				...payload,
+				[field]: clone(value)
+			});
+		}
+		for (const [owner, payload] of updates) this.replaceOwned(owner, payload);
+	}
+	declare(entityId, fields) {
+		const row = this.snapshot().rows.entities.find((row) => row.entityId === currentId(this.doc, entityId));
+		if (!row) throw new Error(`Unknown entity ${entityId}`);
+		this.replaceOwned(entityId, {
+			...row.payload,
+			...fields
+		});
+	}
+	replaceOwned(entityId, payload) {
+		this.record({
+			type: "write",
+			root: family(this.doc, entityId),
+			payload: clone(payload),
+			token: globalThis.crypto.randomUUID()
+		});
+	}
+	editText(entityId, path, start, deleteCount, text) {
+		if (typeof path[0] !== "string") throw new Error("Text path must start with a field");
+		const owner = resolveEntityFieldOwner(this.snapshot().rows, createEntityId(currentId(this.doc, entityId)), path[0]);
+		this.record({
+			type: "text",
+			root: family(this.doc, owner),
+			path: [...path],
+			start,
+			deleteCount,
+			text,
+			token: globalThis.crypto.randomUUID()
+		});
+	}
+	/** Generic assembled-field edit compiled at the author's causal position. */
+	change(entityId, changes) {
+		assertFieldChanges(changes);
+		for (const raw of changes) {
+			const change = clone(raw);
+			if (change.path[0] === "baseEntityIds") {
+				if (change.op === "list.insert" && typeof change.value === "string") change.value = currentId(this.doc, change.value);
+				if (change.op === "list.remove" || change.op === "list.move") change.elementId = currentId(this.doc, change.elementId);
+				if ((change.op === "list.insert" || change.op === "list.move") && change.beforeElementId !== null) change.beforeElementId = currentId(this.doc, change.beforeElementId);
+			}
+			const state = this.snapshot();
+			const id = createEntityId(currentId(this.doc, entityId));
+			const owner = resolveEntityFieldOwner(state.rows, id, change.path[0]);
+			const row = state.rows.entities.find((row) => row.entityId === owner);
+			if (equalJson(row.payload, applyFieldChanges(row.payload, [change]))) continue;
+			this.record({
+				type: "field",
+				root: family(this.doc, owner),
+				path: resolveFieldPath(row.payload, change.path),
+				change: clone(change),
+				token: globalThis.crypto.randomUUID()
+			});
+		}
+	}
+	changeRelation(relationId, changes) {
+		assertFieldChanges(changes);
+		const key = this.relationRoot(relationId);
+		const map = section(this.doc, "relations").get(key);
+		if (!(map instanceof LoroMap) || map.get("deleted") === true) throw new Error("Unknown relation");
+		for (const change of changes) {
+			if (!["metadata", "trace"].includes(change.path[0]) || change.path.length < 2) throw new Error("Relation changes may only edit metadata or trace fields");
+			const payload = {
+				metadata: requireMap(map, "metadata").toJSON(),
+				trace: requireMap(map, "trace").toJSON()
+			};
+			applyFieldChanges(payload, [change]);
+			this.record({
+				type: "relation-field",
+				root: key,
+				path: resolveFieldPath(payload, change.path),
+				change: clone(change)
+			});
+		}
+	}
+	captureSelectionBaselines() {
+		const state = this.snapshot();
+		for (const key of this.selectedRoots) {
+			const id = currentIds(this.doc).get(key);
+			if (id === void 0) continue;
+			const fingerprint = selectionFingerprint(state.rows, id);
+			if (fingerprint !== void 0) this.record({
+				type: "selection-baseline",
+				root: key,
+				fingerprint
+			});
+		}
+	}
+	record(command) {
+		if (command.type === "create") this.selectedRoots.add(command.row.entityId);
+		if (command.type === "write" && !equalJson(content(workspace(this.doc, command.root)).selection, command.payload.selection)) this.selectedRoots.add(command.root);
+		if (command.type === "field" && command.path[0] === "selection") this.selectedRoots.add(command.root);
+		apply(this.doc, command);
+		this.commands.push(command);
+	}
+};
+function apply(doc, command) {
+	switch (command.type) {
+		case "selection-baseline":
+			workspace(doc, command.root).set("selectionBaseline", command.fingerprint);
+			break;
+		case "order":
+			writeEntityOrder(doc, command.group, command.roots, command.token);
+			break;
+		case "create": {
+			const row = command.row;
+			if (section(doc, "origins").get(row.entityId) !== void 0) throw new Error(`Duplicate entity ${row.entityId}`);
+			const map = section(doc, "editing").ensureMergeableMap(row.entityId);
+			map.set("kind", row.entityKind);
+			map.ensureMergeableMap("changes");
+			section(doc, "origins").set(row.entityId, row.entityId);
+			writeObject(map.ensureMergeableMap("content"), {}, owned(row.payload));
+			writeBases(doc, map, baseIds(row.payload));
+			break;
+		}
+		case "write": {
+			const map = workspace(doc, command.root);
+			const before = content(map);
+			const after = owned(command.payload);
+			if (!equalJson(before, after)) {
+				writeObject(map.ensureMergeableMap("content"), before, after);
+				map.ensureMergeableMap("changes").set(command.token, true);
+			}
+			writeBases(doc, map, baseIds(command.payload));
+			break;
+		}
+		case "text": {
+			const map = workspace(doc, command.root);
+			const text = requireText(map.ensureMergeableMap("content"), command.path);
+			if (!Number.isSafeInteger(command.start) || !Number.isSafeInteger(command.deleteCount) || command.start < 0 || command.deleteCount < 0 || command.start + command.deleteCount > Array.from(text.toString()).length) throw new Error("Invalid text edit range");
+			const start = text.convertPos(command.start, "unicode", "utf16");
+			const end = text.convertPos(command.start + command.deleteCount, "unicode", "utf16");
+			text.splice(start, end - start, command.text);
+			map.ensureMergeableMap("changes").set(command.token, true);
+			break;
+		}
+		case "field": {
+			const map = workspace(doc, command.root);
+			if (command.path[0] === "baseEntityIds") {
+				const before = { baseEntityIds: bases(map).map((id) => currentId(doc, id)) };
+				if (command.change.op === "list.move") throw new Error("Composition bases are unordered; list.move is not applicable");
+				writeBases(doc, map, baseIds(applyFieldChanges(before, [command.change])));
+			} else {
+				applyNativeFieldChange(requireMap(map, "content"), command.path, command.change);
+				map.ensureMergeableMap("changes").set(command.token, true);
+			}
+			break;
+		}
+		case "relation-field": {
+			const map = section(doc, "relations").get(command.root);
+			if (!(map instanceof LoroMap) || map.get("deleted") === true) throw new Error("Unknown relation");
+			applyNativeFieldChange(map, command.path, command.change);
+			break;
+		}
+		case "delete":
+			workspace(doc, command.root).set("deleted", true);
+			break;
+		case "relation": {
+			const row = command.row;
+			const map = section(doc, "relations").ensureMergeableMap(row.relationId);
+			const identity = {
+				kind: row.relationKind,
+				endpoints: [row.endpoint0EntityId, row.endpoint1EntityId]
+			};
+			const previous = map.get("identity");
+			if (previous !== void 0 && !equalJson(previous, identity)) throw new Error("Relation identity cannot change kind or endpoint positions");
+			if (previous === void 0) map.set("identity", identity);
+			if (map.get("deleted") === true) throw new Error("Deleted relation IDs cannot be reused");
+			const metadata = map.ensureMergeableMap("metadata");
+			const trace = map.ensureMergeableMap("trace");
+			writeObject(metadata, metadata.toJSON(), row.metadata);
+			writeObject(trace, trace.toJSON(), row.trace);
+			break;
+		}
+		case "unlink": {
+			const map = section(doc, "relations").get(command.root);
+			if (!(map instanceof LoroMap)) throw new Error("Unknown relation");
+			map.set("deleted", true);
+			break;
+		}
+		case "relation-fields": {
+			const map = section(doc, "relations").get(command.root);
+			if (!(map instanceof LoroMap)) throw new Error("Unknown relation");
+			const metadata = map.ensureMergeableMap("metadata");
+			const trace = map.ensureMergeableMap("trace");
+			writeObject(metadata, metadata.toJSON(), command.metadata);
+			writeObject(trace, trace.toJSON(), command.trace);
+			break;
+		}
+		case "attach":
+			section(doc, "attachments").set(command.slot, command.entityId);
+			break;
+	}
+}
+function writeBases(doc, map, ids) {
+	const links = map.ensureMergeableMap("bases");
+	const wanted = new Map(ids.map((id) => {
+		const origin = section(doc, "origins").get(id);
+		return [typeof origin === "string" ? origin : [...currentIds(doc)].find(([, current]) => current === id)?.[0] ?? id, id];
+	}));
+	if (wanted.size !== ids.length) throw new Error("Duplicate base entity family");
+	for (const key of links.keys()) if (!wanted.has(key)) links.delete(key);
+	for (const [key, id] of wanted) if (links.get(key) === void 0) links.set(key, id);
+}
+/** Numeric sub-spans must not silently quote different text after a collaborative edit. */
+function selectionFingerprint(rows, id) {
+	const row = rows.entities.find((row) => row.entityId === id);
+	if (row?.entityKind !== "caption" || !isJsonObject(row.payload.selection)) return void 0;
+	const selection = row.payload.selection;
+	if (selection.textRange === void 0) return void 0;
+	const segments = assembleEntityContent(rows, row.entityId).payload.segments;
+	if (!Array.isArray(segments)) throw new Error("Caption text selection has no source segments");
+	const source = segments.find((segment) => isJsonObject(segment) && segment.segmentId === selection.segmentId);
+	if (!isJsonObject(source) || typeof source.text !== "string") throw new Error("Caption text selection source is missing");
+	return hash([selection, source.text]);
+}
+function assertState(state) {
+	for (const row of state.rows.entities) assembleEntityContent(state.rows, row.entityId);
+	const ids = new Set(state.rows.entities.map((row) => String(row.entityId)));
+	for (const row of state.rows.relations) if (!ids.has(row.endpoint0EntityId) || !ids.has(row.endpoint1EntityId)) throw new Error("Relation has a missing endpoint");
+}
+function materialize(doc, allowSelectionConflicts = false) {
+	const state = readEntityDocument(doc, allowSelectionConflicts);
+	const byId = section(doc, "entities");
+	const ids = currentIds(doc);
+	for (const [source, id] of ids) {
+		const origins = section(doc, "origins");
+		if (origins.get(id) !== source) origins.set(id, source);
+	}
+	for (const row of state.rows.entities) {
+		const next = {
+			id: row.entityId,
+			kind: row.entityKind,
+			...row.payload
+		};
+		const previous = byId.get(row.entityId);
+		if (isJsonObject(previous) && !equalJson(owned(previous), owned(next))) throw new Error("Immutable entity version collision");
+		if (!equalJson(previous, next)) byId.set(row.entityId, next);
+	}
+	const project = section(doc, "project");
+	for (const [slot, id] of Object.entries(state.project)) if (project.get(slot) !== id) project.set(slot, id);
+}
+//#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: meta?.schema_version === "video-document/entity-projection-v1" ? ENTITY_TIMELINE_PROJECTION_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() {
+		const document = readVideoDocumentFromDraft(this.mirror.getState());
+		if (this.doc.getMap("medeo").get("schema") === "medeo.entities.loro.v1") return projectEntityTimeline(readEntityDocument(this.doc).rows, document.meta);
+		return document;
+	}
+	/**
+	* 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) {
+		if (this.snapshot().meta.schema_version === "video-document/entity-projection-v1") throw new Error("Entity timeline projections are read-only; edit the Medeo entities instead");
+		this.mirror.setState((draft) => {
+			edit(draft);
+		}, {
+			origin: "mengine.semantic_editor",
+			message: JSON.stringify({
+				semantic_op: audit.kind,
+				payload: audit.payload,
+				intent: audit.intent ?? null,
+				actor: audit.actor ?? 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) => {
+		writeVideoDocumentToDraft(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));
+}
+/** Host-only replacement of a derived view, retaining the existing Loro history. */
+function applyEntityTimelineProjection(doc, projection, entityRevision) {
+	if (projection.meta.schema_version !== "video-document/entity-projection-v1") throw new Error("Expected an entity timeline projection");
+	if (!Number.isSafeInteger(entityRevision) || entityRevision < 1) throw new Error("Expected a positive entity revision");
+	assertValidVideoDocument(projection);
+	const from = doc.oplogVersion();
+	new Mirror({
+		doc,
+		schema: videoDocumentMirrorSchema
+	}).setState((draft) => writeVideoDocumentToDraft(draft, {
+		...projection,
+		meta: {
+			...projection.meta,
+			version: entityRevision
+		}
+	}), {
+		origin: "mengine.entity_projection",
+		message: JSON.stringify({
+			semantic_op: "EntityTimelineProjection",
+			entity_revision: entityRevision
+		})
+	});
+	return doc.export({
+		mode: "update",
+		from
+	});
+}
+/** Write a whole `VideoDocument` into a draft (seed a fresh doc / plain-memory state). */
+function writeVideoDocumentToDraft(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/document/plain-memory-adapter.ts
+/**
+* Pure in-memory `SemanticDocumentAdapter` — no Loro/WASM. Holds a
+* `VideoDocumentDraft` object and applies each `transact` via immer `produce`,
+* journaling every audit that actually mutated state (plus any ids minted
+* during that transact).
+*
+* Known benign difference vs `MirrorVideoDocumentAdapter`: the editor's
+* `setPart` assigns a fresh part object on every call, so a same-value rewrite
+* produces a new immer state and IS journaled here, while the mirror's deep
+* diff emits no commit. Terminal `snapshot()` stays equal; replay is idempotent.
+*/
+var PlainMemoryAdapter = class {
+	state;
+	_journal = [];
+	baseIdFactory;
+	/** Non-null only while a `transact` edit callback is running. */
+	pendingIds = null;
+	/**
+	* Recording wrapper around the underlying factory. Callers (sandbox editor)
+	* use this so every minted id is appended to the current transact's list.
+	*/
+	idFactory;
+	constructor(document, options) {
+		assertValidVideoDocument(document);
+		const draft = {};
+		writeVideoDocumentToDraft(draft, document);
+		this.state = draft;
+		this.baseIdFactory = options?.idFactory ?? generatePartId;
+		this.idFactory = (prefix) => {
+			const id = this.baseIdFactory(prefix);
+			if (this.pendingIds != null) this.pendingIds.push(id);
+			return id;
+		};
+	}
+	get journal() {
+		return this._journal;
+	}
+	hasContent() {
+		return (this.state.meta?.schema_version ?? "") !== "";
+	}
+	snapshot() {
+		return readVideoDocumentFromDraft(this.state);
+	}
+	/**
+	* Apply one op via immer. A throw in `edit` discards the draft (state and
+	* journal unchanged). When `produce` returns the same reference, there was
+	* no structural change — skip journal, matching mirror "no change, no commit".
+	*/
+	transact(edit, audit) {
+		if (this.state.meta?.schema_version === "video-document/entity-projection-v1") throw new Error("Entity timeline projections are read-only; edit the Medeo entities instead");
+		this.pendingIds = [];
+		try {
+			const next = produce(this.state, edit);
+			if (next !== this.state) {
+				this.state = next;
+				this._journal.push({
+					...audit,
+					generated_ids: this.pendingIds
+				});
+			}
+		} finally {
+			this.pendingIds = null;
+		}
+	}
+};
+/** Build a `PlainMemoryAdapter` seeded with `document`. */
+function createPlainMemoryAdapter(document, options) {
+	return new PlainMemoryAdapter(document, options);
+}
+//#endregion
+export { ensureLaneTrack as $, assembleEntityContent as A, hasSequence as B, projectEntityTimeline as C, base64ToBytes as Ct, decodeEntityRelationRows as D, EntityTimelineProjectionError as E, updateEntityFields as F, fromVideoDocument as G, buildInitialVideoDocument as H, variantBaseEntityIds as I, assertValidVideoDocument as J, toVideoDocument as K, isJsonObject as L, assembleScriptText as M, findComposedAudioScript as N, ScriptCompositionError as O, selectAudioScriptSegment as P, LANE_KINDS_IN_STACK_ORDER as Q, createEntityId as R, resolveFieldPath as S, videoDocumentMirrorSchema as St, resolveEntityTimelineLayout as T, buildSpeechHostMap as U, isMediaAssetVariantKind as V, derivePositionFromAbs as W, partUnionSchema as X, validateVideoDocument as Y, videoDocumentSchema as Z, audioScriptAssetHash as _, VIDEO_DOCUMENT_SCHEMA_VERSION as _t, applyEntityTimelineProjection as a, fillMainTrackTimeGaps as at, applyFieldChanges as b, partUnionToDraft as bt, writeVideoDocumentToDraft as c, resolveAllSpeechOverlaps as ct, LoroEntityDocument as d, TIMELINE_SKELETON_DURATION_MS as dt, findLaneTrack as et, LoroEntityDraft as f, isEmptyVideoClip as ft, audioScriptAssetFields as g, ENTITY_TIMELINE_PROJECTION_SCHEMA_VERSION as gt, audioScriptAssetContent as h, DEFAULT_UNIT_TIME_MS as ht, MirrorVideoDocumentAdapter as i, arrangeMainTrackSeamlessly as it, assemblePhoneticScriptContent as j, assembleCaptionContent as k, readVideoDocumentFromDraft as l, resolveSpeechOverlapByShiftingVideos as lt, entityOrderGroups as m, safeDurationMs as mt, createPlainMemoryAdapter as n, solveVideoDocument as nt, createMirrorVideoDocument as o, reassignSpeechesToVideoClipsByTime as ot, readEntityDocument as p, partDurationMs as pt, VideoDocumentValidationError as q, generatePartId as r, cascadeAfterVideoClipChanges as rt, createMirrorVideoDocumentAdapter as s, recalculateTimelineDuration as st, PlainMemoryAdapter as t, laneTrackId as tt, LORO_ENTITY_SCHEMA as u, syncAggregatedClipsTimePosition as ut, hasAudioScriptAsset as v, effectiveVideoClipDurationMs as vt, EntityProjectionGraph as w, bytesToBase64 as wt, assertFieldChanges as x, recordEntries as xt, equalJson as y, speedOf as yt, createRelationId as z };