@mengine/medeo-client 2.1.0 → 2.1.1-dsl.1

package/dist/video-draft-types-TXRv3wS6.js

@@ -0,0 +1,1419 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import { Cursor } from "loro-crdt";
+//#region ../medeo-dsl/src/ids.ts
+function bytesToBase64url(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function base64urlToBytes(value) {
+	if (!/^[A-Za-z0-9_-]+$/.test(value) || value.length % 4 === 1) throw new Error("Invalid base64url");
+	const bytes = Uint8Array.from(atob(value.replaceAll("-", "+").replaceAll("_", "/")), (c) => c.charCodeAt(0));
+	if (bytesToBase64url(bytes) !== value) throw new Error("Non-canonical base64url");
+	return bytes;
+}
+function tupleHash(tuple) {
+	return bytesToBase64url(sha256(new TextEncoder().encode(JSON.stringify(tuple))));
+}
+function resourceId(kind, system, key) {
+	return `${kind}:${tupleHash([system, key])}`;
+}
+function relationId(table, value) {
+	const v = value;
+	switch (table) {
+		case "clip-source-relations": return `cs:${v.clipId}`;
+		case "time-anchor-relations": return `ta:${v.from}`;
+		case "caption-content-relations": return `cc:${v.captionId}`;
+		case "caption-alignment-relations": return `ca:${v.captionId}`;
+		case "voice-timbre-relations": return `voice-timbre:${tupleHash([v.recordingId, v.voiceId])}`;
+		case "derived-from-relations": return `derived-from:${tupleHash([v.entityId, v.sourceId])}`;
+		case "from-asset-relations": return `from-asset:${v.audioScriptId}`;
+		case "to-asset-relations": return `to-asset:${v.audioScriptId}`;
+	}
+	throw new Error(`Unknown relation table: ${table}`);
+}
+const defaultIdFactory = (kind) => `${kind}_${globalThis.crypto.randomUUID()}`;
+const resourceKinds = {
+	"media-entities": "media",
+	"voice-entities": "voice",
+	"asset-entities": "asset"
+};
+/** A resource row's ID is derived from its locator, so one external resource is one entity. */
+function assertResourceIdentity(table, id, value) {
+	const kind = resourceKinds[table];
+	if (kind && id !== resourceId(kind, value.system, value.key)) throw new Error("Resource identity does not match locator");
+}
+/** A relation row's ID is derived from its uniqueness key. */
+function assertRelationIdentity(table, id, value) {
+	if (id !== relationId(table, value)) throw new Error("Relation ID does not match endpoints");
+}
+//#endregion
+//#region ../medeo-dsl/src/fields.ts
+const string = (v) => typeof v === "string";
+const nonempty = (v) => string(v) && v.length > 0;
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+const integer = (v) => typeof v === "number" && Number.isSafeInteger(v);
+const nonnegative = (v) => integer(v) && v >= 0;
+const positive = (v) => integer(v) && v > 0;
+const oneOf = (...values) => (v) => values.includes(v);
+const required = (check) => ({ check });
+const optional$1 = (check) => ({
+	check,
+	optional: true
+});
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Cursor);
+}
+function assertId(value) {
+	if (!nonempty(value) || [
+		"$cid",
+		"__proto__",
+		"constructor",
+		"prototype"
+	].includes(value)) throw new Error("Expected a nonempty, non-reserved ID");
+}
+function validLanguage(value) {
+	if (typeof value !== "string") return false;
+	if (/^x(?:-[a-z0-9]{1,8})+$/i.test(value)) return true;
+	try {
+		return value.length > 0 && Intl.getCanonicalLocales(value).length === 1;
+	} catch {
+		return false;
+	}
+}
+function object(fields) {
+	return (v) => {
+		try {
+			checkFields(v, fields);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+}
+function checkFields(value, fields, partial = false) {
+	if (!isRecord(value)) throw new Error("Expected an object");
+	for (const key of Object.keys(value)) if (!Object.hasOwn(fields, key)) throw new Error(`Unknown field: ${key}`);
+	for (const [key, field] of Object.entries(fields)) {
+		if (partial && !Object.hasOwn(value, key)) continue;
+		const v = value[key];
+		if (v === void 0 && field.optional) continue;
+		if (!field.check(v)) throw new Error(`Invalid or missing field: ${key}`);
+	}
+}
+const styleFields = {
+	font: optional$1(object({
+		system: required(oneOf("font-library")),
+		key: required(nonempty)
+	})),
+	fontSize: optional$1(finite),
+	fontColor: optional$1(string),
+	fontWeight: optional$1(finite),
+	entranceAnimation: optional$1(string),
+	entranceAnimationDurationMs: optional$1(nonnegative),
+	strokeColor: optional$1(string),
+	strokeWidth: optional$1(finite),
+	positionX: optional$1(finite),
+	positionY: optional$1(finite)
+};
+const seqMarkerFields = {
+	inMs: required(nonnegative),
+	outMs: required(nonnegative),
+	rate: optional$1((v) => finite(v) && v > 0),
+	fillTimeline: optional$1(oneOf(true))
+};
+/** A sequence marker's own fields; the window being nonempty is checked where it is written. */
+function assertSeqMarker(value) {
+	checkFields(value, seqMarkerFields);
+}
+const locator = {
+	system: required(oneOf("memota", "memota-speech")),
+	key: required(nonempty)
+};
+const entityFields = {
+	"timeline-entities": {},
+	"track-entities": {
+		role: required(oneOf("video_clip", "speech", "caption", "bgm")),
+		hidden: optional$1((v) => typeof v === "boolean")
+	},
+	"clip-entities": {
+		seqMarker: required(object(seqMarkerFields)),
+		volume: optional$1(finite)
+	},
+	"media-entities": {
+		...locator,
+		kind: required(oneOf("video", "audio", "voiceover-recording", "image")),
+		storageKey: optional$1(nonempty),
+		durationMs: optional$1(positive),
+		digest: optional$1(nonempty)
+	},
+	"audio-script-entities": {
+		body: required(string),
+		defaultLanguage: optional$1(validLanguage)
+	},
+	"caption-entities": {
+		text: optional$1(string),
+		style: optional$1(object(styleFields))
+	},
+	"voice-entities": {
+		system: required(oneOf("voice-library")),
+		key: required(nonempty),
+		name: optional$1(string)
+	},
+	"asset-entities": {
+		...locator,
+		storageKey: optional$1(nonempty),
+		digest: optional$1(nonempty)
+	}
+};
+const entityTables = Object.keys(entityFields);
+const relationFields = {
+	"clip-source-relations": {
+		clipId: required(nonempty),
+		sourceId: required(nonempty)
+	},
+	"time-anchor-relations": {
+		from: required(nonempty),
+		to: required(nonempty),
+		offsetMs: required(integer),
+		fallback_abs_ms: required(nonnegative)
+	},
+	"caption-content-relations": {
+		captionId: required(nonempty),
+		audioScriptId: required(nonempty),
+		start: required((v) => v instanceof Cursor),
+		end: required((v) => v instanceof Cursor)
+	},
+	"caption-alignment-relations": {
+		captionId: required(nonempty),
+		mediaId: required(nonempty),
+		startMs: required(nonnegative),
+		endMs: required(nonnegative)
+	},
+	"voice-timbre-relations": {
+		recordingId: required(nonempty),
+		voiceId: required(nonempty)
+	},
+	"derived-from-relations": {
+		entityId: required(nonempty),
+		sourceId: required(nonempty)
+	},
+	"from-asset-relations": {
+		audioScriptId: required(nonempty),
+		assetId: required(nonempty)
+	},
+	"to-asset-relations": {
+		audioScriptId: required(nonempty),
+		assetId: required(nonempty)
+	}
+};
+const relationTables = Object.keys(relationFields);
+function assertEntity(table, value) {
+	checkFields(value, entityFields[table]);
+	if (table === "media-entities") {
+		if (value.kind === "image" && value.durationMs !== void 0) throw new Error("Image has no intrinsic duration");
+		if (value.kind !== "image" && !positive(value.durationMs)) throw new Error("Finite media requires durationMs");
+		if (["audio", "voiceover-recording"].includes(value.kind) && !nonempty(value.storageKey)) throw new Error("Audio requires storageKey");
+	}
+}
+/** Validate only touched fields, so an unrelated edit can proceed in a merged, invalid document. */
+function assertEntityPatch(table, patch, current) {
+	if (!isRecord(patch)) throw new Error("Expected an entity patch");
+	if (table === "audio-script-entities" && Object.hasOwn(patch, "body")) throw new Error("Edit body through the Text adapter");
+	if (table === "caption-entities" && current.style !== void 0 && Object.hasOwn(patch, "style") && patch.style === void 0) throw new Error("Reset individual style fields; retain the style Map");
+	if (table === "caption-entities" && current.text !== void 0 && patch.text !== void 0) throw new Error("Edit Caption text through the Text adapter");
+	const next = mergeFields(current, patch);
+	for (const key of Object.keys(patch)) {
+		const field = entityFields[table][key];
+		if (!field || !field.optional && next[key] === void 0 || next[key] !== void 0 && !field.check(next[key])) throw new Error(`Invalid patch field: ${key}`);
+	}
+	if (table === "media-entities" || table === "voice-entities" || table === "asset-entities") {
+		for (const key of [
+			"system",
+			"key",
+			"kind"
+		]) if (Object.hasOwn(patch, key) && patch[key] !== current[key]) throw new Error(`Resource identity field is immutable: ${key}`);
+	}
+	if (table === "media-entities") {
+		if (Object.hasOwn(patch, "durationMs")) {
+			if (next.kind === "image" ? next.durationMs !== void 0 : !positive(next.durationMs)) throw new Error("durationMs must match the media kind");
+		}
+		if (Object.hasOwn(patch, "storageKey") && ["audio", "voiceover-recording"].includes(next.kind) && !nonempty(next.storageKey)) throw new Error("Audio requires storageKey");
+	}
+}
+function assertRelation(table, value) {
+	checkFields(value, relationFields[table]);
+	for (const [key, endpoint] of Object.entries(value)) if (key.endsWith("Id") || key === "from" || key === "to") assertId(endpoint);
+}
+/** Undefined deletes; nested patches retain sibling fields and an existing empty style Map. */
+function mergeFields(target, patch) {
+	const result = { ...target };
+	for (const [key, value] of Object.entries(patch)) {
+		if ([
+			"$cid",
+			"__proto__",
+			"constructor",
+			"prototype"
+		].includes(key)) throw new Error(`Reserved field: ${key}`);
+		if (value === void 0) delete result[key];
+		else result[key] = isRecord(value) ? mergeFields(isRecord(result[key]) ? result[key] : {}, value) : value;
+	}
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/schema/resolver.js
+function getMapFieldSchema(schema, key) {
+	if (!schema) return void 0;
+	if (Object.prototype.hasOwnProperty.call(schema.definition, key)) return schema.definition[key];
+	if (schema.type === "loro-map" && "catchallType" in schema) return schema.catchallType;
+}
+function getChildSchema(schema, childKey) {
+	if (!schema) return void 0;
+	switch (schema.type) {
+		case "schema":
+		case "loro-map": return childKey === void 0 ? void 0 : getMapFieldSchema(schema, String(childKey));
+		case "loro-list":
+		case "loro-movable-list": return schema.itemSchema;
+		case "loro-tree": return schema.nodeSchema;
+		default: return;
+	}
+}
+function getChildContainerSchema(schema, childKey) {
+	const childSchema = getChildSchema(schema, childKey);
+	if (!childSchema) return void 0;
+	switch (childSchema.type) {
+		case "loro-map":
+		case "loro-list":
+		case "loro-movable-list":
+		case "loro-text":
+		case "loro-tree": return childSchema;
+		default: return;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/constants.js
+const CID_KEY = "$cid";
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/container-inference.js
+function isPlainObjectValue(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && typeof value !== "function";
+}
+function inferContainerTypeFromValue$1(value, defaults) {
+	switch (getContainerValueKind(value)) {
+		case "map": return "Map";
+		case "array": return defaults?.defaultMovableList ? "MovableList" : "List";
+		case "string": return defaults?.defaultLoroText ? "Text" : void 0;
+		default: return;
+	}
+}
+function inferSchemaContainerTypeFromValue(value, defaults) {
+	switch (inferContainerTypeFromValue$1(value, defaults)) {
+		case "Map": return "loro-map";
+		case "List": return "loro-list";
+		case "MovableList": return "loro-movable-list";
+		case "Text": return "loro-text";
+		default: return;
+	}
+}
+function matchesContainerType(containerType, value) {
+	const kind = getContainerValueKind(value);
+	switch (containerType) {
+		case "Map": return kind === "map";
+		case "List":
+		case "MovableList":
+		case "Tree": return kind === "array";
+		case "Text": return kind === "string";
+		default: return false;
+	}
+}
+function getContainerValueKind(value) {
+	if (isPlainObjectValue(value)) return "map";
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "string") return "string";
+	return "other";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/core/utils.js
+/**
+* Utility functions for Loro Mirror core
+*/
+/**
+* Check if a schema has a transform.
+* Distinguishes between the .transform() builder method (function) and an actual
+* TransformDefinition object (with decode/encode functions).
+*/
+function hasTransform(schema) {
+	if (schema === void 0) return false;
+	const t = schema.transform;
+	return t != null && typeof t === "object";
+}
+/**
+* Get the transform from a schema, or undefined if none exists.
+*/
+function getTransform(schema) {
+	if (hasTransform(schema)) return schema.transform;
+}
+/**
+* Get the effective equality strategy for a transform.
+* Default: "reference-equality"
+*/
+function getEqualityStrategy(schema, strategyIfNotTransformable) {
+	const transform = getTransform(schema);
+	if (!transform) return strategyIfNotTransformable;
+	return transform.isEqual ?? "reference-equality";
+}
+/**
+* Apply decode transform to a CRDT value.
+* Null/undefined pass through as-is - transform is only called for real values.
+*/
+function applyDecode(schema, crdtValue) {
+	if (crdtValue === null || crdtValue === void 0) return crdtValue;
+	const transform = getTransform(schema);
+	return transform ? transform.decode(crdtValue) : crdtValue;
+}
+/**
+* Recursively decode JSON values using schema transforms.
+* Mutates in-place. Used for snapshot initialization where toJSON() skips decode.
+*/
+function decodeNestedJsonValues(json, schema) {
+	if (json === null || json === void 0 || !schema) return json;
+	switch (schema.type) {
+		case "loro-map":
+			if (!isObject(json)) return json;
+			for (const key of Object.keys(json)) {
+				const fieldSchema = getChildSchema(schema, key);
+				json[key] = decodeNestedJsonValues(json[key], fieldSchema);
+			}
+			return json;
+		case "loro-list":
+		case "loro-movable-list": {
+			if (!Array.isArray(json)) return json;
+			const itemSchema = getChildSchema(schema);
+			for (let i = 0; i < json.length; i++) json[i] = decodeNestedJsonValues(json[i], itemSchema);
+			return json;
+		}
+		case "loro-tree": {
+			if (!Array.isArray(json)) return json;
+			const nodeSchema = getChildSchema(schema);
+			const walk = (nodes) => {
+				for (const node of nodes) if (node != null && typeof node == "object") {
+					if ("data" in node && node.data !== void 0) node.data = decodeNestedJsonValues(node.data, nodeSchema);
+					if ("children" in node && Array.isArray(node.children)) walk(node.children);
+				}
+			};
+			walk(json);
+			return json;
+		}
+		case "loro-text":
+		case "ignore": return json;
+		default: return applyDecode(schema, json);
+	}
+}
+/**
+* Apply encode transform to a domain value.
+* Null/undefined pass through as-is - transform is only called for real values.
+*/
+function applyEncode(schema, domainValue) {
+	if (domainValue === null || domainValue === void 0) return domainValue;
+	const transform = getTransform(schema);
+	return transform ? transform.encode(domainValue) : domainValue;
+}
+/**
+* Check if two domain values are equal according to the schema's equality strategy.
+*
+* Reference equality is always checked first (performance optimization).
+* If refs match, returns true (no change).
+* If refs differ, behavior depends on isEqual setting.
+*/
+function valuesEqual(schema, oldValue, newValue, strategyIfNotTransformable) {
+	if (oldValue === newValue) return true;
+	const strategy = getEqualityStrategy(schema, strategyIfNotTransformable);
+	if (strategy === "reference-equality") return false;
+	else if (strategy === "encoded-value-equality") return applyEncode(schema, oldValue) === applyEncode(schema, newValue);
+	else if (strategy === "deep-equality") return deepEqual(oldValue, newValue);
+	else return strategy(oldValue, newValue);
+}
+function defineCidProperty(target, cid) {
+	if (!isObject(target) || Object.prototype.hasOwnProperty.call(target, "$cid")) return;
+	Object.defineProperty(target, CID_KEY, { value: cid });
+}
+/**
+* Restore the read-only `$cid` contract on a freshly produced state.
+*
+* `defineCidProperty` stamps `$cid` as `{ writable: false, enumerable: false,
+* configurable: false }`. Immer's `useStrictShallowCopy` preserves the descriptor, but it
+* deliberately rewrites every non-writable data property to `{ writable: true,
+* configurable: true }` so the draft stays mutable — which would leave `$cid` writable on
+* every object Immer copied, letting callers reassign a published `$cid`.
+*
+* Two things keep this proportional to what Immer actually copied rather than to the size
+* of the state:
+*
+* - `prev` is the state `produce` was called with, and Immer shares everything it did not
+*   copy, so a subtree reference-equal to `prev` cannot have been touched.
+* - An already-locked `$cid` means this object was not copied this round, so its children
+*   are the same references they were when it was last hardened and are locked too. This
+*   is what makes a reorder cheap: moved items are shared references that land at a new
+*   index, so `prev` no longer lines up with them, but they are still locked.
+*/
+function hardenCidDescriptors(next, prev, visited) {
+	if (next === prev) return;
+	if (Array.isArray(next)) {
+		if ((visited ?? (visited = /* @__PURE__ */ new Set())).has(next)) return;
+		visited.add(next);
+		const prevArr = Array.isArray(prev) ? prev : void 0;
+		for (let i = 0; i < next.length; i++) hardenCidDescriptors(next[i], prevArr?.[i], visited);
+		return;
+	}
+	if (!isObject(next)) return;
+	const descriptor = Object.getOwnPropertyDescriptor(next, CID_KEY);
+	if (descriptor) {
+		if (!descriptor.configurable) return;
+		if ("value" in descriptor) Object.defineProperty(next, CID_KEY, {
+			value: descriptor.value,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	if ((visited ?? (visited = /* @__PURE__ */ new Set())).has(next)) return;
+	visited.add(next);
+	const prevObj = isObject(prev) ? prev : void 0;
+	for (const key of Object.keys(next)) hardenCidDescriptors(next[key], prevObj?.[key], visited);
+}
+/**
+* Check if a value is an object
+*/
+function isObject(value) {
+	return isPlainObjectValue(value);
+}
+const UNSAFE_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* Recursively removes undefined values from an object.
+* This treats undefined values as non-existent fields.
+* Preserves non-enumerable properties like $cid.
+* Returns the original object if no undefined values are found.
+* Protects against prototype pollution by skipping unsafe keys.
+*/
+function stripUndefined(value) {
+	return stripUndefinedInner(value, 0, void 0);
+}
+/**
+* Depth at which we start recording the recursion path to detect cycles.
+*
+* This runs over the whole state on every `setState`, and tracking every node costs more
+* than the stripping itself. Mirror state is a tree whose depth follows the schema, so a
+* real state never gets near this; only a cycle recurses without bound. Once the path is
+* being recorded, any cycle revisits one of its own nodes within a single lap, so starting
+* late still terminates.
+*/
+const CYCLE_GUARD_DEPTH = 64;
+/**
+* Placeholder for a key that must not reach the rebuilt object: an unsafe key, or one whose
+* value is `undefined` and is therefore treated as a non-existent field.
+*/
+const DROPPED = Symbol("dropped");
+function stripUndefinedInner(value, depth, path) {
+	if (value === void 0) return value;
+	if (Array.isArray(value)) {
+		if (depth >= CYCLE_GUARD_DEPTH) {
+			if ((path ?? (path = /* @__PURE__ */ new Set())).has(value)) return value;
+			path.add(value);
+		}
+		let hasChanges = false;
+		const result = value.map((item) => {
+			const stripped = stripUndefinedInner(item, depth + 1, path);
+			if (stripped !== item) hasChanges = true;
+			return stripped;
+		});
+		path?.delete(value);
+		return hasChanges ? result : value;
+	}
+	if (isObject(value)) {
+		if (depth >= CYCLE_GUARD_DEPTH) {
+			if ((path ?? (path = /* @__PURE__ */ new Set())).has(value)) return value;
+			path.add(value);
+		}
+		const keys = Object.keys(value);
+		const strippedValues = Array.from({ length: keys.length });
+		let changed = false;
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (UNSAFE_KEYS.has(key)) {
+				strippedValues[i] = DROPPED;
+				continue;
+			}
+			const val = value[key];
+			if (val === void 0) {
+				strippedValues[i] = DROPPED;
+				changed = true;
+				continue;
+			}
+			const stripped = stripUndefinedInner(val, depth + 1, path);
+			strippedValues[i] = stripped;
+			if (stripped !== val) changed = true;
+		}
+		path?.delete(value);
+		if (!changed) return value;
+		const result = Object.create(null);
+		const allProps = Object.getOwnPropertyNames(value);
+		for (const key of allProps) {
+			if (UNSAFE_KEYS.has(key)) continue;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor && !descriptor.enumerable) Object.defineProperty(result, key, descriptor);
+		}
+		for (let i = 0; i < keys.length; i++) {
+			const val = strippedValues[i];
+			if (val === DROPPED) continue;
+			Object.defineProperty(result, keys[i], {
+				value: val,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+		}
+		return result;
+	}
+	return value;
+}
+/**
+* Performs a deep equality check between two values
+*/
+function deepEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null || typeof a !== "object" && typeof a !== "function" || typeof b !== "object" && typeof b !== "function") return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+		return true;
+	}
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (a instanceof RegExp && b instanceof RegExp) return a.toString() === b.toString();
+	if (!Array.isArray(a) && !Array.isArray(b)) {
+		const keysA = Object.keys(a);
+		const keysB = Object.keys(b);
+		if (keysA.length !== keysB.length) return false;
+		for (const key of keysA) {
+			if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+			if (!deepEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return false;
+}
+/**
+* Recursively compare the `$cid` markers of two state trees.
+*
+* `deepEqual` only walks enumerable keys, so it cannot see `$cid` (which is stamped as a
+* non-enumerable descriptor). Used by `Mirror.checkStateConsistency` so that a tampered
+* or stale `$cid` is reported as a divergence instead of silently sitting in the state.
+* Only the markers are compared here; value equality is `deepEqual`'s job.
+*/
+function cidsEqual(a, b, seen) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		if (markSeen(a, b, seen ?? (seen = /* @__PURE__ */ new Map())) === "seen") return true;
+		for (let i = 0; i < a.length; i++) if (!cidsEqual(a[i], b[i], seen)) return false;
+		return true;
+	}
+	if (!isObject(a) || !isObject(b)) return true;
+	if (a["$cid"] !== b["$cid"]) return false;
+	if (markSeen(a, b, seen ?? (seen = /* @__PURE__ */ new Map())) === "seen") return true;
+	for (const key of Object.keys(a)) {
+		if (!Object.prototype.hasOwnProperty.call(b, key)) continue;
+		if (!cidsEqual(a[key], b[key], seen)) return false;
+	}
+	return true;
+}
+function markSeen(a, b, seen) {
+	let partners = seen.get(a);
+	if (!partners) {
+		partners = /* @__PURE__ */ new Set();
+		seen.set(a, partners);
+	}
+	if (partners.has(b)) return "seen";
+	partners.add(b);
+	return "new";
+}
+function containerIdToContainerType(containerId) {
+	const parts = containerId.split(":");
+	return parts[parts.length - 1];
+}
+function getRootContainerByType(doc, key, type) {
+	if (type === "Text") return doc.getText(key);
+	else if (type === "List") return doc.getList(key);
+	else if (type === "MovableList") return doc.getMovableList(key);
+	else if (type === "Map") return doc.getMap(key);
+	else if (type === "Tree") return doc.getTree(key);
+	else throw new Error();
+}
+function insertChildToMap(containerId, key, value, inferOptions) {
+	const ct = tryInferContainerType(value, inferOptions);
+	if (ct) return {
+		container: containerId,
+		key,
+		value,
+		kind: "insert-container",
+		childContainerType: ct
+	};
+	return {
+		container: containerId,
+		key,
+		value,
+		kind: "insert"
+	};
+}
+function tryUpdateToContainer(change, toUpdate, schema, inferOptions) {
+	if (!toUpdate) return change;
+	if (change.kind !== "insert" && change.kind !== "set") return change;
+	const effectiveInferOptions = applySchemaToInferOptions(schema, inferOptions);
+	const containerType = schema ? schemaToContainerType(schema) ?? tryInferContainerType(change.value, effectiveInferOptions) : tryInferContainerType(change.value, effectiveInferOptions);
+	if (containerType == null || schema && hasTransform(schema)) {
+		const encodedValue = applyEncode(schema, change.value);
+		return encodedValue !== change.value ? {
+			...change,
+			value: encodedValue
+		} : change;
+	}
+	if (change.kind === "insert") return {
+		container: change.container,
+		key: change.key,
+		value: change.value,
+		kind: "insert-container",
+		childContainerType: containerType
+	};
+	if (change.kind === "set") return {
+		container: change.container,
+		key: change.key,
+		value: change.value,
+		kind: "set-container",
+		childContainerType: containerType
+	};
+	return change;
+}
+function schemaToContainerType(schema) {
+	const containerType = schema.getContainerType();
+	return containerType === null ? void 0 : containerType;
+}
+function tryInferContainerType(value, defaults) {
+	return inferContainerTypeFromValue$1(value, defaults);
+}
+function applySchemaToInferOptions(schema, base) {
+	if (!schema || schema.type !== "any") return base;
+	const next = { ...base };
+	next.defaultLoroText = schema.options.defaultLoroText ?? false;
+	if (schema.options.defaultMovableList !== void 0) next.defaultMovableList = schema.options.defaultMovableList;
+	return next;
+}
+function isValueOfContainerType(containerType, value) {
+	return matchesContainerType(containerType, value);
+}
+function inferContainerTypeFromValue(value, defaults) {
+	return inferSchemaContainerTypeFromValue(value, defaults);
+}
+function isObjectLike(value) {
+	return typeof value === "object";
+}
+function isArrayLike(value) {
+	return Array.isArray(value);
+}
+function isStateAndSchemaOfType(values, stateGuard, schemaGuard) {
+	return stateGuard(values.oldState) && stateGuard(values.newState) && (!values.schema || schemaGuard(values.schema));
+}
+function isTreeID(id) {
+	if (!(typeof id === "string")) return false;
+	return !!id.match(/[0-9]+@[0-9]+/);
+}
+/**
+* Stringify a value safely, handling non-JSON-serializable types.
+* Handles BigInt, Date, RegExp, functions, and custom objects.
+*/
+function safeStringify(value, indent = 2) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	function replacer(val) {
+		if (val === null || val === void 0) return val;
+		if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") return val;
+		if (typeof val === "bigint") return `[BigInt: ${val.toString()}]`;
+		if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
+		if (typeof val === "symbol") return `[Symbol: ${val.description || ""}]`;
+		if (typeof val === "object") {
+			if (seen.has(val)) return "[Circular]";
+			seen.add(val);
+			if (val instanceof Date) return `[Date: ${val.toISOString()}]`;
+			if (val instanceof RegExp) return `[RegExp: ${val.toString()}]`;
+			if (val instanceof Error) return `[Error: ${val.message}]`;
+			if (Array.isArray(val)) return val.map(replacer);
+			const result = {};
+			for (const key of Object.keys(val)) result[key] = replacer(val[key]);
+			return result;
+		}
+		return Object.prototype.toString.call(val);
+	}
+	return JSON.stringify(replacer(value), null, indent);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/schema/validators.js
+const schemaValidationCache = /* @__PURE__ */ new WeakMap();
+function isCacheableValue(value) {
+	return typeof value === "object" && value !== null;
+}
+function isSchemaValidated(schema, value) {
+	if (!isCacheableValue(value)) return false;
+	return schemaValidationCache.get(value)?.has(schema) ?? false;
+}
+function markSchemaValidated(schema, value) {
+	if (!isCacheableValue(value)) return;
+	let cache = schemaValidationCache.get(value);
+	if (!cache) {
+		cache = /* @__PURE__ */ new WeakSet();
+		schemaValidationCache.set(value, cache);
+	}
+	cache.add(schema);
+}
+/**
+* Type guard for LoroMapSchema
+*/
+function isLoroMapSchema(schema) {
+	return !!schema && schema.type === "loro-map";
+}
+/**
+* Type guard for LoroListSchema
+*/
+function isLoroListSchema(schema) {
+	return !!schema && schema.type === "loro-list";
+}
+function isListLikeSchema(schema) {
+	return isLoroListSchema(schema) || isLoroMovableListSchema(schema);
+}
+function isLoroMovableListSchema(schema) {
+	return !!schema && schema.type === "loro-movable-list";
+}
+/**
+* Type guard for RootSchemaType
+*/
+function isRootSchemaType(schema) {
+	return !!schema && schema.type === "schema";
+}
+/**
+* Whether a schema subtree contains any `Ignore` field. Recursive schemas are
+* tolerated (each schema object is visited once).
+*/
+function schemaContainsIgnoreField(schema) {
+	const visited = /* @__PURE__ */ new Set();
+	const walk = (s) => {
+		if (!s || visited.has(s)) return false;
+		visited.add(s);
+		if (s.type === "ignore") return true;
+		switch (s.type) {
+			case "schema":
+			case "loro-map": {
+				const record = s;
+				return Object.values(record.definition).some(walk) || walk(record.catchallType);
+			}
+			case "loro-list":
+			case "loro-movable-list": return walk(s.itemSchema);
+			case "loro-tree": return walk(s.nodeSchema);
+			default: return false;
+		}
+	};
+	return walk(schema);
+}
+/**
+* Type guard for LoroTreeSchema
+*/
+function isLoroTreeSchema(schema) {
+	return !!schema && schema.type === "loro-tree";
+}
+/**
+* Check if a schema is for a Loro container
+*/
+function isContainerSchema(schema) {
+	return !!schema && (schema.type === "loro-map" || schema.type === "loro-list" || schema.type === "loro-text" || schema.type === "loro-movable-list" || schema.type === "loro-tree");
+}
+/**
+* Validate a value against a schema
+*
+* When `options.ignoreUnknownProperties` is true, the root schema check does
+* not reject properties missing from the schema definition — typically
+* written by peers on a newer schema version. (Nested map schemas never
+* reject undeclared properties.)
+*/
+function validateSchema(schema, value, options) {
+	const errors = [];
+	const actualType = schema.type;
+	if (schema.options.required && (value === void 0 || value === null)) {
+		errors.push("Value is required");
+		return {
+			valid: false,
+			errors
+		};
+	}
+	if (value === void 0 || value === null) return { valid: true };
+	const useCache = !options?.ignoreUnknownProperties;
+	if (useCache && isSchemaValidated(schema, value)) return { valid: true };
+	switch (actualType) {
+		case "any":
+			if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && value !== null && value !== void 0 && !Array.isArray(value) && !isObject(value)) errors.push("Value must be JSON-like");
+			break;
+		case "string":
+		case "number":
+		case "boolean":
+			validateTransformablePrimitive(schema, value, actualType, errors);
+			break;
+		case "ignore": break;
+		case "loro-text":
+			if (typeof value !== "string") errors.push("Content must be a string");
+			break;
+		case "loro-map":
+			if (!isObject(value)) errors.push("Value must be an object");
+			else if (isLoroMapSchema(schema)) {
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const propSchema = schema.definition[key];
+					const propValue = value[key];
+					const result = validateSchema(propSchema, propValue);
+					if (!result.valid && result.errors) {
+						const prefixedErrors = result.errors.map((err) => `${key}: ${err}`);
+						errors.push(...prefixedErrors);
+					}
+				}
+			}
+			break;
+		case "loro-movable-list":
+		case "loro-list":
+			if (!Array.isArray(value)) errors.push("Value must be an array");
+			else if (isLoroListSchema(schema) || isLoroMovableListSchema(schema)) {
+				const itemSchema = schema.itemSchema;
+				value.forEach((item, index) => {
+					const result = validateSchema(itemSchema, item);
+					if (!result.valid && result.errors) {
+						const prefixedErrors = result.errors.map((err) => `Item ${index}: ${err}`);
+						errors.push(...prefixedErrors);
+					}
+				});
+			}
+			break;
+		case "loro-tree": {
+			if (!Array.isArray(value)) {
+				errors.push("Value must be an array of tree nodes");
+				break;
+			}
+			if (!isLoroTreeSchema(schema)) {
+				errors.push("Invalid tree schema");
+				break;
+			}
+			const validateNode = (node, path) => {
+				if (!isObject(node)) {
+					errors.push(`${path}: Node must be an object`);
+					return;
+				}
+				const n = node;
+				if (n.id != null && typeof n.id !== "string") errors.push(`${path}: id must be a string if provided`);
+				const dataResult = validateSchema(schema.nodeSchema, n.data);
+				if (!dataResult.valid && dataResult.errors) errors.push(...dataResult.errors.map((e) => `${path}.data: ${e}`));
+				if (!Array.isArray(n.children)) errors.push(`${path}: children must be an array`);
+				else n.children.forEach((child, idx) => {
+					validateNode(child, `${path}.children[${idx}]`);
+				});
+			};
+			value.forEach((node, i) => {
+				validateNode(node, `node[${i}]`);
+			});
+			break;
+		}
+		case "schema":
+			if (!isObject(value)) errors.push("Value must be an object");
+			else if (isRootSchemaType(schema)) if (!isObject(value)) errors.push("Value must be an object");
+			else {
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const propSchema = schema.definition[key];
+					const propValue = value[key];
+					const result = validateSchema(propSchema, propValue);
+					if (!result.valid && result.errors) {
+						const prefixedErrors = result.errors.map((err) => `${key}: ${err}`);
+						errors.push(...prefixedErrors);
+					}
+				}
+				for (const key in value) if (!Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					if (options?.ignoreUnknownProperties) continue;
+					errors.push(`Unknown property: ${key}`);
+				}
+			}
+			else errors.push(`Should be a schema, but got ${actualType}`);
+			break;
+		default: errors.push(`Unknown schema type: ${actualType}`);
+	}
+	if (schema.options.validate && typeof schema.options.validate === "function") try {
+		const customValidation = schema.options.validate(value);
+		if (customValidation !== true) {
+			const errorMessage = typeof customValidation === "string" ? customValidation : "Value failed custom validation";
+			errors.push(errorMessage);
+		}
+	} catch (error) {
+		errors.push(`Validation error: ${String(error)}`);
+	}
+	if (errors.length === 0) {
+		if (useCache) markSchemaValidated(schema, value);
+		return { valid: true };
+	}
+	return {
+		valid: false,
+		errors
+	};
+}
+function validateTransformablePrimitive(schema, value, expectedType, errors) {
+	const transform = getTransform(schema);
+	if (transform) {
+		if (transform.validate) try {
+			const result = transform.validate(value);
+			if (result !== true) errors.push(typeof result === "string" ? result : "Transform validation failed");
+		} catch (error) {
+			errors.push(`Transform validation error: ${String(error)}`);
+		}
+		if (transform.validateEncodedType) try {
+			const encoded = applyEncode(schema, value);
+			if (typeof encoded !== expectedType) errors.push(`Transform encode must return a ${expectedType}, got ${typeof encoded}`);
+		} catch (error) {
+			errors.push(`Transform encode validation error: ${String(error)}`);
+		}
+	} else if (typeof value !== expectedType) errors.push(`Value must be a ${expectedType}`);
+}
+/**
+* Get default value for a schema
+* Based on the schema type, it might return a plain value or a wrapped value
+*/
+function getDefaultValue(schema) {
+	if ("defaultValue" in schema.options) return schema.options.defaultValue;
+	switch (schema.type) {
+		case "any": return;
+		case "string":
+			if (schema.options.required === false) return;
+			if (getTransform(schema)) return;
+			return "";
+		case "number":
+			if (schema.options.required === false) return;
+			if (getTransform(schema)) return;
+			return 0;
+		case "boolean":
+			if (schema.options.required === false) return;
+			if (getTransform(schema)) return;
+			return false;
+		case "loro-text": {
+			const value = schema.options.required ? "" : void 0;
+			if (value === void 0) return void 0;
+			return value;
+		}
+		case "loro-map":
+			if (isLoroMapSchema(schema)) {
+				const result = {};
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const value = getDefaultValue(schema.definition[key]);
+					if (value !== void 0) result[key] = value;
+				}
+				return result;
+			}
+			return {};
+		case "loro-list": return [];
+		case "loro-tree": {
+			const value = schema.options.required ? [] : void 0;
+			if (value === void 0) return void 0;
+			return value;
+		}
+		case "schema":
+			if (isRootSchemaType(schema)) {
+				const result = {};
+				for (const key in schema.definition) if (Object.prototype.hasOwnProperty.call(schema.definition, key)) {
+					const value = getDefaultValue(schema.definition[key]);
+					if (value !== void 0) result[key] = value;
+				}
+				return result;
+			}
+			return {};
+		default: return;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/loro-mirror@2.3.3_patch_hash=a551a0e4aa4f61ec88b0d9e970a183b5ee2955107a2e0bb03b378bc510c2f395_loro-crdt@1.16.1/node_modules/loro-mirror/dist/schema/index.js
+/**
+* Create a schema definition
+*/
+function schema(definition, options) {
+	return {
+		type: "schema",
+		definition,
+		options: options || {},
+		getContainerType() {
+			return "Map";
+		}
+	};
+}
+/**
+* Define a string field
+*/
+schema.String = (function(options) {
+	const baseSchema = {
+		type: "string",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+	return {
+		...baseSchema,
+		transform: (def) => ({
+			...baseSchema,
+			transform: def
+		})
+	};
+});
+/**
+* Define an any field (runtime-inferred by Mirror)
+*/
+schema.Any = function(options) {
+	return {
+		type: "any",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+};
+/**
+* Define a number field
+*/
+schema.Number = function(options) {
+	const baseSchema = {
+		type: "number",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+	return {
+		...baseSchema,
+		transform: (def) => ({
+			...baseSchema,
+			transform: def
+		})
+	};
+};
+/**
+* Define a boolean field
+*/
+schema.Boolean = function(options) {
+	const baseSchema = {
+		type: "boolean",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+	return {
+		...baseSchema,
+		transform: (def) => ({
+			...baseSchema,
+			transform: def
+		})
+	};
+};
+/**
+* Define a field to be ignored (not synced with Loro)
+*/
+schema.Ignore = function(options) {
+	return {
+		type: "ignore",
+		options: options || {},
+		getContainerType: () => {
+			return null;
+		}
+	};
+};
+/**
+* Define a Loro map
+*/
+schema.LoroMap = function(definition, options) {
+	const baseSchema = {
+		type: "loro-map",
+		definition,
+		options: options || {},
+		getContainerType: () => {
+			return "Map";
+		}
+	};
+	const schemaWithCatchall = {
+		...baseSchema,
+		catchall: (catchallSchema) => {
+			return {
+				...baseSchema,
+				catchallType: catchallSchema,
+				catchall: (newCatchallSchema) => {
+					return {
+						...baseSchema,
+						catchallType: newCatchallSchema,
+						catchall: schemaWithCatchall.catchall
+					};
+				}
+			};
+		}
+	};
+	return schemaWithCatchall;
+};
+/**
+* Create a dynamic record schema (like zod's z.record)
+*/
+schema.LoroMapRecord = function(valueSchema, options) {
+	return {
+		type: "loro-map",
+		definition: {},
+		catchallType: valueSchema,
+		options: options || {},
+		getContainerType: () => {
+			return "Map";
+		},
+		catchall: (newCatchallSchema) => {
+			return schema.LoroMapRecord(newCatchallSchema, options);
+		}
+	};
+};
+/**
+* Define a Loro list
+*/
+schema.LoroList = function(itemSchema, idSelector, options) {
+	return {
+		type: "loro-list",
+		itemSchema,
+		idSelector,
+		options: options || {},
+		getContainerType: () => {
+			return "List";
+		}
+	};
+};
+schema.LoroMovableList = function(itemSchema, idSelector, options) {
+	return {
+		type: "loro-movable-list",
+		itemSchema,
+		idSelector,
+		options: options || {},
+		getContainerType: () => {
+			return "MovableList";
+		}
+	};
+};
+/**
+* Define a Loro text field
+*/
+schema.LoroText = function(options) {
+	return {
+		type: "loro-text",
+		options: options || {},
+		getContainerType: () => {
+			return "Text";
+		}
+	};
+};
+/**
+* Define a Loro tree
+*
+* Each tree node has a `data` map described by `nodeSchema`.
+*/
+schema.LoroTree = function(nodeSchema, options) {
+	return {
+		type: "loro-tree",
+		nodeSchema,
+		options: options || {},
+		getContainerType() {
+			return "Tree";
+		}
+	};
+};
+//#endregion
+//#region ../medeo-dsl/src/schema/codec.ts
+function isInvalidAtomic(value) {
+	return typeof value === "object" && value !== null && "invalid" in value && value.invalid === true;
+}
+function codec(encode, decode) {
+	return {
+		encode: (v) => isInvalidAtomic(v) ? v.raw : encode(v),
+		decode: (raw) => {
+			try {
+				return decode(raw);
+			} catch (error) {
+				return {
+					invalid: true,
+					raw,
+					reason: String(error)
+				};
+			}
+		}
+	};
+}
+const timeAnchorCodec = codec((v) => {
+	assertRelation("time-anchor-relations", v);
+	return JSON.stringify({
+		from: v.from,
+		to: v.to,
+		offsetMs: v.offsetMs,
+		fallback_abs_ms: v.fallback_abs_ms
+	});
+}, (raw) => {
+	const v = JSON.parse(raw);
+	assertRelation("time-anchor-relations", v);
+	return v;
+});
+const captionContentCodec = codec((v) => {
+	assertRelation("caption-content-relations", v);
+	return JSON.stringify({
+		captionId: v.captionId,
+		audioScriptId: v.audioScriptId,
+		start: bytesToBase64url(v.start.encode()),
+		end: bytesToBase64url(v.end.encode())
+	});
+}, (raw) => {
+	const v = JSON.parse(raw);
+	if (typeof v?.start !== "string" || typeof v?.end !== "string") throw new Error("Expected encoded Cursor pair");
+	const value = {
+		...v,
+		start: Cursor.decode(base64urlToBytes(v.start)),
+		end: Cursor.decode(base64urlToBytes(v.end))
+	};
+	assertRelation("caption-content-relations", value);
+	return value;
+});
+/** A Clip's sequence marker is stored as one string, so it is taken or replaced whole. */
+const seqMarkerCodec = codec((v) => {
+	assertSeqMarker(v);
+	return JSON.stringify({
+		inMs: v.inMs,
+		outMs: v.outMs,
+		...v.rate === void 0 ? {} : { rate: v.rate },
+		...v.fillTimeline === void 0 ? {} : { fillTimeline: v.fillTimeline }
+	});
+}, (raw) => {
+	const v = JSON.parse(raw);
+	assertSeqMarker(v);
+	return v;
+});
+//#endregion
+//#region ../medeo-dsl/src/schema/loro-shape.ts
+const optional = { required: false };
+const mergeable = { mergeableMapChildContainers: true };
+const strings = (keys) => Object.fromEntries(keys.map((key) => [key, schema.String()]));
+const relation = (keys) => schema.LoroMapRecord(schema.LoroMap(strings(keys)), mergeable);
+const atomicValue = (codec) => schema.String().transform({
+	...codec,
+	isEqual: "encoded-value-equality",
+	validateEncodedType: true
+});
+const atomic = (codec) => schema.LoroMapRecord(atomicValue(codec));
+/** Only direct children inherit mergeable identity. Body and ordinary entity rows keep normal identities. */
+const medeoDslLoroShape = schema({
+	"timeline-entities": schema.LoroMapRecord(schema.LoroMap({})),
+	"track-entities": schema.LoroMapRecord(schema.LoroMap({
+		role: schema.String(),
+		hidden: schema.Boolean(optional)
+	})),
+	"clip-entities": schema.LoroMapRecord(schema.LoroMap({
+		seqMarker: atomicValue(seqMarkerCodec),
+		volume: schema.Number(optional)
+	})),
+	"media-entities": schema.LoroMapRecord(schema.LoroMap({
+		kind: schema.String(),
+		system: schema.String(),
+		key: schema.String(),
+		storageKey: schema.String(optional),
+		durationMs: schema.Number(optional),
+		digest: schema.String(optional)
+	}), mergeable),
+	"audio-script-entities": schema.LoroMapRecord(schema.LoroMap({
+		body: schema.LoroText(),
+		defaultLanguage: schema.String(optional)
+	})),
+	"caption-entities": schema.LoroMapRecord(schema.LoroMap({
+		text: schema.LoroText(optional),
+		style: schema.LoroMap({
+			font: schema.LoroMap({
+				system: schema.String(),
+				key: schema.String()
+			}, optional),
+			fontSize: schema.Number(optional),
+			fontColor: schema.String(optional),
+			fontWeight: schema.Number(optional),
+			entranceAnimation: schema.String(optional),
+			entranceAnimationDurationMs: schema.Number(optional),
+			strokeColor: schema.String(optional),
+			strokeWidth: schema.Number(optional),
+			positionX: schema.Number(optional),
+			positionY: schema.Number(optional)
+		}, {
+			...optional,
+			...mergeable
+		})
+	}, mergeable)),
+	"voice-entities": schema.LoroMapRecord(schema.LoroMap({
+		system: schema.String(),
+		key: schema.String(),
+		name: schema.String(optional)
+	}), mergeable),
+	"asset-entities": schema.LoroMapRecord(schema.LoroMap({
+		system: schema.String(),
+		key: schema.String(),
+		storageKey: schema.String(optional),
+		digest: schema.String(optional)
+	}), mergeable),
+	"contain-relations": schema.LoroTree(schema.LoroMap({ entityId: schema.String() })),
+	"clip-source-relations": relation(["clipId", "sourceId"]),
+	"time-anchor-relations": atomic(timeAnchorCodec),
+	"caption-content-relations": atomic(captionContentCodec),
+	"caption-alignment-relations": schema.LoroMapRecord(schema.LoroMap({
+		captionId: schema.String(),
+		mediaId: schema.String(),
+		startMs: schema.Number(),
+		endMs: schema.Number()
+	}), mergeable),
+	"voice-timbre-relations": relation(["recordingId", "voiceId"]),
+	"derived-from-relations": relation(["entityId", "sourceId"]),
+	"from-asset-relations": relation(["audioScriptId", "assetId"]),
+	"to-asset-relations": relation(["audioScriptId", "assetId"])
+});
+//#endregion
+//#region ../medeo-dsl/src/schema/document-format.ts
+/** Format discrimination does not register containers or alter the document. */
+function documentFormat(doc) {
+	const roots = doc.getShallowValue();
+	const legacy = [
+		"medeo",
+		"timeline",
+		"tracks",
+		"part_library"
+	].some((key) => Object.hasOwn(roots, key));
+	const dsl = Object.keys(roots).some((key) => key.endsWith("-entities") || key.endsWith("-relations"));
+	return legacy && dsl ? "mixed" : legacy ? "legacy" : dsl ? "dsl" : "unknown";
+}
+var UnsupportedDocumentFormatError = class extends Error {
+	code = "unsupported_document_format";
+	constructor() {
+		super("Expected a new DSL document; legacy, mixed or uninitialized content is not supported");
+		this.name = "UnsupportedDocumentFormatError";
+	}
+};
+/** Run after initial import, before opening an editable handle. Empty new documents still have one Timeline. */
+function assertDslDocument(doc) {
+	if (documentFormat(doc) !== "dsl" || doc.getMap("timeline-entities").keys().length !== 1) throw new UnsupportedDocumentFormatError();
+}
+//#endregion
+//#region ../medeo-dsl/src/schema/text-styles.ts
+/** How rich-text marks extend at their edges: a language runs on into new text, a pause stays on its space. */
+const textStyles = {
+	language: { expand: "after" },
+	pauseMs: { expand: "none" }
+};
+//#endregion
+//#region src/dsl/projection/video-draft-types.ts
+const DEFAULT_UNIT_TIME_MS = 33.333;
+//#endregion
+export { assertRelation as $, hardenCidDescriptors as A, safeStringify as B, applySchemaToInferOptions as C, deepEqual as D, decodeNestedJsonValues as E, isObject as F, valuesEqual as G, stripUndefined as H, isObjectLike as I, getChildSchema as J, CID_KEY as K, isStateAndSchemaOfType as L, inferContainerTypeFromValue as M, insertChildToMap as N, defineCidProperty as O, isArrayLike as P, assertId as Q, isTreeID as R, applyEncode as S, containerIdToContainerType as T, tryInferContainerType as U, schemaToContainerType as V, tryUpdateToContainer as W, assertEntity as X, getMapFieldSchema as Y, assertEntityPatch as Z, isLoroTreeSchema as _, documentFormat as a, assertRelationIdentity as at, validateSchema as b, isInvalidAtomic as c, relationId as ct, getDefaultValue as d, entityTables as et, isContainerSchema as f, isLoroMovableListSchema as g, isLoroMapSchema as h, assertDslDocument as i, validLanguage as it, hasTransform as j, getRootContainerByType as k, timeAnchorCodec as l, resourceId as lt, isLoroListSchema as m, textStyles as n, mergeFields as nt, medeoDslLoroShape as o, assertResourceIdentity as ot, isListLikeSchema as p, getChildContainerSchema as q, UnsupportedDocumentFormatError as r, relationTables as rt, captionContentCodec as s, defaultIdFactory as st, DEFAULT_UNIT_TIME_MS as t, isRecord as tt, schema as u, tupleHash as ut, isRootSchemaType as v, cidsEqual as w, applyDecode as x, schemaContainsIgnoreField as y, isValueOfContainerType as z };