@mengine/medeo-tool 1.2.1-alpha.0 → 1.2.1-alpha.7

package/dist/script-session-BF44uKv_.mjs

@@ -0,0 +1,1501 @@
+import { SchemaValidator, SemanticEditor, createEditSandbox, effectiveVideoClipDurationMs, fromVideoDocument, solveVideoDocument, speedOf } from "@mengine/medeo-client";
+//#region src/document/compact-projection.ts
+const DEFAULT_TEXT_PREVIEW_LENGTH = 24;
+/** Kind tag shown in the first column (`video_clip` → `clip`). */
+function kindTag(kind) {
+	return kind === "video_clip" ? "clip" : kind;
+}
+/** Lane label: `video_clip` tracks display as `main`, otherwise `parts_kind`. */
+function laneLabel(partsKind) {
+	return partsKind === "video_clip" ? "main" : partsKind;
+}
+/** Speed token: absent → `1`; linear → numeric multiplier; anything else → `custom`. */
+function speedToken(speedShift) {
+	if (speedShift == null) return "1";
+	if (speedShift.category === "linear") return String(speedOf(speedShift));
+	return "custom";
+}
+function effectiveDurationMs(part, timelineDurationMs) {
+	if (part.video_clip != null) return effectiveVideoClipDurationMs(part.video_clip);
+	if (part.speech != null) return part.speech.media_duration_ms ?? 0;
+	if (part.caption != null) return part.caption.initial_duration_ms ?? 0;
+	if (part.bgm != null) return timelineDurationMs;
+	return 0;
+}
+function truncateText(text, budget) {
+	if (text.length <= budget) return text;
+	return `${text.slice(0, budget)}…`;
+}
+function anchorToken(timePosition) {
+	if (timePosition.mode === "anchored") return `anchor=${timePosition.anchorPartId}+${timePosition.offsetMs}`;
+	if (timePosition.mode === "absolute") return "anchor=abs";
+	return "anchor=abs";
+}
+function clipAttrs(clip) {
+	const playIn = clip.play_in ?? 0;
+	const playOut = clip.play_out ?? 0;
+	return `media=${clip.origin_media_id ?? ""} trim=${playIn}-${playOut} speed=${speedToken(clip.speed_shift)} vol=${clip.volume ?? 0}`;
+}
+function partAttrs(part, item, textPreviewLength) {
+	if (part.video_clip != null) return clipAttrs(part.video_clip);
+	if (part.speech != null) return `${anchorToken(item.time_position)} dur=${part.speech.media_duration_ms ?? 0}`;
+	if (part.caption != null) {
+		const preview = truncateText(part.caption.text ?? "", textPreviewLength);
+		return `${anchorToken(item.time_position)} text="${preview}"`;
+	}
+	if (part.bgm != null) return `vol=${part.bgm.volume ?? 0}`;
+	return "";
+}
+/**
+* Render a `VideoDocument` as compact text: one header line plus one row per
+* timeline part (optionally filtered by `onlyPartIds`). Deterministic and
+* side-effect free — same document always yields the same string.
+*/
+function renderCompactProjection(document, options) {
+	const onlyPartIds = options?.onlyPartIds;
+	const textPreviewLength = options?.textPreviewLength ?? DEFAULT_TEXT_PREVIEW_LENGTH;
+	const solved = solveVideoDocument(document);
+	const library = document.part_library ?? {};
+	const tracks = document.tracks ?? [];
+	let totalParts = 0;
+	const rows = [];
+	for (const track of tracks) {
+		const partsKind = track.parts_kind;
+		if (partsKind == null) continue;
+		const lane = laneLabel(partsKind);
+		const tag = kindTag(partsKind);
+		for (const item of track.items ?? []) {
+			totalParts += 1;
+			const partId = item.part_id;
+			if (onlyPartIds != null && !onlyPartIds.has(partId)) continue;
+			const part = library[partId];
+			if (part == null) continue;
+			const abs = solved.absByPartId.get(partId) ?? 0;
+			const dur = effectiveDurationMs(part, solved.durationMs);
+			const attrs = partAttrs(part, item, textPreviewLength);
+			rows.push(`${tag} ${partId} ${lane} [${abs},${abs + dur}) ${attrs}`);
+		}
+	}
+	return [`# draft=${document.meta.draft_id ?? ""} v=${document.meta.version ?? 0} duration=${solved.durationMs} parts=${totalParts} shown=${rows.length}`, ...rows].join("\n");
+}
+//#endregion
+//#region src/sandbox/preview.ts
+/**
+* Collect part ids referenced by a journal for compact preview filtering.
+* Walks known id-shaped payload keys (宁多勿少) and unions `generated_ids`.
+*/
+const PART_ID_KEYS = new Set([
+	"clip_id",
+	"clip_ids",
+	"before_clip_id",
+	"after_clip_id",
+	"speech_id",
+	"speech_ids",
+	"speech_part_id",
+	"caption_id",
+	"caption_ids",
+	"bgm_id",
+	"anchor_part_id",
+	"part_id",
+	"body_part_id"
+]);
+/** Extract every part id a journal entry touches (payload refs + minted ids). */
+function collectAffectedPartIds(journal) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of journal) {
+		for (const generated of entry.generated_ids ?? []) if (generated.length > 0) ids.add(generated);
+		collectFromValue(entry.payload, ids);
+	}
+	return ids;
+}
+function collectFromValue(value, ids) {
+	if (value == null) return;
+	if (Array.isArray(value)) {
+		for (const item of value) collectFromValue(item, ids);
+		return;
+	}
+	if (typeof value !== "object") return;
+	for (const [key, child] of Object.entries(value)) {
+		if (PART_ID_KEYS.has(key)) {
+			if (typeof child === "string" && child.length > 0) ids.add(child);
+			else if (Array.isArray(child)) {
+				for (const item of child) if (typeof item === "string" && item.length > 0) ids.add(item);
+			}
+		}
+		collectFromValue(child, ids);
+	}
+}
+/**
+* Render a ChangePlan preview: header + rows for journal-affected parts only.
+* Empty journal → empty `onlyPartIds` (header alone), matching the T2 contract.
+*/
+function renderPreview(document, journal) {
+	return renderCompactProjection(document, { onlyPartIds: journal.length === 0 ? /* @__PURE__ */ new Set() : collectAffectedPartIds(journal) });
+}
+//#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 kind === "video" || kind === "audio" || kind === "voice" || kind === "image" || kind === "caption" || kind === "axvideo";
+}
+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/invariants.ts
+/** 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));
+	for (const entity of entities) {
+		const current = entity.current();
+		const entityIssues = validateEntity(entity, entityIds);
+		issues.push(...entityIssues);
+		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));
+		if (current.entityKind === "axvideo") issues.push(...validateAXVideoAdmission(entity, index));
+		if (current.entityKind === "caption") issues.push(...validateCaptionAsset(entity, index));
+		issues.push(...validateSequenceComposition(entity));
+	}
+	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 issues = [];
+	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"
+	}];
+}
+function validateCaptionAsset(caption, index) {
+	if (ofKind([...index.relationsOf(caption)], "physical-asset").some((relation) => relation.other(caption)?.deref()?.current().entityKind === "asset")) return [];
+	return [{
+		code: "caption_asset_required",
+		entityId: caption.entityId,
+		message: "Caption must have a Physical Asset Relation"
+	}];
+}
+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.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");
+	switch (entity.entityKind) {
+		case "track":
+			validateOptionalField(value, "hidden", "boolean", problems);
+			validateOptionalField(value, "role", "string", problems);
+			break;
+		case "video":
+		case "audio":
+		case "voice":
+		case "caption":
+			validateSequencePayload(value, "bounded", "native", problems);
+			break;
+		case "image":
+			validateSequencePayload(value, "unbounded", "constant", problems);
+			break;
+		case "axvideo":
+			validateSequencePayload(value, "bounded", "derived", problems);
+			break;
+		case "sequence-marker":
+			validateMarkerPayload(value, problems);
+			break;
+		case "audio-script":
+		case "phonetic-script":
+			validateScriptPayload(value, problems);
+			break;
+		case "timeline":
+		case "clip":
+		case "asset":
+		case "viewport": 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\"");
+}
+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`);
+}
+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;
+		}
+		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 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 === "entityId") && !isOwnedLocalIdPath(entityKind, path) && isEntityIdFieldName(key)) paths.push(path);
+		visitPeerEntityIdPaths(child, entityKind, path, ancestors, paths);
+	}
+	ancestors.delete(value);
+}
+function collectPeerEntityValuePaths(value, ownEntityId, entityIds) {
+	const paths = [];
+	visitPeerEntityValues(value, ownEntityId, entityIds, "", /* @__PURE__ */ new Set(), paths);
+	return paths;
+}
+function visitPeerEntityValues(value, ownEntityId, entityIds, path, ancestors, paths) {
+	if (typeof value === "string") {
+		if (value !== ownEntityId && entityIds.has(value)) 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, ownEntityId, entityIds, `${path}[${index}]`, ancestors, paths);
+	else for (const [key, child] of Object.entries(value)) {
+		if (path.length === 0 && (key === "entityId" || key === "entityKind")) continue;
+		visitPeerEntityValues(child, ownEntityId, entityIds, path.length === 0 ? key : `${path}.${key}`, ancestors, paths);
+	}
+	ancestors.delete(value);
+}
+function isOwnedLocalIdPath(entityKind, path) {
+	if (path === "lifecycle.actorId") return true;
+	if ((entityKind === "audio-script" || entityKind === "phonetic-script") && /^segments\[\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/json-values.ts
+function isJsonObject(value) {
+	return isJsonValue(value, /* @__PURE__ */ new Set()) && !Array.isArray(value) && value !== null;
+}
+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;
+	const prototype = Object.getPrototypeOf(value);
+	if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) 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;
+}
+//#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 phoneticScriptProvenanceRelationSpec = metadataSpec("phonetic-script-provenance", "phonetic-script", "audio-script", isSegmentAlignmentMetadata);
+const captionProvenanceRelationSpec = metadataSpec("caption-provenance", "caption", "audio-script", isSegmentAlignmentMetadata);
+const captionAlignmentRelationSpec = Object.freeze({
+	kind: "caption-alignment",
+	validateEndpoints: (endpoints) => hasKinds(endpoints, new Set(["caption"]), new Set(["audio", "voice"])),
+	validateMetadata: isCaptionAlignmentMetadata
+});
+/** 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,
+	phoneticScriptProvenanceRelationSpec,
+	captionProvenanceRelationSpec,
+	captionAlignmentRelationSpec
+]);
+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 isSegmentAlignmentMetadata(value) {
+	return isJsonObject(value) && Object.hasOwn(value, "segmentAlignment");
+}
+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 })");
+		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
+		});
+	}
+	/**
+	* 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) {
+		const entity = decodeEntityRow(row, extensionEntityKinds, issues);
+		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 ../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 src/entity/entity-sandbox.ts
+const ASSET_SOURCE_KEY = "external";
+const MEMOTA_SYSTEM = "memota";
+/** Mutable entity/relation draft whose only durable product is an explicit command plan. */
+var EntitySandbox = class {
+	original;
+	idFactory;
+	onCommand;
+	onTruncate;
+	state;
+	commands = [];
+	entities;
+	relations;
+	constructor(options) {
+		this.original = cloneSnapshot(options.state ?? {
+			revision: 0,
+			entities: [],
+			relations: []
+		});
+		this.state = cloneSnapshot(this.original);
+		this.idFactory = options.idFactory;
+		this.onCommand = options.onCommand;
+		this.onTruncate = options.onTruncate;
+		this.entities = this.buildEntityFacade();
+		this.relations = this.buildRelationFacade();
+	}
+	get commandCount() {
+		return this.commands.length;
+	}
+	getCommands() {
+		return this.commands;
+	}
+	rollbackTo(index) {
+		if (!Number.isInteger(index) || index < 0 || index > this.commands.length) throw new Error(`rollbackTo: entity checkpoint index ${index} is past journal length ${this.commands.length}`);
+		const prefix = this.commands.slice(0, index);
+		this.state = cloneSnapshot(this.original);
+		for (const command of prefix) this.apply(command, false);
+		this.commands.length = 0;
+		this.commands.push(...prefix);
+		this.onTruncate?.(index);
+	}
+	buildPlan() {
+		decodeEntityRelationRows(toDslRows(this.state), numericMarkerComparators);
+		return {
+			base_revision: this.original.revision,
+			commands: this.commands.slice(),
+			rows: cloneSnapshot(this.state)
+		};
+	}
+	renderPreview() {
+		const lines = [`Entity plan: base_revision=${this.original.revision} commands=${this.commands.length} entities=${this.state.entities.length} relations=${this.state.relations.length}`];
+		for (const command of this.commands) if (command.kind === "create-entity") lines.push(`+ entity ${command.entity.entity_id} kind=${command.entity.entity_kind}`);
+		else if (command.relation.relation_kind === "generated") lines.push(`+ relation ${command.relation.relation_id} generated(output=${command.relation.endpoint_0_entity_id}, input=${command.relation.endpoint_1_entity_id})`);
+		else lines.push(`+ relation ${command.relation.relation_id} kind=${command.relation.relation_kind} endpoints=${command.relation.endpoint_0_entity_id},${command.relation.endpoint_1_entity_id}`);
+		return lines.join("\n");
+	}
+	buildEntityFacade() {
+		return {
+			list: () => clone(this.state.entities),
+			get: (entityId) => {
+				const entity = this.state.entities.find((candidate) => candidate.entity_id === entityId);
+				return entity == null ? null : clone(entity);
+			},
+			findByAssetId: (assetId) => {
+				assertTrimmed(assetId, "assetId");
+				return clone(this.state.entities.filter((entity) => entity.entity_kind === "asset" && isImportedMemotaAsset(entity.payload, assetId)));
+			},
+			create: (input) => this.createEntity(input),
+			importAsset: (input) => this.importAsset(input)
+		};
+	}
+	buildRelationFacade() {
+		return {
+			list: () => clone(this.state.relations),
+			of: (entityId, relationKind) => {
+				assertTrimmed(entityId, "entityId");
+				if (relationKind !== void 0 && !builtInRelationSpecs.some((spec) => spec.kind === relationKind)) throw new Error(`Unknown Relation kind "${relationKind}"`);
+				return clone(this.state.relations.filter((relation) => (relation.endpoint_0_entity_id === entityId || relation.endpoint_1_entity_id === entityId) && (relationKind === void 0 || relation.relation_kind === relationKind)));
+			},
+			link: (input) => this.link(input),
+			linkGenerated: (input) => this.linkGenerated(input)
+		};
+	}
+	createEntity(input) {
+		if (!isKnownEntityKind(input.entity_kind)) throw new Error(`Unknown or extension Entity kind "${String(input.entity_kind)}"`);
+		const payload = clone(input.payload);
+		if (!isJsonObject(payload)) throw new Error("Entity payload must contain only JSON values");
+		const entityId = input.entity_id ?? this.idFactory("entity");
+		assertTrimmed(entityId, "entity_id");
+		const entity = {
+			entity_id: entityId,
+			entity_kind: input.entity_kind,
+			payload
+		};
+		entityToRow({
+			...entity.payload,
+			entityId: createEntityId(entityId),
+			entityKind: entity.entity_kind
+		});
+		this.record({
+			kind: "create-entity",
+			entity
+		});
+		return entityId;
+	}
+	importAsset(input) {
+		assertTrimmed(input.asset_id, "asset_id");
+		const payload = input.payload === void 0 ? {} : clone(input.payload);
+		if (!isJsonObject(payload)) throw new Error("Asset payload must contain only JSON values");
+		return this.createEntity({
+			...input.entity_id !== void 0 ? { entity_id: input.entity_id } : {},
+			entity_kind: "asset",
+			payload: {
+				...payload,
+				[ASSET_SOURCE_KEY]: {
+					system: MEMOTA_SYSTEM,
+					key: input.asset_id
+				}
+			}
+		});
+	}
+	link(input) {
+		if (input.relation_kind === "generated") throw new Error("Author generated Relations with relations.linkGenerated({ output_entity_id, input_entity_id })");
+		const spec = builtInRelationSpecs.find((candidate) => candidate.kind === input.relation_kind);
+		if (spec == null) throw new Error(`Unknown Relation kind "${String(input.relation_kind)}"`);
+		const relation = this.relationFromInput(input, input.relation_kind);
+		const [first, second] = this.refsFor(relation);
+		new BiRelationIndex().link({
+			relationId: createRelationId(relation.relation_id),
+			spec,
+			endpoints: [first, second],
+			metadata: relation.metadata,
+			trace: relation.trace
+		});
+		this.record({
+			kind: "link-relation",
+			relation
+		});
+		return relation.relation_id;
+	}
+	linkGenerated(input) {
+		const relation = this.relationFromInput({
+			...input.relation_id !== void 0 ? { relation_id: input.relation_id } : {},
+			endpoint_0_entity_id: input.output_entity_id,
+			endpoint_1_entity_id: input.input_entity_id,
+			metadata: {},
+			...input.trace !== void 0 ? { trace: input.trace } : {}
+		}, "generated");
+		const [output, source] = this.refsFor(relation);
+		new BiRelationIndex().linkGenerated({
+			relationId: createRelationId(relation.relation_id),
+			output,
+			input: source,
+			trace: relation.trace
+		});
+		this.record({
+			kind: "link-relation",
+			relation
+		});
+		return relation.relation_id;
+	}
+	relationFromInput(input, relationKind) {
+		const relationId = input.relation_id ?? this.idFactory("relation");
+		assertTrimmed(relationId, "relation_id");
+		assertTrimmed(input.endpoint_0_entity_id, "endpoint_0_entity_id");
+		assertTrimmed(input.endpoint_1_entity_id, "endpoint_1_entity_id");
+		const metadata = clone(input.metadata ?? {});
+		const trace = clone(input.trace ?? {});
+		if (!isJsonObject(metadata) || !isJsonObject(trace)) throw new Error("Relation metadata and trace must contain only JSON values");
+		return {
+			relation_id: relationId,
+			relation_kind: relationKind,
+			endpoint_0_entity_id: input.endpoint_0_entity_id,
+			endpoint_1_entity_id: input.endpoint_1_entity_id,
+			metadata,
+			trace
+		};
+	}
+	refsFor(relation) {
+		const first = this.state.entities.find((entity) => entity.entity_id === relation.endpoint_0_entity_id);
+		const second = this.state.entities.find((entity) => entity.entity_id === relation.endpoint_1_entity_id);
+		if (first == null || second == null) {
+			const missing = [first == null ? relation.endpoint_0_entity_id : null, second == null ? relation.endpoint_1_entity_id : null].filter((value) => value != null).join(", ");
+			throw new Error(`Relation references missing Entity id(s): ${missing}`);
+		}
+		return [createEntityRef(toDslEntity(first)), createEntityRef(toDslEntity(second))];
+	}
+	record(command) {
+		this.apply(command, true);
+		this.commands.push(clone(command));
+		this.onCommand?.(clone(command));
+	}
+	apply(command, enforceIdentity) {
+		if (command.kind === "create-entity") {
+			if (enforceIdentity && this.state.entities.some((entity) => entity.entity_id === command.entity.entity_id)) throw new Error(`Entity id "${command.entity.entity_id}" already exists`);
+			this.state.entities.push(clone(command.entity));
+			return;
+		}
+		if (enforceIdentity && this.state.relations.some((relation) => relation.relation_id === command.relation.relation_id)) throw new Error(`Relation id "${command.relation.relation_id}" already exists`);
+		this.state.relations.push(clone(command.relation));
+	}
+};
+function isImportedMemotaAsset(payload, assetId) {
+	const external = payload[ASSET_SOURCE_KEY];
+	return external != null && !Array.isArray(external) && typeof external === "object" && external.system === MEMOTA_SYSTEM && external.key === assetId;
+}
+function toDslEntity(entity) {
+	return {
+		...clone(entity.payload),
+		entityId: createEntityId(entity.entity_id),
+		entityKind: entity.entity_kind
+	};
+}
+function toDslRows(state) {
+	return {
+		entities: state.entities.map((entity) => ({
+			entityId: createEntityId(entity.entity_id),
+			entityKind: entity.entity_kind,
+			payload: clone(entity.payload)
+		})),
+		relations: state.relations.map((relation) => ({
+			relationId: createRelationId(relation.relation_id),
+			relationKind: relation.relation_kind,
+			endpoint0EntityId: createEntityId(relation.endpoint_0_entity_id),
+			endpoint1EntityId: createEntityId(relation.endpoint_1_entity_id),
+			metadata: clone(relation.metadata),
+			trace: clone(relation.trace)
+		}))
+	};
+}
+function cloneSnapshot(state) {
+	return clone(state);
+}
+function clone(value) {
+	return structuredClone(value);
+}
+function assertTrimmed(value, label) {
+	if (typeof value !== "string" || value.length === 0 || value.trim() !== value) throw new Error(`${label} must be a non-empty trimmed string`);
+}
+const numericMarkerComparators = { compareMarkerPoints: (_marker, _range, left, right) => {
+	if (typeof left !== "number" || !Number.isFinite(left) || typeof right !== "number" || !Number.isFinite(right)) throw new Error("Sequence Marker points require finite numeric coordinates in the entity sandbox");
+	return left - right;
+} };
+//#endregion
+//#region src/sandbox/script-session.ts
+const LOG_LINE_MAX = 2e3;
+const LOG_LINE_CAP = 1e3;
+const LOG_BYTE_CAP = 64 * 1024;
+const TRUNCATE_MARK = "[truncated]";
+const LOG_TRUNCATED = "[log truncated]";
+const ENTITY_CHECKPOINT_INDEX = Symbol("entityCheckpointIndex");
+/** Session core for one forked document; globals stay identity-stable across rollback. */
+var EditSandboxSession = class {
+	original;
+	idFactory;
+	onEntry;
+	onLog;
+	onTruncate;
+	entitySandbox;
+	current;
+	/** Adapter journal length already accounted for — new slices are real commits. */
+	adapterJournalSeen = 0;
+	entries = [];
+	logs = [];
+	logBytes = 0;
+	logCapped = false;
+	edit;
+	timeline;
+	entities;
+	relations;
+	console;
+	checkpoint;
+	rollbackTo;
+	constructor(document, options) {
+		this.original = structuredClone(document);
+		this.idFactory = options?.idFactory;
+		this.onEntry = options?.onEntry;
+		this.onLog = options?.onLog;
+		this.onTruncate = options?.onTruncate;
+		this.entitySandbox = new EntitySandbox({
+			state: options?.entityState,
+			idFactory: options?.domainIdFactory ?? (() => {
+				throw new Error("Entity id factory is unavailable in this sandbox host");
+			}),
+			onCommand: options?.onEntityCommand,
+			onTruncate: options?.onEntityTruncate
+		});
+		this.current = this.boot(structuredClone(this.original));
+		this.adapterJournalSeen = this.current.adapter.journal.length;
+		this.edit = this.buildEditFacade();
+		this.timeline = this.buildTimelineFacade();
+		this.entities = this.entitySandbox.entities;
+		this.relations = this.entitySandbox.relations;
+		this.console = this.buildConsoleShim();
+		this.checkpoint = () => {
+			const checkpoint = { index: this.entries.length };
+			Object.defineProperty(checkpoint, ENTITY_CHECKPOINT_INDEX, {
+				value: this.entitySandbox.commandCount,
+				enumerable: false
+			});
+			return checkpoint;
+		};
+		this.rollbackTo = (cp) => this.doRollbackTo(cp);
+	}
+	/** Assemble a ChangePlan from the self-maintained journal + current preview. */
+	buildPlan(baseVersion) {
+		const entityCommands = this.entitySandbox.getCommands();
+		if (this.entries.length > 0 && entityCommands.length > 0) throw new Error("A sandbox plan cannot mix timeline and entity mutations; run and commit them as separate plans");
+		const entityPlan = this.entitySandbox.buildPlan();
+		const planKind = entityCommands.length > 0 ? "entities" : "timeline";
+		return {
+			plan_kind: planKind,
+			doc_id: this.original.meta.draft_id ?? "",
+			base_version: baseVersion,
+			ops: this.entries.slice(),
+			entity_base_revision: entityPlan.base_revision,
+			entity_commands: entityPlan.commands,
+			...planKind === "entities" ? { entity_rows: entityPlan.rows } : {},
+			preview: planKind === "entities" ? this.entitySandbox.renderPreview() : renderPreview(this.current.adapter.snapshot(), this.entries),
+			logs: this.logs.slice()
+		};
+	}
+	getEntries() {
+		return this.entries;
+	}
+	getLogs() {
+		return this.logs;
+	}
+	boot(document) {
+		const sandbox = createEditSandbox(document, this.idFactory != null ? { idFactory: this.idFactory } : void 0);
+		return {
+			adapter: sandbox.adapter,
+			editor: sandbox.editor
+		};
+	}
+	doRollbackTo(cp) {
+		if (cp.index > this.entries.length) throw new Error(`rollbackTo: checkpoint index ${cp.index} is past journal length ${this.entries.length}`);
+		const prefix = this.entries.slice(0, cp.index);
+		const next = this.boot(structuredClone(this.original));
+		replayJournalSync(next.adapter, prefix);
+		this.entries.length = 0;
+		this.entries.push(...prefix);
+		this.current = next;
+		this.adapterJournalSeen = next.adapter.journal.length;
+		this.onTruncate?.(prefix.length);
+		const entityIndex = cp[ENTITY_CHECKPOINT_INDEX];
+		if (entityIndex !== void 0) this.entitySandbox.rollbackTo(entityIndex);
+	}
+	captureNewEntries() {
+		const journal = this.current.adapter.journal;
+		if (journal.length <= this.adapterJournalSeen) return;
+		const fresh = journal.slice(this.adapterJournalSeen);
+		this.adapterJournalSeen = journal.length;
+		for (const entry of fresh) {
+			this.entries.push(entry);
+			this.onEntry?.(entry);
+		}
+	}
+	appendLog(line) {
+		if (this.logCapped) return;
+		if (this.logs.length >= LOG_LINE_CAP || this.logBytes >= LOG_BYTE_CAP) {
+			this.logs.push(LOG_TRUNCATED);
+			this.logCapped = true;
+			this.onLog?.(LOG_TRUNCATED);
+			return;
+		}
+		let out = line;
+		if (out.length > LOG_LINE_MAX) out = `${out.slice(0, LOG_LINE_MAX - 11)}${TRUNCATE_MARK}`;
+		this.logs.push(out);
+		this.logBytes += out.length;
+		this.onLog?.(out);
+	}
+	buildConsoleShim() {
+		const write = (...args) => {
+			this.appendLog(args.map(formatLogArg).join(" "));
+		};
+		return {
+			log: write,
+			info: write,
+			warn: write,
+			error: write
+		};
+	}
+	buildEditFacade() {
+		const wrap = (method) => async (input) => {
+			await method(this.current.editor, input);
+			this.captureNewEntries();
+		};
+		return {
+			addSpeeches: wrap((e, i) => e.addSpeeches(i)),
+			addVideoClips: async (input) => {
+				const needsAppend = input.before_clip_id == null && input.after_clip_id == null && input.clips.some((clip) => clip.start_ms == null);
+				const appendAt = this.timeline.snapshot().timeline?.duration_ms ?? 0;
+				const normalized = needsAppend ? {
+					...input,
+					clips: input.clips.map((clip) => clip.start_ms == null ? {
+						...clip,
+						start_ms: appendAt
+					} : clip)
+				} : input;
+				await this.current.editor.addVideoClips(normalized);
+				this.captureNewEntries();
+			},
+			adjustBgmVolume: wrap((e, i) => e.adjustBgmVolume(i)),
+			adjustSpeechVolume: wrap((e, i) => e.adjustSpeechVolume(i)),
+			adjustVideoClipDuration: wrap((e, i) => e.adjustVideoClipDuration(i)),
+			adjustVideoClipVolume: wrap((e, i) => e.adjustVideoClipVolume(i)),
+			changeSpeechScript: wrap((e, i) => e.changeSpeechScript(i)),
+			changeSpeechVoice: wrap((e, i) => e.changeSpeechVoice(i)),
+			deleteBgm: wrap((e, i) => e.deleteBgm(i)),
+			deleteSpeeches: wrap((e, i) => e.deleteSpeeches(i)),
+			deleteVideoClips: wrap((e, i) => e.deleteVideoClips(i)),
+			moveSpeeches: wrap((e, i) => e.moveSpeeches(i)),
+			moveVideoClips: wrap((e, i) => e.moveVideoClips(i)),
+			moveVideoClipsByAnchor: wrap((e, i) => e.moveVideoClipsByAnchor(i)),
+			replaceVideoClipContent: wrap((e, i) => e.replaceVideoClipContent(i)),
+			replaceVideoClipSequence: wrap((e, i) => e.replaceVideoClipSequence(i)),
+			setBgm: wrap((e, i) => e.setBgm(i)),
+			setCaptionStyle: wrap((e, i) => e.setCaptionStyle(i)),
+			setCaptionVisibility: wrap((e, i) => e.setCaptionVisibility(i)),
+			setVideoClipSpeedShift: wrap((e, i) => e.setVideoClipSpeedShift(i))
+		};
+	}
+	buildTimelineFacade() {
+		return {
+			snapshot: () => fromVideoDocument(this.current.adapter.snapshot()),
+			clipsInRange: (startMs, endMs) => this.clipsInRange(startMs, endMs),
+			part: (id) => this.part(id)
+		};
+	}
+	clipsInRange(startMs, endMs) {
+		const document = this.current.adapter.snapshot();
+		const solved = solveVideoDocument(document);
+		const library = document.part_library ?? {};
+		const main = document.tracks?.find((track) => track.parts_kind === "video_clip");
+		const out = [];
+		for (const item of main?.items ?? []) {
+			const id = item.part_id;
+			if (id == null) continue;
+			const clip = library[id]?.video_clip;
+			if (clip == null) continue;
+			const start = solved.absByPartId.get(id) ?? 0;
+			const duration = effectiveVideoClipDurationMs(clip);
+			const end = start + duration;
+			const mid = start + duration / 2;
+			if (!(mid >= startMs && mid < endMs)) continue;
+			out.push({
+				id,
+				start_ms: start,
+				end_ms: end,
+				duration_ms: duration,
+				speed_shift: clip.speed_shift,
+				volume: clip.volume,
+				media_id: clip.origin_media_id
+			});
+		}
+		return out;
+	}
+	part(id) {
+		const document = this.current.adapter.snapshot();
+		const part = (document.part_library ?? {})[id];
+		if (part == null) return null;
+		let lane = "main";
+		let kind = "video_clip";
+		for (const track of document.tracks ?? []) {
+			if (!(track.items ?? []).some((item) => item.part_id === id)) continue;
+			const partsKind = track.parts_kind ?? "video_clip";
+			kind = partsKind;
+			lane = partsKind === "video_clip" ? "main" : partsKind;
+			break;
+		}
+		const solved = solveVideoDocument(document);
+		const start = solved.absByPartId.get(id) ?? 0;
+		let duration = 0;
+		if (part.video_clip != null) duration = effectiveVideoClipDurationMs(part.video_clip);
+		else if (part.speech != null) duration = part.speech.media_duration_ms ?? 0;
+		else if (part.caption != null) duration = part.caption.initial_duration_ms ?? 0;
+		else if (part.bgm != null) duration = solved.durationMs;
+		return {
+			id,
+			kind,
+			lane,
+			start_ms: start,
+			end_ms: start + duration,
+			duration_ms: duration,
+			part
+		};
+	}
+};
+function formatLogArg(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) return String(value);
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "[unstringifiable]";
+	}
+}
+/**
+* Synchronous journal replay for rollback. Editor methods are `async` only for
+* interface uniformity — their bodies complete before the Promise is returned,
+* so voiding the call applies mutations in-order without yielding.
+*/
+function replayJournalSync(adapter, journal) {
+	const queue = [];
+	const idFactory = (_prefix) => {
+		const id = queue.shift();
+		if (id == null) throw new Error("unrecorded id");
+		return id;
+	};
+	const editor = new SemanticEditor(adapter, new SchemaValidator(), idFactory);
+	for (const entry of journal) {
+		queue.push(...entry.generated_ids ?? []);
+		const payload = entry.payload;
+		switch (entry.kind) {
+			case "MoveVideoClips":
+				editor.moveVideoClips(payload);
+				break;
+			case "MoveVideoClipsByAnchor":
+				editor.moveVideoClipsByAnchor(payload);
+				break;
+			case "DeleteVideoClips":
+				editor.deleteVideoClips(payload);
+				break;
+			case "AddVideoClips":
+				editor.addVideoClips(payload);
+				break;
+			case "AdjustVideoClipVolume":
+				editor.adjustVideoClipVolume(payload);
+				break;
+			case "SetVideoClipSpeedShift":
+				editor.setVideoClipSpeedShift(payload);
+				break;
+			case "ReplaceVideoClipContent":
+				editor.replaceVideoClipContent(payload);
+				break;
+			case "ReplaceVideoClipSequence":
+				editor.replaceVideoClipSequence(payload);
+				break;
+			case "AdjustVideoClipDuration":
+				editor.adjustVideoClipDuration(payload);
+				break;
+			case "AddSpeeches":
+				editor.addSpeeches(payload);
+				break;
+			case "DeleteSpeeches":
+				editor.deleteSpeeches(payload);
+				break;
+			case "MoveSpeeches":
+				editor.moveSpeeches(payload);
+				break;
+			case "ChangeSpeechScript":
+				editor.changeSpeechScript(payload);
+				break;
+			case "ChangeSpeechVoice":
+				editor.changeSpeechVoice(payload);
+				break;
+			case "AdjustSpeechVolume":
+				editor.adjustSpeechVolume(payload);
+				break;
+			case "SetCaptionVisibility":
+				editor.setCaptionVisibility(payload);
+				break;
+			case "SetCaptionStyle":
+				editor.setCaptionStyle(payload);
+				break;
+			case "SetBgm":
+				editor.setBgm(payload);
+				break;
+			case "DeleteBgm":
+				editor.deleteBgm(payload);
+				break;
+			case "AdjustBgmVolume":
+				editor.adjustBgmVolume(payload);
+				break;
+			default: {
+				const _exhaustive = entry.kind;
+				throw new Error(`replayJournalSync: unsupported kind ${String(_exhaustive)}`);
+			}
+		}
+		if (queue.length > 0) throw new Error("unconsumed ids");
+	}
+}
+//#endregion
+export { renderCompactProjection as i, collectAffectedPartIds as n, renderPreview as r, EditSandboxSession as t };
+
+//# sourceMappingURL=script-session-BF44uKv_.mjs.map