@cutcraft/kit 0.0.0-stage → 0.1.0

package/dist/source/index-public.mjs

@@ -0,0 +1,1768 @@
+import { $ as resolveTheme, Dn as NOT_RENDERED, En as MASK_NOT_RENDERED, Fn as RENDERED_VALUES, J as isBundledFont, Kt as ELEMENTS, Ln as capabilitiesOf, Tn as MASKED_KINDS, dt as INTERIOR_PREFIX, et as themeToken, gt as resolveTimeRef, mn as TOKEN_PATTERN, n as src_exports, pn as STYLED_KINDS, yt as lookupAsset, z as nodeSpecOf } from "../src-BsBU2JLf.mjs";
+import * as zod from "zod";
+import { GRAPHIC_BASE_PROPS, GRAPHIC_KINDS, GRAPHIC_KIND_NAMES, isIcon } from "@cutcraft/graphics";
+import * as React from "react";
+import { parse } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+import * as t from "@babel/types";
+import * as jsxRuntime from "react/jsx-runtime";
+import { transform } from "sucrase";
+// src/source/parse.ts
+function parseSource(text) {
+	return {
+		text,
+		ast: parse(text, {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"],
+			errorRecovery: true,
+			ranges: false
+		})
+	};
+}
+function rangeOf(node) {
+	return [node.start ?? 0, node.end ?? 0];
+}
+// src/source/index.ts
+const traverse$1 = traverseModule.default ?? traverseModule;
+const KIND_BY_NAME = new Map(Object.entries(ELEMENTS).map(([name, c]) => [name, c.kind]));
+/**
+* Index every vocabulary JSX element with a literal id so patches can be
+* written back as text edits. Elements inside helper functions are indexed
+* too; whether they are literal or generated at runtime is decided by
+* `collect`, which sees how often the helper is used.
+*/
+function buildSourceIndex(text) {
+	const { ast } = parseSource(text);
+	const elements = /* @__PURE__ */ new Map();
+	const calls = [];
+	const helpers = /* @__PURE__ */ new Map();
+	const anonymous = [];
+	const dynamic = [];
+	const idSites = [];
+	const strays = [];
+	let defaults = null;
+	let hasSchema = false;
+	let hasDefaultExport = false;
+	let compositionId = null;
+	let schemaFn = null;
+	const paramKeys = /* @__PURE__ */ new Map();
+	let propsName = null;
+	for (const node of ast.program.body) {
+		if (!t.isExportDefaultDeclaration(node)) continue;
+		const decl = node.declaration;
+		const fn = t.isFunctionDeclaration(decl) || t.isArrowFunctionExpression(decl) || t.isFunctionExpression(decl) ? decl : null;
+		if (!fn) continue;
+		schemaFn = fn;
+		const param = fn.params[0];
+		if (t.isIdentifier(param)) propsName = param.name;
+		else if (t.isObjectPattern(param)) for (const p of param.properties) {
+			if (!t.isObjectProperty(p) || !t.isIdentifier(p.key)) continue;
+			const local = t.isIdentifier(p.value) ? p.value : t.isAssignmentPattern(p.value) && t.isIdentifier(p.value.left) ? p.value.left : null;
+			if (local) paramKeys.set(local.name, p.key.name);
+		}
+	}
+	const bindingOf = (expr) => {
+		if (t.isIdentifier(expr)) return paramKeys.get(expr.name) ?? null;
+		if (t.isMemberExpression(expr) && !expr.computed && t.isIdentifier(expr.object) && expr.object.name === propsName && t.isIdentifier(expr.property)) return expr.property.name;
+		return null;
+	};
+	const helperNames = /* @__PURE__ */ new Set();
+	for (const node of ast.program.body) {
+		if (t.isFunctionDeclaration(node) && node.id) helperNames.add(node.id.name);
+		if (t.isVariableDeclaration(node)) {
+			for (const d of node.declarations) if (t.isIdentifier(d.id) && (t.isArrowFunctionExpression(d.init) || t.isFunctionExpression(d.init))) helperNames.add(d.id.name);
+		}
+	}
+	traverse$1(ast, {
+		ExportNamedDeclaration(path) {
+			const decl = path.node.declaration;
+			if (!t.isVariableDeclaration(decl)) return;
+			for (const d of decl.declarations) {
+				if (!t.isIdentifier(d.id)) continue;
+				if (d.id.name === "schema") hasSchema = true;
+				if (d.id.name === "defaults" && t.isObjectExpression(d.init)) {
+					const props = /* @__PURE__ */ new Map();
+					for (const p of d.init.properties) {
+						if (!t.isObjectProperty(p)) continue;
+						const key = t.isIdentifier(p.key) ? p.key.name : t.isStringLiteral(p.key) ? p.key.value : null;
+						if (key === null) continue;
+						const lit = literalOf(p.value);
+						props.set(key, {
+							name: key,
+							range: rangeOf(p),
+							valueRange: rangeOf(p.value),
+							literal: lit.value,
+							isExpression: !lit.ok
+						});
+					}
+					defaults = {
+						range: rangeOf(d.init),
+						props
+					};
+				}
+			}
+		},
+		ExportDefaultDeclaration() {
+			hasDefaultExport = true;
+		},
+		FunctionDeclaration(path) {
+			if (!path.node.id || path.parentPath.isExportDefaultDeclaration()) return;
+			const hooks = hookCalls(path.node);
+			helpers.set(path.node.id.name, {
+				name: path.node.id.name,
+				range: rangeOf(path.node),
+				pure: hooks.length === 0,
+				hooks,
+				producesElements: namesElements(path.node)
+			});
+		},
+		VariableDeclarator(path) {
+			const init = path.node.init;
+			if (!t.isIdentifier(path.node.id) || !(t.isArrowFunctionExpression(init) || t.isFunctionExpression(init))) return;
+			if (!helperNames.has(path.node.id.name)) return;
+			const hooks = hookCalls(init);
+			helpers.set(path.node.id.name, {
+				name: path.node.id.name,
+				range: rangeOf(path.node),
+				pure: hooks.length === 0,
+				hooks,
+				producesElements: namesElements(init)
+			});
+		},
+		JSXElement(path) {
+			const opening = path.node.openingElement;
+			const name = jsxName(opening.name);
+			if (name === null) return;
+			if (/^[a-z]/.test(name)) {
+				const host = nearestElement(path);
+				if (host === "Track" || host === "Composition") strays.push({
+					name,
+					range: rangeOf(path.node),
+					parent: host
+				});
+				return;
+			}
+			const parent = enclosingElementId(path);
+			const siblingIndex = siblingIndexOf(path);
+			const indent = indentOf(text, path.node.start ?? 0);
+			if (helperNames.has(name) && !KIND_BY_NAME.has(name)) {
+				const callIndex = calls.filter((c) => c.helper === name).length;
+				calls.push({
+					helper: name,
+					callIndex,
+					range: rangeOf(path.node),
+					parent,
+					siblingIndex,
+					indent
+				});
+				return;
+			}
+			const kind = KIND_BY_NAME.get(name);
+			if (!kind) return;
+			const inSchemaFn = schemaFn !== null && path.getFunctionParent()?.node === schemaFn;
+			const { props, locked, bound } = attributesOf(opening, inSchemaFn);
+			const idSite = props.get("id");
+			let id = typeof idSite?.literal === "string" ? idSite.literal : null;
+			if (id === null && kind === "composition" && !idSite) id = "composition";
+			if (id === null) {
+				if (idSite?.isExpression && idSite.valueRange) dynamic.push({
+					kind,
+					range: rangeOf(path.node),
+					idText: text.slice(idSite.valueRange[0], idSite.valueRange[1])
+				});
+				const fn = path.getFunctionParent();
+				if (!(Boolean(fn && !fn.isExportDefaultDeclaration() && !fn.parentPath?.isExportDefaultDeclaration()) && idSite?.isExpression)) anonymous.push({
+					kind,
+					range: rangeOf(path.node),
+					reason: idSite ? "id must be a string literal" : "missing id"
+				});
+				return;
+			}
+			if (kind === "composition") compositionId = id;
+			if (idSite) idSites.push({
+				id,
+				range: idSite.range
+			});
+			const closing = path.node.closingElement;
+			const childrenRange = closing ? [opening.end ?? 0, closing.start ?? 0] : null;
+			const interior = kind === "layer" ? interiorOf(path.node, inSchemaFn) : null;
+			if (interior) {
+				for (const prop of interior.lockedProps) locked.push(`${INTERIOR_PREFIX}${prop}`);
+				for (const [prop, key] of Object.entries(interior.boundProps)) bound[`${INTERIOR_PREFIX}${prop}`] = key;
+			}
+			elements.set(id, {
+				generated: false,
+				id,
+				kind,
+				name,
+				range: rangeOf(path.node),
+				openingTag: rangeOf(opening),
+				closingTag: closing ? rangeOf(closing) : null,
+				childrenRange,
+				props,
+				parent,
+				siblingIndex,
+				lockedProps: locked,
+				boundProps: bound,
+				indent,
+				...interior ? { interior } : {}
+			});
+		}
+	});
+	/** A tag's attributes as prop sites, with schema bindings resolved when the tag sits in the default export. */
+	function attributesOf(opening, inSchemaFn) {
+		const props = /* @__PURE__ */ new Map();
+		const locked = [];
+		const bound = {};
+		for (const attr of opening.attributes) {
+			if (!t.isJSXAttribute(attr) || !t.isJSXIdentifier(attr.name)) continue;
+			let site = propSite(attr);
+			const binding = inSchemaFn && site.isExpression && t.isJSXExpressionContainer(attr.value) ? bindingOf(attr.value.expression) : null;
+			if (binding !== null) {
+				site = {
+					...site,
+					binding
+				};
+				bound[site.name] = binding;
+			}
+			props.set(site.name, site);
+			if (site.isExpression && binding === null) locked.push(site.name);
+		}
+		return {
+			props,
+			locked,
+			bound
+		};
+	}
+	/** The Layer's handles: exactly one element child whose tag names a file-level function. */
+	function interiorOf(layer, inSchemaFn) {
+		const elements = layer.children.filter((c) => !(t.isJSXText(c) && c.value.trim() === ""));
+		const only = elements.length === 1 ? elements[0] : null;
+		if (!only || !t.isJSXElement(only)) return null;
+		const name = jsxName(only.openingElement.name);
+		if (name === null || !helperNames.has(name) || KIND_BY_NAME.has(name)) return null;
+		const { props, locked, bound } = attributesOf(only.openingElement, inSchemaFn);
+		return {
+			component: name,
+			range: rangeOf(only),
+			openingTag: rangeOf(only.openingElement),
+			props,
+			lockedProps: locked,
+			boundProps: bound
+		};
+	}
+	return {
+		text,
+		ast,
+		elements,
+		calls,
+		helpers,
+		defaults,
+		hasSchema,
+		hasDefaultExport,
+		compositionId,
+		anonymous,
+		dynamic,
+		idSites,
+		strays
+	};
+}
+function jsxName(name) {
+	if (t.isJSXIdentifier(name)) return name.name;
+	if (t.isJSXMemberExpression(name) && t.isJSXIdentifier(name.property)) return name.property.name;
+	return null;
+}
+function propSite(attr) {
+	const name = attr.name.name;
+	const value = attr.value;
+	if (!value) return {
+		name,
+		range: rangeOf(attr),
+		valueRange: null,
+		literal: true,
+		isExpression: false
+	};
+	if (t.isStringLiteral(value)) return {
+		name,
+		range: rangeOf(attr),
+		valueRange: rangeOf(value),
+		literal: value.value,
+		isExpression: false
+	};
+	if (t.isJSXExpressionContainer(value)) {
+		const expr = value.expression;
+		const lit = literalOf(expr);
+		return {
+			name,
+			range: rangeOf(attr),
+			valueRange: rangeOf(expr),
+			literal: lit.value,
+			isExpression: !lit.ok
+		};
+	}
+	return {
+		name,
+		range: rangeOf(attr),
+		valueRange: rangeOf(value),
+		literal: void 0,
+		isExpression: true
+	};
+}
+/** Evaluate a literal expression (numbers, strings, booleans, null, arrays and objects of literals, template strings without holes). */
+function literalOf(node) {
+	if (!node) return {
+		ok: false,
+		value: void 0
+	};
+	if (t.isStringLiteral(node)) return {
+		ok: true,
+		value: node.value
+	};
+	if (t.isNumericLiteral(node)) return {
+		ok: true,
+		value: node.value
+	};
+	if (t.isBooleanLiteral(node)) return {
+		ok: true,
+		value: node.value
+	};
+	if (t.isNullLiteral(node)) return {
+		ok: true,
+		value: null
+	};
+	if (t.isTemplateLiteral(node) && node.expressions.length === 0) return {
+		ok: true,
+		value: node.quasis.map((q) => q.value.cooked ?? "").join("")
+	};
+	if (t.isUnaryExpression(node) && node.operator === "-" && t.isNumericLiteral(node.argument)) return {
+		ok: true,
+		value: -node.argument.value
+	};
+	if (t.isTSAsExpression(node) || t.isTSSatisfiesExpression(node) || t.isParenthesizedExpression(node)) return literalOf(node.expression);
+	if (t.isArrayExpression(node)) {
+		const out = [];
+		for (const el of node.elements) {
+			const r = literalOf(el);
+			if (!r.ok) return {
+				ok: false,
+				value: void 0
+			};
+			out.push(r.value);
+		}
+		return {
+			ok: true,
+			value: out
+		};
+	}
+	if (t.isObjectExpression(node)) {
+		const out = {};
+		for (const p of node.properties) {
+			if (!t.isObjectProperty(p) || p.computed) return {
+				ok: false,
+				value: void 0
+			};
+			const key = t.isIdentifier(p.key) ? p.key.name : t.isStringLiteral(p.key) ? p.key.value : null;
+			if (key === null) return {
+				ok: false,
+				value: void 0
+			};
+			const r = literalOf(p.value);
+			if (!r.ok) return {
+				ok: false,
+				value: void 0
+			};
+			out[key] = r.value;
+		}
+		return {
+			ok: true,
+			value: out
+		};
+	}
+	return {
+		ok: false,
+		value: void 0
+	};
+}
+function isVocabularyTag(node) {
+	const name = jsxName(node.openingElement.name);
+	return name !== null && KIND_BY_NAME.has(name);
+}
+/** Whether a function's JSX names any vocabulary element. */
+function namesElements(fn) {
+	let found = false;
+	t.traverseFast(fn.body, (node) => {
+		if (!found && t.isJSXElement(node) && isVocabularyTag(node)) found = true;
+	});
+	return found;
+}
+/** The tag name of the JSX element this one sits in, within the same function; null at the function's edge. */
+function nearestElement(path) {
+	let p = path.parentPath;
+	while (p && !t.isFunction(p.node)) {
+		if (t.isJSXElement(p.node)) return jsxName(p.node.openingElement.name);
+		p = p.parentPath;
+	}
+	return null;
+}
+function hookCalls(fn) {
+	const hooks = [];
+	t.traverseFast(fn.body, (node) => {
+		if (t.isCallExpression(node) && t.isIdentifier(node.callee) && /^use[A-Z]/.test(node.callee.name)) hooks.push(node.callee.name);
+	});
+	return hooks;
+}
+/** The id of the vocabulary element this JSX sits in, looking through HTML and other components as `collect` does. */
+function enclosingElementId(path) {
+	let p = path.parentPath;
+	while (p) {
+		if (t.isJSXElement(p.node) && !isVocabularyTag(p.node)) {
+			p = p.parentPath;
+			continue;
+		}
+		if (t.isJSXElement(p.node)) {
+			const attrs = p.node.openingElement.attributes;
+			for (const attr of attrs) if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === "id") {
+				if (t.isStringLiteral(attr.value)) return attr.value.value;
+				if (t.isJSXExpressionContainer(attr.value) && t.isStringLiteral(attr.value.expression)) return attr.value.expression.value;
+			}
+			if (jsxName(p.node.openingElement.name) === "Composition") return "composition";
+			return null;
+		}
+		p = p.parentPath;
+	}
+	return null;
+}
+function siblingIndexOf(path) {
+	const parent = path.parentPath?.node;
+	if (!parent || !(t.isJSXElement(parent) || t.isJSXFragment(parent))) return 0;
+	let i = 0;
+	for (const child of parent.children) {
+		if (child === path.node) return i;
+		if (t.isJSXElement(child)) i += 1;
+	}
+	return i;
+}
+function indentOf(text, pos) {
+	const lineStart = text.lastIndexOf("\n", pos - 1) + 1;
+	const prefix = text.slice(lineStart, pos);
+	return /^\s*$/.test(prefix) ? prefix : "";
+}
+// src/source/edits.ts
+/** Splice edits into the text, last range first, refusing overlaps. */
+function applyEdits(text, edits) {
+	const splices = [];
+	for (const e of edits) if (e.kind === "move") {
+		splices.push({
+			range: e.from,
+			text: ""
+		});
+		splices.push({
+			range: e.range,
+			text: e.text
+		});
+	} else splices.push({
+		range: e.range,
+		text: e.text
+	});
+	splices.sort((a, b) => b.range[0] - a.range[0] || b.range[1] - a.range[1]);
+	let out = text;
+	let lastStart = Number.POSITIVE_INFINITY;
+	for (const s of splices) {
+		if (s.range[1] > lastStart) throw new Error(`overlapping edits at ${s.range[0]}..${s.range[1]}`);
+		out = out.slice(0, s.range[0]) + s.text + out.slice(s.range[1]);
+		lastStart = s.range[0];
+	}
+	return out;
+}
+/** Widen an element range to swallow its own line(s): leading indentation and the trailing newline. */
+function lineRange(text, range) {
+	let start = range[0];
+	const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+	if (/^\s*$/.test(text.slice(lineStart, start))) start = lineStart;
+	let end = range[1];
+	const rest = text.slice(end).match(/^[ \t]*\r?\n/);
+	if (rest) end += rest[0].length;
+	return [start, end];
+}
+// src/source/print.ts
+const NAME_BY_KIND = new Map(Object.entries(ELEMENTS).map(([name, c]) => [c.kind, name]));
+const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/** JavaScript source for a JSON value, compact, double-quoted. */
+function printLiteral(value) {
+	if (value === void 0) return "undefined";
+	if (typeof value === "function") return value.name || "undefined";
+	if (value === null) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return `[${value.map(printLiteral).join(", ")}]`;
+	const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+	if (entries.length === 0) return "{}";
+	return `{ ${entries.map(([k, v]) => `${IDENT.test(k) ? k : JSON.stringify(k)}: ${printLiteral(v)}`).join(", ")} }`;
+}
+/** One JSX attribute. Strings as `name="…"`, everything else as `name={…}`, `true` as a bare attribute. */
+function printProp(name, value) {
+	if (value === void 0) return "";
+	if (value === true) return name;
+	if (typeof value === "function") return `${name}={${printLiteral(value)}}`;
+	if (typeof value === "string" && !value.includes("\"") && !value.includes("\n")) return `${name}="${value}"`;
+	return `${name}={${printLiteral(value)}}`;
+}
+function elementName(kind) {
+	return NAME_BY_KIND.get(kind) ?? kind;
+}
+/** A whole element as JSX text, indented with `indent`, children on their own lines. */
+function printElement(spec, indent = "", step = "  ") {
+	const name = elementName(spec.kind);
+	const attrs = Object.entries(spec.props).filter(([k, v]) => v !== void 0 && true).map(([k, v]) => printProp(k, v)).filter(Boolean);
+	const open = `${indent}<${name}${attrs.length ? " " + attrs.join(" ") : ""}`;
+	const children = spec.children ?? [];
+	if (children.length === 0 && spec.text === void 0) return `${open} />`;
+	if (children.length === 0) return `${open}>${escapeText(spec.text ?? "")}</${name}>`;
+	const inner = children.map((c) => printElement(c, indent + step, step)).join("\n");
+	return `${open}>${spec.text !== void 0 ? `\n${indent + step}${escapeText(spec.text)}` : ""}\n${inner}\n${indent}</${name}>`;
+}
+function escapeText(text) {
+	return /[{}<>]/.test(text) ? `{${JSON.stringify(text)}}` : text;
+}
+// src/source/bake.ts
+/**
+* Replace the helper call that produced a generated element with the literal
+* elements that call produced, so the editor can address them. Multicam cuts
+* are baked by appending their generated clips after the generator.
+*/
+function bake(text, id, state, index = buildSourceIndex(text)) {
+	const node = state.tree.byId.get(id);
+	if (!node) {
+		const generated = state.items.get(id);
+		return generated?.editable === "generated" && generated.parent ? bakeGeneratedChildren(text, generated.parent, state, index) : [];
+	}
+	if (node.editable !== "generated") return node.children.filter((c) => c.editable === "generated").flatMap((c) => bake(text, c.id, state, index));
+	const origin = node.origin;
+	if (!origin) return [];
+	const call = index.calls.find((c) => c.helper === origin.helper && c.callIndex === origin.callIndex);
+	if (!call) return [];
+	const printed = topLevelFromCall(state, origin.helper, origin.callIndex).map((n) => printElement(nodeSpecOf(n), call.indent)).join("\n");
+	return [{
+		kind: "bake",
+		id,
+		range: lineRange(text, call.range),
+		text: `${printed}\n`
+	}];
+}
+/** The outermost nodes a helper call produced: those whose parent is not itself from the same call. */
+function topLevelFromCall(state, helper, callIndex) {
+	const fromCall = (n) => Boolean(n?.origin && n.origin.helper === helper && n.origin.callIndex === callIndex);
+	return [...state.tree.byId.values()].filter((n) => fromCall(n) && !fromCall(n.parent ? state.tree.byId.get(n.parent) : void 0));
+}
+function bakeGeneratedChildren(text, parentId, state, index) {
+	const site = index.elements.get(parentId);
+	if (!site) return [];
+	const generated = [...state.items.values()].filter((p) => p.editable === "generated" && p.parent === parentId && !state.tree.byId.has(p.id)).sort((a, b) => a.start - b.start);
+	const parentKind = state.tree.byId.get(parentId)?.kind ?? site.kind;
+	const asChildren = generated.length > 0 && generated.every((p) => capabilitiesOf(parentKind).childKinds.includes(p.kind));
+	const indent = asChildren ? `${site.indent}  ` : site.indent;
+	const printed = generated.map((p) => printElement({
+		id: p.id,
+		kind: p.kind,
+		props: JSON.parse(JSON.stringify(p.props))
+	}, indent)).join("\n");
+	if (!asChildren) {
+		const end = lineRange(text, site.range)[1];
+		return [{
+			kind: "bake",
+			id: parentId,
+			range: [end, end],
+			text: `${printed}\n`
+		}];
+	}
+	if (site.childrenRange) return [{
+		kind: "bake",
+		id: parentId,
+		range: site.childrenRange,
+		text: `\n${printed}\n${site.indent}`
+	}];
+	const open = site.openingTag;
+	const slash = text.lastIndexOf("/>", open[1]);
+	return [{
+		kind: "bake",
+		id: parentId,
+		range: [text[slash - 1] === " " ? slash - 1 : slash, open[1]],
+		text: `>\n${printed}\n${site.indent}</${site.name}>`
+	}];
+}
+// src/source/fold.ts
+const traverse = traverseModule.default ?? traverseModule;
+/** Structural edits can introduce vocabulary tags the original file never imported. */
+function elementImports(text) {
+	const { ast } = parseSource(text);
+	const missing = /* @__PURE__ */ new Set();
+	traverse(ast, { JSXOpeningElement(path) {
+		const name = path.node.name;
+		if (t.isJSXIdentifier(name) && Object.hasOwn(ELEMENTS, name.name) && !path.scope.hasBinding(name.name)) missing.add(name.name);
+	} });
+	if (!missing.size) return [];
+	const imports = ast.program.body.filter(t.isImportDeclaration);
+	const kitImport = imports.find((node) => node.source.value === "@cutcraft/kit" || node.source.value === "@cut/kit");
+	const pos = imports.at(-1)?.end ?? ast.program.directives.at(-1)?.end ?? 0;
+	const moduleName = kitImport?.source.value ?? "@cutcraft/kit";
+	return [{
+		kind: "insert",
+		id: "composition",
+		range: [pos, pos],
+		text: `\nimport { ${[...missing].sort().join(", ")} } from ${JSON.stringify(moduleName)};\n`
+	}];
+}
+/**
+* Turn the patch log's net effect into text edits against the index.
+* Targets without a literal site are reported, not folded; `foldToSource`
+* bakes them first and folds again.
+*/
+function fold(log, index, state) {
+	const edits = [];
+	const needsBake = [];
+	const skipped = [];
+	const text = index.text;
+	const groups = /* @__PURE__ */ new Map();
+	/**
+	* Queue a placed node (inserted or moved) at its insertion point. Siblings
+	* that are themselves placed in this net have no usable site yet, so the
+	* point is taken from the nearest sibling that sits in the text, and the
+	* group keeps the order the overlay produces: an element placed after that
+	* anchor goes first, one placed after a queued sibling goes right behind it.
+	*/
+	const place = (id, at, print, from) => {
+		let anchor = at.after;
+		while (anchor !== null) {
+			const sibling = log.net.get(anchor);
+			if (!sibling?.place || sibling.place.parent !== at.parent) break;
+			anchor = sibling.place.after;
+		}
+		const point = insertionPoint(index, at.parent, anchor);
+		if (!point) return false;
+		const key = `${at.parent}\u0000${anchor ?? ""}`;
+		let group = groups.get(key);
+		if (!group) {
+			group = {
+				point,
+				ids: [],
+				texts: /* @__PURE__ */ new Map(),
+				moved: /* @__PURE__ */ new Map()
+			};
+			groups.set(key, group);
+		}
+		group.texts.set(id, print(point.indent));
+		if (from) group.moved.set(id, from);
+		const behind = at.after === anchor ? -1 : group.ids.indexOf(at.after);
+		group.ids.splice(behind + 1, 0, id);
+		return true;
+	};
+	/** The nearest ancestor inserted by this net: its printed subtree already carries this node. */
+	const insertedAncestor = (id) => {
+		for (let node = state.tree.byId.get(id); node && node.parent !== null; node = state.tree.byId.get(node.parent)) if (log.net.get(node.parent)?.presence === "inserted") return node.parent;
+		return null;
+	};
+	for (const [id, net] of log.net) {
+		if (net.bake) {
+			needsBake.push(id);
+			continue;
+		}
+		if (id === "composition" && net.props.has("$defaults")) {
+			const value = net.props.get("$defaults");
+			if (value === void 0) {} else if (index.defaults) edits.push({
+				kind: "defaults",
+				id,
+				range: index.defaults.range,
+				text: printLiteral(value)
+			});
+			else skipped.push({
+				id,
+				reason: "no `export const defaults` literal to rewrite"
+			});
+			net.props.delete("$defaults");
+			if (net.props.size === 0 && net.presence === "present" && !net.place && net.text === void 0) continue;
+		}
+		switch (net.presence) {
+			case "removed": {
+				const site = index.elements.get(id);
+				if (!site) {
+					needsBake.push(id);
+					break;
+				}
+				edits.push({
+					kind: "remove",
+					id,
+					range: lineRange(text, site.range),
+					text: ""
+				});
+				break;
+			}
+			case "inserted": {
+				if (!net.node || !net.place) {
+					skipped.push({
+						id,
+						reason: "insert without a node"
+					});
+					break;
+				}
+				if (insertedAncestor(id)) break;
+				const node = state.tree.byId.get(id) ?? net.node;
+				if (!place(id, net.place, (indent) => printElement(nodeSpecOf(node), indent), null)) needsBake.push(net.place.parent);
+				break;
+			}
+			case "present": {
+				const site = index.elements.get(id);
+				if (!site) {
+					needsBake.push(id);
+					break;
+				}
+				if (insertedAncestor(id)) {
+					edits.push({
+						kind: "remove",
+						id,
+						range: lineRange(text, site.range),
+						text: ""
+					});
+					break;
+				}
+				if (net.place) {
+					const original = text.slice(site.range[0], site.range[1]);
+					if (!place(id, net.place, (indent) => reindent(original, site.indent, indent), lineRange(text, site.range))) needsBake.push(net.place.parent);
+				}
+				let newAttrs = -1;
+				for (const [prop, value] of net.props) {
+					const key = site.boundProps[prop];
+					const handle = prop.startsWith(INTERIOR_PREFIX);
+					if (handle && !site.interior && key === void 0) {
+						skipped.push({
+							id,
+							reason: `"${id}" has no handles`
+						});
+						continue;
+					}
+					const target = handle ? {
+						id,
+						props: site.interior.props,
+						openingTag: site.interior.openingTag
+					} : site;
+					const e = key !== void 0 ? bindingEdit(index, id, prop, key, value, skipped) : propEdit(target, handle ? prop.slice(INTERIOR_PREFIX.length) : prop, value, text);
+					if (!e) continue;
+					if (e.kind === "prop" && e.range[0] === e.range[1]) {
+						const prev = edits[newAttrs];
+						if (prev?.kind === "prop" && prev.range[0] === e.range[0]) {
+							edits[newAttrs] = {
+								...prev,
+								text: prev.text + e.text
+							};
+							continue;
+						}
+						newAttrs = edits.length;
+					}
+					edits.push(e);
+				}
+				if (net.text !== void 0) {
+					const e = textEdit(site, net.text);
+					if (e) edits.push(e);
+					else skipped.push({
+						id,
+						reason: "cannot set text on this element"
+					});
+				}
+				break;
+			}
+		}
+	}
+	for (const group of groups.values()) {
+		const printed = group.ids.map((id) => group.texts.get(id)).join("\n");
+		edits.push(insertEdit(index, group.ids[0], group.point, printed));
+		for (const [id, from] of group.moved) edits.push({
+			kind: "remove",
+			id,
+			range: from,
+			text: ""
+		});
+	}
+	return {
+		edits: lastWriteWins(edits),
+		needsBake: [...new Set(needsBake)],
+		skipped
+	};
+}
+function lastWriteWins(edits) {
+	const byRange = /* @__PURE__ */ new Map();
+	const keep = [];
+	for (const e of edits) {
+		if (e.kind !== "defaults") {
+			keep.push(e);
+			continue;
+		}
+		const k = `${e.range[0]}:${e.range[1]}`;
+		const prev = byRange.get(k);
+		if (prev !== void 0) keep[prev] = e;
+		else {
+			byRange.set(k, keep.length);
+			keep.push(e);
+		}
+	}
+	return keep;
+}
+/** Fold with baking: generated targets are baked into literals, the file is re-indexed, and the fold is retried. */
+function foldToSource(text, log, state, maxRounds = 4) {
+	let current = text;
+	const baked = [];
+	let allEdits = [];
+	for (let round = 0; round < maxRounds; round++) {
+		const index = buildSourceIndex(current);
+		const { edits, needsBake, skipped } = fold(log, index, state);
+		if (needsBake.length === 0) {
+			allEdits = [...allEdits, ...edits];
+			const folded = applyEdits(current, edits);
+			const imports = elementImports(folded);
+			return {
+				text: applyEdits(folded, imports),
+				edits: [...allEdits, ...imports],
+				baked,
+				skipped
+			};
+		}
+		let bakeEdits = [];
+		for (const id of needsBake) {
+			const result = bake(current, id, state, index);
+			if (result.length === 0) return {
+				text: applyEdits(current, edits),
+				edits: [...allEdits, ...edits],
+				baked,
+				skipped: [...skipped, {
+					id,
+					reason: "cannot bake"
+				}]
+			};
+			bakeEdits = [...bakeEdits, ...result];
+			baked.push(id);
+		}
+		current = applyEdits(current, dedupe(bakeEdits));
+		allEdits = [...allEdits, ...bakeEdits];
+	}
+	return {
+		text: current,
+		edits: allEdits,
+		baked,
+		skipped: [{
+			id: "*",
+			reason: "bake did not converge"
+		}]
+	};
+}
+function dedupe(edits) {
+	const seen = /* @__PURE__ */ new Set();
+	return edits.filter((e) => {
+		const k = `${e.range[0]}:${e.range[1]}`;
+		if (seen.has(k)) return false;
+		seen.add(k);
+		return true;
+	});
+}
+function insertionPoint(index, parentId, after) {
+	const text = index.text;
+	const parent = index.elements.get(parentId);
+	if (!parent) return null;
+	const step = "  ";
+	if (after !== null) {
+		const sibling = index.elements.get(after);
+		if (!sibling || sibling.parent !== parentId) return null;
+		return {
+			pos: lineRange(text, sibling.range)[1],
+			indent: sibling.indent,
+			wrap: (p) => `${p}\n`
+		};
+	}
+	if (parent.childrenRange) {
+		const afterOpen = parent.openingTag[1];
+		const nl = text.slice(afterOpen).match(/^[ \t]*\r?\n/);
+		const childIndent = parent.indent + step;
+		if (nl) return {
+			pos: afterOpen + nl[0].length,
+			indent: childIndent,
+			wrap: (p) => `${p}\n`
+		};
+		return {
+			pos: afterOpen,
+			indent: childIndent,
+			wrap: (p) => `\n${p}\n${parent.indent}`
+		};
+	}
+	const open = parent.openingTag;
+	const slash = text.lastIndexOf("/>", open[1]);
+	if (slash < open[0]) return null;
+	return {
+		pos: slash,
+		indent: parent.indent + step,
+		wrap: (p) => `>\n${p}\n${parent.indent}</${parent.name}>`,
+		convertsParent: parent
+	};
+}
+function insertEdit(index, id, target, printed) {
+	if (target.convertsParent) {
+		const open = target.convertsParent.openingTag;
+		const before = index.text.slice(open[1] - 2, open[1]) === "/>" ? open[1] - 2 : target.pos;
+		return {
+			kind: "insert",
+			id,
+			range: [index.text[before - 1] === " " ? before - 1 : before, open[1]],
+			text: target.wrap(printed)
+		};
+	}
+	return {
+		kind: "insert",
+		id,
+		range: [target.pos, target.pos],
+		text: target.wrap(printed)
+	};
+}
+/**
+* A prop bound to a `schema` key keeps its reference; the value goes into
+* the `defaults` literal, so every element reading that key follows. Two
+* elements writing the same key in one fold would collide on the same
+* range, so the later write wins and the earlier edit is dropped.
+*/
+function bindingEdit(index, id, prop, key, value, skipped) {
+	const target = index.defaults?.props.get(key);
+	if (value === void 0) {
+		skipped.push({
+			id,
+			reason: `cannot unset "${prop}": it is bound to defaults.${key}`
+		});
+		return null;
+	}
+	if (!target || !target.valueRange) {
+		skipped.push({
+			id,
+			reason: `"${prop}" is bound to defaults.${key}, which has no literal`
+		});
+		return null;
+	}
+	return {
+		kind: "defaults",
+		id,
+		range: target.valueRange,
+		text: printLiteral(value)
+	};
+}
+function propEdit(site, prop, value, text) {
+	const existing = site.props.get(prop);
+	if (value === void 0) {
+		if (!existing) return null;
+		let start = existing.range[0];
+		while (start > site.openingTag[0] && /\s/.test(text[start - 1])) start -= 1;
+		return {
+			kind: "prop",
+			id: site.id,
+			prop,
+			range: [start, existing.range[1]],
+			text: ""
+		};
+	}
+	if (existing) {
+		if (existing.valueRange === null) return {
+			kind: "prop",
+			id: site.id,
+			prop,
+			range: existing.range,
+			text: printProp(prop, value)
+		};
+		const asString = typeof value === "string" && text[existing.valueRange[0]] === "\"" && !value.includes("\"") && !value.includes("\n");
+		const replacement = asString ? `"${value}"` : printLiteral(value);
+		if (asString) return {
+			kind: "prop",
+			id: site.id,
+			prop,
+			range: existing.valueRange,
+			text: replacement
+		};
+		const r = existing.valueRange;
+		const wrapped = text[r[0] - 1] === "{" && text[r[1]] === "}";
+		if (wrapped && typeof value === "string" && !value.includes("\"") && !value.includes("\n")) return {
+			kind: "prop",
+			id: site.id,
+			prop,
+			range: [r[0] - 1, r[1] + 1],
+			text: `"${value}"`
+		};
+		if (wrapped) return {
+			kind: "prop",
+			id: site.id,
+			prop,
+			range: r,
+			text: replacement
+		};
+		return {
+			kind: "prop",
+			id: site.id,
+			prop,
+			range: r,
+			text: `{${replacement}}`
+		};
+	}
+	const open = site.openingTag;
+	let pos = text.slice(open[1] - 2, open[1]) === "/>" ? open[1] - 2 : open[1] - 1;
+	while (pos > open[0] && /\s/.test(text[pos - 1])) pos -= 1;
+	return {
+		kind: "prop",
+		id: site.id,
+		prop,
+		range: [pos, pos],
+		text: ` ${printProp(prop, value)}`
+	};
+}
+function textEdit(site, value) {
+	if (site.childrenRange) return {
+		kind: "text",
+		id: site.id,
+		range: site.childrenRange,
+		text: value
+	};
+	const open = site.openingTag;
+	const slash = site.range[1] - 2;
+	let start = slash;
+	while (start > open[0] && /\s/.test(site.indent) && /\s/.test(value[start - 1] ?? "")) start -= 1;
+	return {
+		kind: "text",
+		id: site.id,
+		range: [slash, site.range[1]],
+		text: `>${value}</${site.name}>`
+	};
+}
+function reindent(source, from, to) {
+	if (from === to) return source;
+	return source.split("\n").map((line, i) => i === 0 ? line : line.startsWith(from) ? to + line.slice(from.length) : line).join("\n");
+}
+// src/source/lint/rules/free-code.ts
+/** HTML straight in a `<Track>` or `<Composition>`: the resolver walks past it and nothing draws it. */
+const strayHtml = {
+	name: "stray-html",
+	check: (index) => index.strays.map(({ name, range, parent }) => ({
+		rule: "stray-html",
+		severity: "warning",
+		range,
+		message: `<${name}> sits straight in a <${parent}>, where nothing draws it; put free code inside a <Layer> (any React, CSS or WebGL renders there)`
+	}))
+};
+/**
+* Free code renders frame by frame against the video's own clock. `useT()`, requestAnimationFrame, Date, performance
+* and CSS animations follow it; timers, media elements playing on their own and canvases kept on the CPU do not.
+*/
+const freeCodeClock = {
+	name: "free-code-clock",
+	check: (index) => {
+		const out = [];
+		const warn = (node, message) => {
+			out.push({
+				rule: "free-code-clock",
+				severity: "warning",
+				range: rangeOf(node),
+				message
+			});
+		};
+		t.traverseFast(index.ast.program, (node) => {
+			if (t.isCallExpression(node)) {
+				const callee = node.callee;
+				const name = t.isIdentifier(callee) ? callee.name : t.isMemberExpression(callee) && t.isIdentifier(callee.property) ? callee.property.name : null;
+				if (name === "setTimeout" || name === "setInterval") warn(node, `${name} runs on the wall clock, so an export would not repeat it frame for frame; derive the change from useT() instead`);
+			} else if (t.isJSXOpeningElement(node) && t.isJSXIdentifier(node.name) && (node.name.name === "video" || node.name.name === "audio")) warn(node, `<${node.name.name}> plays on its own clock and its sound is not in the export; use a <Clip> or <Audio>, and useClipFrame for a clip's picture in free code`);
+			else if (t.isObjectProperty(node) && t.isIdentifier(node.key) && node.key.name === "willReadFrequently" && t.isBooleanLiteral(node.value, { value: true })) warn(node, "a canvas with willReadFrequently is kept on the CPU and the export does not capture it; leave the option out");
+		});
+		return out;
+	}
+};
+// src/source/lint/rules/graphic.ts
+/** `<Graphic>` kinds and their literal props, and `icon:` sticker names, checked before anything renders. */
+const graphicProps = {
+	name: "graphic-props",
+	check: (index) => {
+		const out = [];
+		for (const site of index.elements.values()) {
+			if (site.kind === "sticker") {
+				const src = site.props.get("src");
+				if (typeof src?.literal === "string" && src.literal.startsWith("icon:") && !isIcon(src.literal.slice(5))) out.push({
+					rule: "graphic-props",
+					severity: "warning",
+					message: `"${site.id}": no Lucide icon "${src.literal.slice(5)}"; the sticker shows a placeholder`,
+					range: src.range,
+					id: site.id,
+					prop: "src"
+				});
+				continue;
+			}
+			if (site.kind !== "graphic") continue;
+			const kind = site.props.get("kind");
+			if (typeof kind?.literal !== "string") continue;
+			if (!GRAPHIC_KIND_NAMES.includes(kind.literal)) {
+				const near = GRAPHIC_KIND_NAMES.filter((k) => k.includes(kind.literal) || kind.literal.includes(k.split("-")[0]));
+				out.push({
+					rule: "graphic-props",
+					severity: "error",
+					message: `"${site.id}": no graphic kind "${kind.literal}"${near.length ? `; did you mean ${near.map((k) => `"${k}"`).join(", ")}?` : ` (see the graphics reference)`}`,
+					range: kind.range,
+					id: site.id,
+					prop: "kind"
+				});
+				continue;
+			}
+			const shape = GRAPHIC_KINDS[kind.literal].shape;
+			for (const [name, prop] of site.props) {
+				if (name === "kind" || GRAPHIC_BASE_PROPS.includes(name)) continue;
+				if (!Object.hasOwn(shape, name)) {
+					out.push({
+						rule: "graphic-props",
+						severity: "error",
+						message: `"${site.id}": ${kind.literal} has no prop "${name}" (${Object.keys(shape).join(", ")})`,
+						range: prop.range,
+						id: site.id,
+						prop: name
+					});
+					continue;
+				}
+				if (prop.literal === void 0 || prop.isExpression && prop.binding !== void 0) continue;
+				const result = shape[name].safeParse(prop.literal);
+				if (!result.success) out.push({
+					rule: "graphic-props",
+					severity: "error",
+					message: `"${site.id}.${name}": ${result.error.issues[0]?.message ?? "invalid"}`,
+					range: prop.range,
+					id: site.id,
+					prop: name
+				});
+			}
+		}
+		return out;
+	}
+};
+// src/source/lint/rules/not-rendered.ts
+/** Values that ask for nothing, so writing them is never reported. */
+const OFF = [
+	false,
+	0,
+	"none",
+	"all"
+];
+/** `prop` or `prop.field`: the written literal, or undefined when it is absent or not a literal. */
+function literalAt(site, path) {
+	const [prop, ...fields] = path.split(".");
+	const p = site.props.get(prop);
+	if (!p) return null;
+	let value = p.literal;
+	for (const f of fields) value = value !== null && typeof value === "object" && !Array.isArray(value) ? value[f] : void 0;
+	return {
+		value,
+		range: p.range,
+		prop
+	};
+}
+/** Props, values and elements the schemas accept but the player and renderer do not draw or play; see `jsx/rendering.ts`. */
+const notRendered = {
+	name: "not-rendered",
+	check: (index) => {
+		const out = [];
+		const warn = (site, what, reason, range = site.range, prop) => out.push({
+			rule: "not-rendered",
+			severity: "warning",
+			message: `"${site.id}" <${site.name}>${what ? ` ${what}` : ""} ${reason}`,
+			range,
+			id: site.id,
+			...prop ? { prop } : {}
+		});
+		const masks = /* @__PURE__ */ new Map();
+		for (const site of index.elements.values()) {
+			for (const v of RENDERED_VALUES) {
+				if (v.kind !== site.kind) continue;
+				const at = literalAt(site, v.prop);
+				if (typeof at?.value !== "string" || v.values.includes(at.value)) continue;
+				if (NOT_RENDERED.some((n) => n.kind === site.kind && n.prop === v.prop && n.value === at.value)) continue;
+				warn(site, `${v.prop} "${at.value}"`, v.reason, at.range, at.prop);
+			}
+			for (const n of NOT_RENDERED) {
+				if (n.kind !== "*" && n.kind !== site.kind) continue;
+				if (n.parent && index.elements.get(site.parent ?? "")?.kind !== n.parent) continue;
+				if (!n.prop) {
+					warn(site, "", n.reason);
+					continue;
+				}
+				const at = literalAt(site, n.prop);
+				if (!at || n.prop.includes(".") && at.value === void 0) continue;
+				if (n.value !== void 0 ? at.value !== n.value : OFF.includes(at.value)) continue;
+				warn(site, n.value !== void 0 ? `${n.prop} "${n.value}"` : n.prop, n.reason, at.range, at.prop);
+			}
+			if (site.kind === "mask" && site.parent) {
+				const parent = index.elements.get(site.parent);
+				const count = (masks.get(site.parent) ?? 0) + 1;
+				masks.set(site.parent, count);
+				if (parent && !MASKED_KINDS.includes(parent.kind)) warn(site, `on ${parent.kind} "${parent.id}"`, MASK_NOT_RENDERED.kind);
+				else if (count > 1) warn(site, "", MASK_NOT_RENDERED.second);
+			}
+		}
+		return out;
+	}
+};
+// src/source/lint/rules/shots.ts
+/** Closer than this to a shot change, on the wrong side of it, a cut shows a few frames of the other shot. */
+const NEAR_S = .3;
+const NO_MARKERS = /* @__PURE__ */ new Map();
+const r2 = (t) => Math.round(t * 100) / 100;
+/** The written `in`/`out` as source seconds: a number or a word/shot/silence reference; undefined when absent or unresolvable. */
+function sourceTime(site, prop, asset) {
+	const p = site.props.get(prop);
+	if (p === void 0) return void 0;
+	const t = resolveTimeRef(p.literal, asset, NO_MARKERS, {
+		id: site.id,
+		prop
+	});
+	return typeof t === "number" ? t : void 0;
+}
+/** Clips that draw a picture, with their asset's shot list. */
+function* cutClips(index, manifest, needShots = true) {
+	for (const site of index.elements.values()) {
+		if (site.kind !== "clip") continue;
+		const src = site.props.get("src")?.literal;
+		if (typeof src !== "string") continue;
+		const asset = lookupAsset(manifest, src);
+		if (asset && (!needShots || asset.shots?.length)) yield {
+			site,
+			asset,
+			shots: asset.shots ?? []
+		};
+	}
+}
+/** A cut a few frames off a source shot change: `in` just before one shows the previous shot first, `out` just after one shows the next shot last. */
+const cutNearShot = {
+	name: "cut-near-shot",
+	check: (index, options) => {
+		if (!options.manifest) return [];
+		const out = [];
+		for (const { site, asset, shots } of cutClips(index, options.manifest)) for (const prop of ["in", "out"]) {
+			const p = site.props.get(prop);
+			const t = sourceTime(site, prop, asset);
+			if (!p || t === void 0) continue;
+			for (const shot of shots) {
+				const gap = prop === "in" ? shot.start - t : t - shot.start;
+				if (gap <= 0 || gap >= NEAR_S || shot.i === 0) continue;
+				const shown = prop === "in" ? `shot:${shot.i - 1} shows first` : `shot:${shot.i} shows last`;
+				const use = prop === "in" ? `in="shot:${shot.i}"` : `out="shot:${shot.i - 1}.end"`;
+				out.push({
+					rule: "cut-near-shot",
+					severity: "warning",
+					message: `"${site.id}.${prop}" = ${r2(t)} is ${r2(gap)} s ${prop === "in" ? "before" : "after"} shot:${shot.i} starts (${r2(shot.start)}); a flash of ${shown}; use ${use}`,
+					range: p.range,
+					id: site.id,
+					prop
+				});
+			}
+		}
+		return out;
+	}
+};
+/** One crop over a source range that contains a shot change: the framing the crop was set for ends mid-clip. */
+const shotChangeInsideCrop = {
+	name: "shot-change-inside-crop",
+	check: (index, options) => {
+		if (!options.manifest) return [];
+		const out = [];
+		for (const { site, asset, shots } of cutClips(index, options.manifest)) {
+			const transform = site.props.get("transform");
+			const literal = transform?.literal;
+			if (!transform || literal === null || typeof literal !== "object" || Array.isArray(literal) || !("crop" in literal)) continue;
+			const start = sourceTime(site, "in", asset) ?? 0;
+			const end = sourceTime(site, "out", asset) ?? asset.duration;
+			const inside = shots.filter((s) => s.start > start + NEAR_S && s.start < end - NEAR_S);
+			if (inside.length === 0) continue;
+			const names = inside.map((s) => `shot:${s.i} (${r2(s.start)})`).join(", ");
+			out.push({
+				rule: "shot-change-inside-crop",
+				severity: "warning",
+				message: `"${site.id}" has one crop over ${r2(start)}–${r2(end)}, but the camera cuts inside it at ${names}; the framing changes there, so split the clip at the shot (out="shot:N.end", then in="shot:N+1") and crop each part`,
+				range: transform.range,
+				id: site.id,
+				prop: "transform"
+			});
+		}
+		return out;
+	}
+};
+/** Two clips on one track playing overlapping stretches of the same asset: the same footage twice, usually a split that left the old line in. */
+const repeatedSource = {
+	name: "repeated-source",
+	check: (index, options) => {
+		if (!options.manifest) return [];
+		const out = [];
+		const byTrack = /* @__PURE__ */ new Map();
+		for (const { site, asset } of cutClips(index, options.manifest, false)) {
+			const start = sourceTime(site, "in", asset) ?? 0;
+			const end = sourceTime(site, "out", asset) ?? asset.duration;
+			const list = byTrack.get(site.parent ?? "") ?? [];
+			list.push({
+				site,
+				src: asset.id,
+				start,
+				end
+			});
+			byTrack.set(site.parent ?? "", list);
+		}
+		for (const clips of byTrack.values()) for (let i = 1; i < clips.length; i++) {
+			const b = clips[i];
+			const a = clips.slice(0, i).find((x) => x.src === b.src && Math.min(x.end, b.end) - Math.max(x.start, b.start) > 1);
+			if (!a) continue;
+			const from = Math.max(a.start, b.start);
+			const to = Math.min(a.end, b.end);
+			out.push({
+				rule: "repeated-source",
+				severity: "warning",
+				message: `"${b.site.id}" plays ${r2(from)}–${r2(to)} of ${b.src} again after "${a.site.id}" did; the same footage twice on one track is usually a split that kept the old clip. Remove one.`,
+				range: b.site.range,
+				id: b.site.id
+			});
+		}
+		return out;
+	}
+};
+// src/source/lint/rules/theme.ts
+/** Keys whose string values are colours. */
+const COLOR_KEYS = /* @__PURE__ */ new Set([
+	"color",
+	"fill",
+	"background",
+	"tint",
+	"highlight",
+	"upcoming",
+	"frontColor",
+	"sideColor"
+]);
+/** Subtrees where a literal colour is expected even with a theme: shadows are usually black, whatever the palette. */
+const SKIP_KEYS = /* @__PURE__ */ new Set([
+	"shadow",
+	"shadows",
+	"theme",
+	"text",
+	"content",
+	"src"
+]);
+const THEMED_KINDS = /* @__PURE__ */ new Set([
+	...STYLED_KINDS,
+	"composition",
+	"marker"
+]);
+const NOT_COLORS = /* @__PURE__ */ new Set([
+	"none",
+	"transparent",
+	"currentColor"
+]);
+/** `$tokens` the theme does not define, and `style` names it has no preset for. */
+const themeRefs = {
+	name: "theme-refs",
+	check: (index) => {
+		const theme = fileTheme(index);
+		if (!theme) return [];
+		const out = [];
+		for (const site of index.elements.values()) {
+			for (const [name, prop] of site.props) {
+				if (SKIP_KEYS.has(name) || prop.literal === void 0) continue;
+				walk(prop.literal, name, (value, path) => {
+					const m = typeof value === "string" ? TOKEN_PATTERN.exec(value) : null;
+					if (m && themeToken(theme, m[1]) === void 0) out.push({
+						rule: "theme-refs",
+						severity: "error",
+						message: `"${site.id}.${path}": ${value} is not a theme token (${Object.keys(theme.tokens).map((k) => `$${k}`).join(", ")})`,
+						range: prop.range,
+						id: site.id,
+						prop: name
+					});
+				});
+			}
+			const style = site.props.get("style");
+			if (STYLED_KINDS.includes(site.kind) && typeof style?.literal === "string" && !theme.styles[site.kind]?.[style.literal]) {
+				const known = Object.keys(theme.styles[site.kind] ?? {});
+				out.push({
+					rule: "theme-refs",
+					severity: "error",
+					message: `"${site.id}": no ${site.kind} style "${style.literal}" in the theme${known.length ? ` (${known.join(", ")})` : ""}`,
+					range: style.range,
+					id: site.id,
+					prop: "style"
+				});
+			}
+		}
+		return out;
+	}
+};
+/** With a theme declared, literal colours and fonts on graphics drift from it; name a token instead. */
+const themeLiterals = {
+	name: "theme-literals",
+	check: (index) => {
+		const theme = fileTheme(index);
+		if (!theme?.declared) return [];
+		const out = [];
+		const byValue = /* @__PURE__ */ new Map();
+		for (const [k, v] of Object.entries(theme.palette)) if (!byValue.has(v.toLowerCase())) byValue.set(v.toLowerCase(), k);
+		for (const site of index.elements.values()) {
+			if (!THEMED_KINDS.has(site.kind)) continue;
+			for (const [name, prop] of site.props) {
+				if (SKIP_KEYS.has(name) || prop.literal === void 0) continue;
+				walk(prop.literal, name, (value, path, key) => {
+					if (typeof value !== "string" || value.startsWith("$")) return;
+					if (key === "font") out.push({
+						rule: "theme-literals",
+						severity: "warning",
+						message: `"${site.id}.${path}" names font "${value}"; use $heading, $body or $mono so the theme sets it`,
+						range: prop.range,
+						id: site.id,
+						prop: name
+					});
+					else if (COLOR_KEYS.has(key) && !NOT_COLORS.has(value)) {
+						const token = byValue.get(value.toLowerCase());
+						out.push({
+							rule: "theme-literals",
+							severity: "warning",
+							message: `"${site.id}.${path}" is the literal colour ${value}; use ${token ? `$${token}` : "a palette token"} so a theme change reaches it`,
+							range: prop.range,
+							id: site.id,
+							prop: name
+						});
+					}
+				});
+			}
+		}
+		return out;
+	}
+};
+/** Fonts no renderer ships: the export sets them in Inter unless the fonts are passed to it. */
+const fontAvailable = {
+	name: "font-available",
+	check: (index) => {
+		const theme = fileTheme(index) ?? resolveTheme(void 0);
+		const out = [];
+		const seen = /* @__PURE__ */ new Set();
+		const check = (family, site, prop, name, path) => {
+			if (isBundledFont(family) || seen.has(`${site.id}.${path}`)) return;
+			seen.add(`${site.id}.${path}`);
+			out.push({
+				rule: "font-available",
+				severity: "warning",
+				message: `"${site.id}.${path}" uses font "${family}", which is not bundled; the export sets it in Inter unless the font is passed to it`,
+				range: [prop.range[0], prop.range[1]],
+				id: site.id,
+				prop: name
+			});
+		};
+		for (const site of index.elements.values()) for (const [name, prop] of site.props) {
+			if (SKIP_KEYS.has(name) || prop.literal === void 0) continue;
+			walk(prop.literal, name, (value, path, key) => {
+				if (key !== "font" || typeof value !== "string") return;
+				const m = TOKEN_PATTERN.exec(value);
+				const family = m ? themeToken(theme, m[1]) : value;
+				if (typeof family === "string") check(family, site, prop, name, path);
+			});
+		}
+		const comp = index.compositionId ? index.elements.get(index.compositionId) : void 0;
+		const themeProp = comp?.props.get("theme");
+		if (comp && themeProp && theme.declared) for (const [role, family] of Object.entries(theme.fonts)) check(family, comp, themeProp, "theme", `theme.fonts.${role}`);
+		return out;
+	}
+};
+/** The file's theme when the composition's `theme` is a literal (or absent); null when it is an expression. */
+function fileTheme(index) {
+	const prop = (index.compositionId ? index.elements.get(index.compositionId) : void 0)?.props.get("theme");
+	if (!prop) return resolveTheme(void 0);
+	if (prop.literal === void 0 || typeof prop.literal !== "object" || prop.literal === null) return null;
+	return resolveTheme(prop.literal);
+}
+function walk(value, path, visit, key = path) {
+	if (Array.isArray(value)) value.forEach((v, i) => walk(v, `${path}.${i}`, visit, key));
+	else if (typeof value === "object" && value !== null) {
+		for (const [k, v] of Object.entries(value)) if (!SKIP_KEYS.has(k)) walk(v, `${path}.${k}`, visit, k);
+	} else visit(value, path, key);
+}
+// src/source/lint/rules/index.ts
+const TIMING_PROPS = [
+	"in",
+	"out",
+	"duration",
+	"start",
+	"offset",
+	"anchor",
+	"at"
+];
+const literalIds = {
+	name: "literal-ids",
+	check: (index) => index.anonymous.map((a) => ({
+		rule: "literal-ids",
+		severity: "error",
+		message: `<${a.kind}>: ${a.reason}; every element needs a literal id so the editor can address it`,
+		range: a.range
+	}))
+};
+const uniqueIds = {
+	name: "unique-ids",
+	check: (index) => {
+		const seen = /* @__PURE__ */ new Map();
+		const out = [];
+		for (const { id, range } of index.idSites) {
+			const count = (seen.get(id) ?? 0) + 1;
+			seen.set(id, count);
+			if (count === 2) out.push({
+				rule: "unique-ids",
+				severity: "error",
+				message: `id "${id}" is used more than once`,
+				range,
+				id
+			});
+		}
+		return out;
+	}
+};
+const noStartOnSequence = {
+	name: "no-start-on-sequence",
+	check: (index) => {
+		const out = [];
+		for (const site of index.elements.values()) {
+			const start = site.props.get("start");
+			if (!start || !site.parent) continue;
+			const parent = index.elements.get(site.parent);
+			if (parent?.kind !== "track") continue;
+			if (parent.props.get("layout")?.literal === "free") continue;
+			if (site.props.has("anchor")) continue;
+			out.push({
+				rule: "no-start-on-sequence",
+				severity: "error",
+				message: `"${site.id}" has start on a sequence track; order decides start there, or use layout="free"`,
+				range: start.range,
+				id: site.id,
+				prop: "start"
+			});
+		}
+		return out;
+	}
+};
+/** The hooks a helper that makes elements may call: they read the player's clock, nothing else. */
+const LAYER_HOOKS = /* @__PURE__ */ new Set(["useT", "useLayer"]);
+const rules = [
+	literalIds,
+	uniqueIds,
+	noStartOnSequence,
+	{
+		name: "pure-helpers",
+		check: (index) => [...index.helpers.values()].filter((h) => h.producesElements && h.hooks.some((n) => !LAYER_HOOKS.has(n))).map((h) => ({
+			rule: "pure-helpers",
+			severity: "error",
+			message: `helper ${h.name} makes timeline elements and calls ${h.hooks.filter((n) => !LAYER_HOOKS.has(n)).join(", ")}; the resolver expands it as a plain function, so keep hooks in the free code inside a <Layer>`,
+			range: h.range
+		}))
+	},
+	strayHtml,
+	freeCodeClock,
+	{
+		name: "expression-locked",
+		check: (index) => {
+			const out = [];
+			for (const site of index.elements.values()) for (const prop of TIMING_PROPS) {
+				const p = site.props.get(prop);
+				if (p?.isExpression && p.binding === void 0) out.push({
+					rule: "expression-locked",
+					severity: "warning",
+					message: `"${site.id}.${prop}" is an expression; the timeline will show it locked`,
+					range: p.range,
+					id: site.id,
+					prop
+				});
+			}
+			return out;
+		}
+	},
+	{
+		name: "one-captions",
+		check: (index) => {
+			return [...index.elements.values()].filter((s) => s.kind === "captions").slice(1).map((s) => ({
+				rule: "one-captions",
+				severity: "error",
+				message: "a composition has one <Captions>",
+				range: s.range,
+				id: s.id
+			}));
+		}
+	},
+	{
+		name: "ambiguous-duration",
+		check: (index) => {
+			const out = [];
+			for (const site of index.elements.values()) {
+				if (![
+					"clip",
+					"audio",
+					"nested"
+				].includes(site.kind)) continue;
+				const d = site.props.get("duration");
+				if (d && site.props.has("out")) out.push({
+					rule: "ambiguous-duration",
+					severity: "error",
+					message: `"${site.id}" gives both out and duration`,
+					range: d.range,
+					id: site.id,
+					prop: "duration"
+				});
+			}
+			return out;
+		}
+	},
+	{
+		name: "file-shape",
+		check: (index) => {
+			const out = [];
+			if (!index.hasDefaultExport) out.push({
+				rule: "file-shape",
+				severity: "error",
+				message: "the file must default-export the video component",
+				range: [0, 0]
+			});
+			if (index.hasSchema && !index.defaults) out.push({
+				rule: "file-shape",
+				severity: "error",
+				message: "`export const schema` needs an `export const defaults = {…}` object literal",
+				range: [0, 0]
+			});
+			if (!index.compositionId) out.push({
+				rule: "file-shape",
+				severity: "error",
+				message: "no <Composition> found",
+				range: [0, 0]
+			});
+			return out;
+		}
+	},
+	{
+		name: "missing-asset",
+		check: (index, options) => {
+			if (!options.manifest) return [];
+			const out = [];
+			for (const site of index.elements.values()) {
+				const src = site.props.get("src");
+				if (typeof src?.literal !== "string" || !src.literal.startsWith("asset:")) continue;
+				if (!options.manifest.assets[src.literal.slice(6)]) out.push({
+					rule: "missing-asset",
+					severity: "error",
+					message: `${src.literal} is not in the manifest`,
+					range: src.range,
+					id: site.id,
+					prop: "src"
+				});
+			}
+			return out;
+		}
+	},
+	{
+		name: "sequence-gap",
+		check: (index) => {
+			const main = firstSequenceTrack(index);
+			if (!main) return [];
+			const out = [];
+			for (const site of index.elements.values()) {
+				if (site.kind !== "gap" || site.parent !== main.id) continue;
+				out.push({
+					rule: "sequence-gap",
+					severity: "warning",
+					message: `"${site.id}" is a gap on the first sequence track "${main.id}"; nothing is under it, so those frames are black unless another track covers them`,
+					range: site.range,
+					id: site.id
+				});
+			}
+			return out;
+		}
+	},
+	{
+		name: "cut-inside-word",
+		check: (index, options) => {
+			if (!options.manifest) return [];
+			const out = [];
+			for (const site of index.elements.values()) {
+				if (site.kind !== "clip" && site.kind !== "audio") continue;
+				const src = site.props.get("src")?.literal;
+				if (typeof src !== "string") continue;
+				const words = lookupAsset(options.manifest, src)?.transcript?.words;
+				if (!words || words.length === 0) continue;
+				for (const prop of ["in", "out"]) {
+					const p = site.props.get(prop);
+					if (typeof p?.literal !== "number") continue;
+					const t = p.literal;
+					const word = words.find((w) => t > w.start && t < w.end);
+					if (!word) continue;
+					const ref = prop === "in" ? `word:${word.i}` : `word:${word.i}.end`;
+					out.push({
+						rule: "cut-inside-word",
+						severity: "warning",
+						message: `"${site.id}.${prop}" = ${t} cuts inside "${word.text}" (${word.start}–${word.end}); use ${ref} or a time outside the word`,
+						range: p.range,
+						id: site.id,
+						prop
+					});
+				}
+			}
+			return out;
+		}
+	},
+	cutNearShot,
+	shotChangeInsideCrop,
+	repeatedSource,
+	themeRefs,
+	themeLiterals,
+	fontAvailable,
+	graphicProps,
+	notRendered
+];
+/** The composition's first track in document order that lays out as a sequence and is not hidden: the one under everything else. */
+function firstSequenceTrack(index) {
+	let first = null;
+	for (const site of index.elements.values()) {
+		if (site.kind !== "track" || site.parent !== index.compositionId) continue;
+		if (site.props.get("layout")?.literal === "free" || site.props.get("hidden")?.literal === true) continue;
+		if (!first || site.siblingIndex < first.siblingIndex) first = site;
+	}
+	return first;
+}
+// src/source/lint/index.ts
+/** Static checks on a video file: the conventions that keep it editable by the UI. */
+function lint(text, options = {}) {
+	const index = buildSourceIndex(text);
+	const enabled = options.rules ? rules.filter((r) => options.rules.includes(r.name)) : rules;
+	const out = [];
+	for (const rule of enabled) out.push(...rule.check(index, options));
+	return out.sort((a, b) => a.range[0] - b.range[0]);
+}
+// src/source/load.ts
+/** The modules a cut file may import. `@cut/kit` is the kit's old name, still accepted from older files. */
+const ALLOWED_IMPORTS = {
+	react: React,
+	"react/jsx-runtime": jsxRuntime,
+	zod,
+	"@cutcraft/kit": src_exports,
+	"@cut/kit": src_exports
+};
+function loadModule(source, options = {}) {
+	const { code } = transform(source, {
+		transforms: [
+			"typescript",
+			"jsx",
+			"imports"
+		],
+		keepUnusedImports: true,
+		jsxRuntime: "automatic",
+		production: true
+	});
+	const module = { exports: {} };
+	const offered = {
+		...ALLOWED_IMPORTS,
+		...options.imports
+	};
+	const require = (name) => {
+		if (!(name in offered)) throw new Error(`The file imports “${name}”, which this host does not offer (it offers ${Object.keys(offered).join(", ")}).`);
+		return offered[name];
+	};
+	new Function("require", "exports", "module", code)(require, module.exports, module);
+	if (typeof module.exports.default !== "function") throw new Error("The file has no default export (the video).");
+	return module.exports;
+}
+export { ALLOWED_IMPORTS, applyEdits, bake, buildSourceIndex, elementName, fold, foldToSource, indentOf, lineRange, lint, literalOf, loadModule, parseSource, printElement, printLiteral, printProp, rangeOf, rules };