@open-take/compositor 0.1.0

package/dist/index.js

@@ -0,0 +1,973 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import { spawn, spawnSync } from "node:child_process";
+import { copyFile, mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderVideo } from "@revideo/renderer";
+
+//#region src/types.ts
+/** True when motion blur is configured to actually do something (so the OFF
+*  path stays byte-identical to the pre-motion-blur renderer). */
+function motionBlurActive(mb) {
+	return !!mb && mb.samples > 1 && mb.shutter > 0;
+}
+const DEFAULT_FRAMING = {
+	insetFrac: .92,
+	cornerRadius: 28,
+	shadow: {
+		color: "rgba(0,0,0,0.55)",
+		blur: 60,
+		offset: {
+			x: 0,
+			y: 28
+		}
+	},
+	background: {
+		from: "#1e1b3a",
+		to: "#0a0e1c"
+	}
+};
+const DEFAULT_MOTION_BLUR = {
+	samples: 6,
+	shutter: .7
+};
+const DEFAULT_CURSOR = {
+	travelMs: 560,
+	travelWidthsPerSec: .35,
+	travelMinMs: 300,
+	travelMaxMs: 850,
+	scale: 2,
+	arcFrac: .05,
+	arcMax: 24,
+	rippleMs: 450,
+	holdMs: 1100,
+	zoomOutMs: 800,
+	zoomInMs: 760,
+	zoomEase: [
+		.3,
+		0,
+		.2,
+		1
+	],
+	dragLagMs: 190,
+	travelEase: [
+		.3,
+		0,
+		.2,
+		1
+	]
+};
+
+//#endregion
+//#region src/presets.ts
+const ZOOM_LEVELS = {
+	light: 1.25,
+	medium: 1.5,
+	tight: 1.8,
+	close: 2.2
+};
+/** Name a scale if it sits within tolerance of a preset; else null (custom). */
+function zoomLevelName(scale, tol = .07) {
+	let best = null;
+	let bestD = tol;
+	for (const [name, v] of Object.entries(ZOOM_LEVELS)) {
+		const d = Math.abs(scale - v);
+		if (d <= bestD) {
+			best = name;
+			bestD = d;
+		}
+	}
+	return best;
+}
+const MOTION = {
+	calm: {
+		travelWidthsPerSec: .28,
+		holdMs: 1500,
+		zoomInMs: 950,
+		zoomOutMs: 950
+	},
+	natural: {
+		travelWidthsPerSec: .35,
+		holdMs: 1100,
+		zoomInMs: 760,
+		zoomOutMs: 800
+	},
+	brisk: {
+		travelWidthsPerSec: .45,
+		holdMs: 750,
+		zoomInMs: 560,
+		zoomOutMs: 600
+	}
+};
+function motionName(cursor) {
+	for (const [name, m] of Object.entries(MOTION)) if (Math.abs(cursor.travelWidthsPerSec - m.travelWidthsPerSec) < .015 && Math.abs(cursor.holdMs - m.holdMs) < 60 && Math.abs(cursor.zoomInMs - m.zoomInMs) < 60 && Math.abs(cursor.zoomOutMs - m.zoomOutMs) < 60) return name;
+	return null;
+}
+const DARK_SHADOW = {
+	color: "rgba(0,0,0,0.55)",
+	blur: 60,
+	offset: {
+		x: 0,
+		y: 28
+	}
+};
+const LOOKS = {
+	midnight: {
+		background: {
+			from: "#1e1b3a",
+			to: "#0a0e1c"
+		},
+		cornerRadius: 28,
+		shadow: DARK_SHADOW
+	},
+	ink: {
+		background: {
+			from: "#16181d",
+			to: "#07080a"
+		},
+		cornerRadius: 28,
+		shadow: DARK_SHADOW
+	},
+	slate: {
+		background: {
+			from: "#232733",
+			to: "#0e1116"
+		},
+		cornerRadius: 28,
+		shadow: DARK_SHADOW
+	},
+	ocean: {
+		background: {
+			from: "#0c2b36",
+			to: "#071019"
+		},
+		cornerRadius: 28,
+		shadow: DARK_SHADOW
+	},
+	plum: {
+		background: {
+			from: "#2a1e3a",
+			to: "#140a1c"
+		},
+		cornerRadius: 28,
+		shadow: DARK_SHADOW
+	},
+	ember: {
+		background: {
+			from: "#38231d",
+			to: "#1a0d09"
+		},
+		cornerRadius: 28,
+		shadow: DARK_SHADOW
+	},
+	paper: {
+		background: {
+			from: "#f6f4ef",
+			to: "#ddd8cd"
+		},
+		cornerRadius: 22,
+		shadow: {
+			color: "rgba(31,27,20,0.30)",
+			blur: 45,
+			offset: {
+				x: 0,
+				y: 20
+			}
+		}
+	},
+	plain: {
+		background: {
+			from: "#101014",
+			to: "#101014",
+			type: "solid"
+		},
+		cornerRadius: 28,
+		shadow: DARK_SHADOW
+	}
+};
+function lookName(framing) {
+	const bg = framing.background;
+	for (const [name, l] of Object.entries(LOOKS)) if (l.background.from.toLowerCase() === bg.from.toLowerCase() && l.background.to.toLowerCase() === bg.to.toLowerCase() && (l.background.type ?? "gradient") === (bg.type ?? "gradient")) return name;
+	return null;
+}
+const FINISH = {
+	smooth: DEFAULT_MOTION_BLUR,
+	crisp: void 0,
+	heavy: {
+		samples: 8,
+		shutter: .85
+	}
+};
+function finishName(mb) {
+	const active = !!mb && mb.samples > 1 && mb.shutter > 0;
+	if (!active) return "crisp";
+	for (const [name, f] of Object.entries(FINISH)) if (f && mb && f.samples === mb.samples && Math.abs(f.shutter - mb.shutter) < .03) return name;
+	return null;
+}
+
+//#endregion
+//#region src/ffmpeg.ts
+let cachedFfmpeg;
+let cachedFfprobe;
+function runsOk(bin) {
+	try {
+		return spawnSync(bin, ["-version"], { stdio: "ignore" }).status === 0;
+	} catch {
+		return false;
+	}
+}
+async function installerPath(pkg) {
+	try {
+		const m = await import(pkg);
+		return m.default?.path ?? m.path ?? null;
+	} catch {
+		return null;
+	}
+}
+async function resolveFfmpeg() {
+	if (cachedFfmpeg) return cachedFfmpeg;
+	if (runsOk("ffmpeg")) {
+		cachedFfmpeg = "ffmpeg";
+		return cachedFfmpeg;
+	}
+	const p = await installerPath("@ffmpeg-installer/ffmpeg");
+	if (p && runsOk(p)) {
+		cachedFfmpeg = p;
+		return p;
+	}
+	throw new Error("ffmpeg not found — install it (e.g. `brew install ffmpeg`) or `npm install` so the bundled @ffmpeg-installer binary resolves for this platform");
+}
+async function resolveFfprobe() {
+	if (cachedFfprobe) return cachedFfprobe;
+	if (runsOk("ffprobe")) {
+		cachedFfprobe = "ffprobe";
+		return cachedFfprobe;
+	}
+	const p = await installerPath("@ffprobe-installer/ffprobe");
+	if (p && runsOk(p)) {
+		cachedFfprobe = p;
+		return p;
+	}
+	throw new Error("ffprobe not found — install ffmpeg (e.g. `brew install ffmpeg`) or `npm install` so the bundled @ffprobe-installer binary resolves for this platform");
+}
+
+//#endregion
+//#region src/math.ts
+var math_exports = {};
+__export(math_exports, {
+	bboxFitScale: () => bboxFitScale,
+	buildLegs: () => buildLegs,
+	buildStageKeyframes: () => buildStageKeyframes,
+	clampCenter: () => clampCenter,
+	cubicBezier: () => cubicBezier,
+	cursorPos: () => cursorPos,
+	gradientEndpoints: () => gradientEndpoints,
+	isDragging: () => isDragging,
+	keyvalN: () => keyvalN,
+	keyvalP: () => keyvalP,
+	panEasing: () => panEasing,
+	restStageScale: () => restStageScale,
+	smoother: () => smoother,
+	springEase: () => springEase,
+	stageEasing: () => stageEasing
+});
+function smoother(t) {
+	t = Math.max(0, Math.min(1, t));
+	return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function cubicBezier(x1, y1, x2, y2) {
+	const bx = (s) => {
+		const u = 1 - s;
+		return 3 * u * u * s * x1 + 3 * u * s * s * x2 + s * s * s;
+	};
+	const by = (s) => {
+		const u = 1 - s;
+		return 3 * u * u * s * y1 + 3 * u * s * s * y2 + s * s * s;
+	};
+	return (x) => {
+		if (x <= 0) return 0;
+		if (x >= 1) return 1;
+		let lo = 0, hi = 1, s = x;
+		for (let i = 0; i < 24; i++) {
+			const xt = bx(s);
+			if (Math.abs(xt - x) < 1e-4) break;
+			if (xt < x) lo = s;
+			else hi = s;
+			s = (lo + hi) / 2;
+		}
+		return by(s);
+	};
+}
+function springEase(bounce) {
+	const zeta = Math.max(.4, Math.min(1, 1 - bounce));
+	const Ts = -Math.log(.001) / zeta;
+	return (p) => {
+		if (p <= 0) return 0;
+		if (p >= 1) return 1;
+		const t = p * Ts;
+		if (zeta >= 1) return 1 - Math.exp(-t) * (1 + t);
+		const wd = Math.sqrt(1 - zeta * zeta);
+		return 1 - Math.exp(-zeta * t) * (Math.cos(wd * t) + zeta / wd * Math.sin(wd * t));
+	};
+}
+function stageEasing(cursor) {
+	if (cursor.zoomSpring != null) return springEase(cursor.zoomSpring);
+	if (cursor.zoomEase) return cubicBezier(...cursor.zoomEase);
+	return smoother;
+}
+function panEasing(cursor) {
+	if (cursor.zoomEase) return cubicBezier(...cursor.zoomEase);
+	return smoother;
+}
+function gradientEndpoints(angleDeg, oW, oH) {
+	if (angleDeg == null) return {
+		x0: 0,
+		y0: 0,
+		x1: oW,
+		y1: oH
+	};
+	const th = angleDeg * Math.PI / 180;
+	const dx = Math.sin(th);
+	const dy = -Math.cos(th);
+	const L = Math.abs(oW * dx) + Math.abs(oH * dy);
+	const cx = oW / 2;
+	const cy = oH / 2;
+	return {
+		x0: cx - dx * L / 2,
+		y0: cy - dy * L / 2,
+		x1: cx + dx * L / 2,
+		y1: cy + dy * L / 2
+	};
+}
+function keyvalN(t, kfs, ease = smoother, easeDown) {
+	if (t <= kfs[0][0]) return kfs[0][1];
+	if (t >= kfs[kfs.length - 1][0]) return kfs[kfs.length - 1][1];
+	for (let i = 0; i < kfs.length - 1; i++) {
+		const [t0, v0] = kfs[i];
+		const [t1, v1] = kfs[i + 1];
+		if (t0 <= t && t <= t1) {
+			const e = easeDown && v1 < v0 ? easeDown : ease;
+			return v0 + (v1 - v0) * e((t - t0) / (t1 - t0));
+		}
+	}
+	return kfs[kfs.length - 1][1];
+}
+function keyvalP(t, kfs, ease = smoother) {
+	if (t <= kfs[0][0]) return kfs[0][1];
+	if (t >= kfs[kfs.length - 1][0]) return kfs[kfs.length - 1][1];
+	for (let i = 0; i < kfs.length - 1; i++) {
+		const [t0, v0] = kfs[i];
+		const [t1, v1] = kfs[i + 1];
+		if (t0 <= t && t <= t1) {
+			const p = ease((t - t0) / (t1 - t0));
+			return {
+				x: v0.x + (v1.x - v0.x) * p,
+				y: v0.y + (v1.y - v0.y) * p
+			};
+		}
+	}
+	return kfs[kfs.length - 1][1];
+}
+/**
+* Scale (absolute, video-px → output-px) that fits `bbox` into `fillFrac`
+* of the output frame, capped at `maxScale` and floored at `restScale`.
+* Wide/long elements naturally get a gentler scale because the limiting
+* dimension dominates min().
+*/
+function bboxFitScale(bbox, outW, outH, fillFrac, maxScale, restScale) {
+	const fitW = outW * fillFrac / Math.max(1, bbox.w);
+	const fitH = outH * fillFrac / Math.max(1, bbox.h);
+	return Math.min(maxScale, Math.max(restScale, Math.min(fitW, fitH)));
+}
+/** Stage scale at rest: video inset into the frame (leaves backdrop margin). */
+function restStageScale(videoW, videoH, outW, outH, insetFrac) {
+	return insetFrac * Math.min(outW / videoW, outH / videoH);
+}
+/**
+* Clamp a desired video-px center so the scaled video still covers the output
+* frame (the viewport crop stays inside the source video) when zoomed in. When
+* the content does not cover an axis (zoomed out / inset), centre that axis.
+*
+* In the composition-camera model the whole composition
+* (backdrop + inset screen) is zoomed by one camera; this keeps the camera crop
+* within the screen so a zoom fills the frame (no backdrop margin) without ever
+* panning past the recording's edge.
+*/
+function clampCenter(center, scale, videoW, videoH, outW, outH) {
+	const halfW = outW / (2 * scale);
+	const halfH = outH / (2 * scale);
+	const cx = videoW * scale >= outW ? Math.min(Math.max(center.x, halfW), videoW - halfW) : videoW / 2;
+	const cy = videoH * scale >= outH ? Math.min(Math.max(center.y, halfH), videoH - halfH) : videoH / 2;
+	return {
+		x: cx,
+		y: cy
+	};
+}
+function buildStageKeyframes(comp) {
+	const { videoWidth: vW, videoHeight: vH } = comp.source;
+	const { width: oW, height: oH } = comp.output;
+	const rest = restStageScale(vW, vH, oW, oH, comp.framing.insetFrac);
+	const restC = {
+		x: vW / 2,
+		y: vH / 2
+	};
+	const HOLD = comp.cursor.holdMs / 1e3;
+	const ZOUT = comp.cursor.zoomOutMs / 1e3;
+	const anchors = [];
+	for (const e of comp.events) {
+		const base = {
+			tMs: e.tMs,
+			durationMs: e.durationMs ?? 0,
+			inAtMs: e.zoom.inAtMs
+		};
+		if (e.kind === "scroll" || e.kind === "press" && !e.zoom.enabled) anchors.push({
+			...base,
+			scale: rest,
+			center: restC
+		});
+		else if (e.zoom.enabled) anchors.push({
+			...base,
+			scale: e.zoom.scale,
+			center: e.zoom.center,
+			glide: e.zoom.glide
+		});
+	}
+	const zf = [{
+		t: 0,
+		s: rest
+	}];
+	const cf = [{
+		t: 0,
+		c: restC
+	}];
+	const push = (t, s, c) => {
+		zf.push({
+			t: Math.max(t, zf[zf.length - 1].t + .001),
+			s
+		});
+		cf.push({
+			t: Math.max(t, cf[cf.length - 1].t + .001),
+			c
+		});
+	};
+	const pushC = (t, c) => {
+		cf.push({
+			t: Math.max(t, cf[cf.length - 1].t + .001),
+			c
+		});
+	};
+	const ze = panEasing(comp.cursor);
+	const invEase = (target) => {
+		let lo = 0;
+		let hi = 1;
+		for (let i = 0; i < 30; i++) {
+			const m = (lo + hi) / 2;
+			if (ze(m) < target) lo = m;
+			else hi = m;
+		}
+		return (lo + hi) / 2;
+	};
+	const fillThreshold = Math.max(oW / vW, oH / vH);
+	let cur = {
+		s: rest,
+		c: restC
+	};
+	anchors.forEach((e, i) => {
+		const rampStart = e.inAtMs / 1e3;
+		const clickT = e.tMs / 1e3;
+		const actionEnd = (e.tMs + e.durationMs) / 1e3;
+		const next = anchors[i + 1];
+		const holdEndT = next ? next.inAtMs / 1e3 : actionEnd + HOLD;
+		let holdC = e.center;
+		if (e.glide && (e.glide.x !== 0 || e.glide.y !== 0)) {
+			const holdDur = Math.max(0, holdEndT - clickT);
+			holdC = {
+				x: e.center.x + e.glide.x * holdDur,
+				y: e.center.y + e.glide.y * holdDur
+			};
+		}
+		push(rampStart, cur.s, cur.c);
+		if (cur.s > fillThreshold && e.scale < fillThreshold && fillThreshold > rest && clickT > rampStart && Math.hypot(e.center.x - cur.c.x, e.center.y - cur.c.y) > 1) {
+			const uCross = invEase((fillThreshold - cur.s) / (e.scale - cur.s));
+			pushC(rampStart + uCross * (clickT - rampStart), e.center);
+		}
+		push(clickT, e.scale, e.center);
+		cur = {
+			s: e.scale,
+			c: holdC
+		};
+		if (next) push(holdEndT, cur.s, cur.c);
+		else {
+			const holdEnd = holdEndT;
+			push(holdEnd, cur.s, cur.c);
+			const offset = Math.hypot(cur.c.x - restC.x, cur.c.y - restC.y) > 1;
+			if (offset && cur.s > fillThreshold && fillThreshold > rest) {
+				const uCross = invEase((fillThreshold - cur.s) / (rest - cur.s));
+				pushC(holdEnd + uCross * ZOUT, restC);
+			}
+			push(holdEnd + ZOUT, rest, restC);
+			cur = {
+				s: rest,
+				c: restC
+			};
+		}
+	});
+	const lastT = Math.max(zf[zf.length - 1].t, cf[cf.length - 1].t);
+	const T = Math.max(comp.durationMs / 1e3, lastT) + .3;
+	push(T, rest, restC);
+	return {
+		z: zf.map((f) => [f.t, f.s]),
+		c: cf.map((f) => [f.t, f.c]),
+		T
+	};
+}
+function buildLegs(comp) {
+	const legs = [];
+	let cur = comp.start;
+	const { travelWidthsPerSec, travelMinMs, travelMaxMs, travelMs } = comp.cursor;
+	const speedPxPerMs = (travelWidthsPerSec || 0) * comp.source.videoWidth / 1e3;
+	const travelDur = (a, b) => {
+		if (speedPxPerMs <= 0) return travelMs / 1e3;
+		const dist = Math.hypot(b.x - a.x, b.y - a.y);
+		return Math.min(travelMaxMs, Math.max(travelMinMs, dist / speedPxPerMs)) / 1e3;
+	};
+	for (const e of comp.events) {
+		if (e.kind === "scroll" || e.kind === "press") continue;
+		const arrive = e.tMs / 1e3;
+		const prevEnd = legs.length ? legs[legs.length - 1].t1 : 0;
+		const t0 = Math.max(arrive - travelDur(cur, e.point), prevEnd, 0);
+		legs.push({
+			t0,
+			t1: arrive,
+			a: cur,
+			b: e.point
+		});
+		cur = e.point;
+		if (e.kind === "drag" && e.to) {
+			const lag = comp.cursor.dragLagMs / 1e3;
+			const start = arrive + lag;
+			const dEnd = (e.tMs + (e.durationMs ?? 0)) / 1e3 + lag;
+			const path = e.path && e.path.length >= 2 ? e.path : [e.point, e.to];
+			if (dEnd > start) legs.push({
+				t0: start,
+				t1: dEnd,
+				a: e.point,
+				b: e.to,
+				drag: true,
+				path,
+				ease: e.ease
+			});
+			cur = e.to;
+		}
+	}
+	return legs;
+}
+/** Point a fraction `u` (0..1) along a polyline, parameterised by arc length. */
+function alongPath(path, u) {
+	if (path.length === 1) return path[0];
+	const seg = [];
+	let total = 0;
+	for (let i = 0; i < path.length - 1; i++) {
+		const d = Math.hypot(path[i + 1].x - path[i].x, path[i + 1].y - path[i].y);
+		seg.push(d);
+		total += d;
+	}
+	if (total === 0) return path[0];
+	let target = u * total;
+	for (let i = 0; i < seg.length; i++) {
+		if (target <= seg[i] || i === seg.length - 1) {
+			const f = seg[i] > 0 ? target / seg[i] : 0;
+			return {
+				x: path[i].x + (path[i + 1].x - path[i].x) * f,
+				y: path[i].y + (path[i + 1].y - path[i].y) * f
+			};
+		}
+		target -= seg[i];
+	}
+	return path[path.length - 1];
+}
+function cursorPos(t, legs, comp) {
+	for (const lg of legs) if (lg.t0 <= t && t <= lg.t1) {
+		const raw = Math.max(0, Math.min(1, (t - lg.t0) / (lg.t1 - lg.t0)));
+		if (lg.drag && lg.path) return alongPath(lg.path, lg.ease === "smooth" ? smoother(raw) : raw);
+		const e = comp.cursor.travelEase;
+		const p = e ? cubicBezier(e[0], e[1], e[2], e[3])(raw) : smoother(raw);
+		const base = {
+			x: lg.a.x + (lg.b.x - lg.a.x) * p,
+			y: lg.a.y + (lg.b.y - lg.a.y) * p
+		};
+		const dx = lg.b.x - lg.a.x, dy = lg.b.y - lg.a.y;
+		const L = Math.hypot(dx, dy) || 1;
+		const arc = Math.min(comp.cursor.arcFrac * L, comp.cursor.arcMax) * Math.sin(Math.PI * p);
+		return {
+			x: base.x + -dy / L * arc,
+			y: base.y + dx / L * arc
+		};
+	}
+	if (legs.length === 0 || t < legs[0].t0) return comp.start;
+	for (let i = 0; i < legs.length - 1; i++) if (legs[i].t1 < t && t < legs[i + 1].t0) return legs[i].b;
+	return legs[legs.length - 1].b;
+}
+/** True while a drag is mid-stroke (button held) — for the pressed cursor. */
+function isDragging(t, legs) {
+	return legs.some((lg) => lg.drag === true && lg.t0 <= t && t <= lg.t1);
+}
+
+//#endregion
+//#region src/plan.ts
+function planComposition(log, opts = {}) {
+	const vW = log.video.width, vH = log.video.height;
+	const oW = opts.output?.width ?? vW;
+	const oH = opts.output?.height ?? vH;
+	const fps = opts.output?.fps ?? 30;
+	const fillFrac = opts.fillFrac ?? .55;
+	const maxScale = opts.maxScale ?? 1.5;
+	const zoomRatio = opts.zoomRatio ?? 1.3;
+	const zoomFirst = opts.zoomFirst ?? false;
+	const framing = {
+		...DEFAULT_FRAMING,
+		...opts.framing
+	};
+	const cursor = {
+		...DEFAULT_CURSOR,
+		...opts.cursor
+	};
+	const sx = vW / log.viewport.w;
+	const sy = vH / log.viewport.h;
+	const mapPt = (p) => ({
+		x: p.x * sx,
+		y: p.y * sy
+	});
+	const mapBox = (b) => ({
+		x: b.x * sx,
+		y: b.y * sy,
+		w: b.w * sx,
+		h: b.h * sy
+	});
+	const rest = restStageScale(vW, vH, oW, oH, framing.insetFrac);
+	const pathBBox = (pts) => {
+		const xs = pts.map((p) => p.x), ys = pts.map((p) => p.y);
+		const x = Math.min(...xs), y = Math.min(...ys);
+		return {
+			x,
+			y,
+			w: Math.max(...xs) - x,
+			h: Math.max(...ys) - y
+		};
+	};
+	const events = log.events.map((c, i) => {
+		const kind = c.kind ?? "click";
+		const point = mapPt({
+			x: c.x,
+			y: c.y
+		});
+		const isFirst = i === 0;
+		const intent = c.zoom ?? "auto";
+		const durationMs$1 = "durationMs" in c ? c.durationMs : 0;
+		const to = kind === "drag" ? mapPt(c.to) : void 0;
+		const rawPath = kind === "drag" ? c.path ?? [{
+			x: c.x,
+			y: c.y
+		}, c.to] : void 0;
+		const path = rawPath?.map(mapPt);
+		const ease = kind === "drag" ? c.ease : void 0;
+		const bbox = kind === "drag" && path ? pathBBox(path) : c.box ? mapBox(c.box) : void 0;
+		let enabled = false;
+		let scale = rest;
+		let reason;
+		const center = bbox ? {
+			x: bbox.x + bbox.w / 2,
+			y: bbox.y + bbox.h / 2
+		} : point;
+		const fit = bbox ? bboxFitScale(bbox, oW, oH, fillFrac, maxScale, rest) : maxScale;
+		if (kind === "scroll") {
+			enabled = false;
+			reason = "scroll — full view (content pans, no zoom)";
+		} else if (intent === "never") {
+			enabled = false;
+			reason = "plan: zoom=never (global/navigation payoff — keep full view)";
+		} else if (intent === "always") {
+			enabled = true;
+			scale = fit;
+			reason = `plan: zoom=always → ${fit.toFixed(2)}x (capped ${maxScale}x)`;
+		} else if (!bbox) reason = "no bbox in event log — cannot bbox-fit, so no zoom (avoids framing dead space)";
+		else {
+			scale = fit;
+			const meaningful = fit > rest * zoomRatio;
+			const region = kind === "drag" ? "drag path" : "element";
+			if (isFirst && !zoomFirst) {
+				enabled = false;
+				reason = `first/orienting action — skipped by default (fit ${fit.toFixed(2)}x available)`;
+			} else if (!meaningful) {
+				enabled = false;
+				reason = `${region} fills the frame already (fit ${fit.toFixed(2)}x ≈ rest ${rest.toFixed(2)}x) — gentle/no zoom`;
+			} else {
+				enabled = true;
+				reason = `bbox-fit ${fit.toFixed(2)}x (capped ${maxScale}x), ${region} framed with ${Math.round(fillFrac * 100)}% fill`;
+			}
+		}
+		return {
+			kind,
+			tMs: c.tMs,
+			point,
+			bbox,
+			label: c.sel ?? c.note,
+			zoom: {
+				enabled,
+				scale,
+				center,
+				inAtMs: Math.max(0, c.tMs - cursor.zoomInMs),
+				reason
+			},
+			...durationMs$1 ? { durationMs: durationMs$1 } : {},
+			...kind === "type" ? { text: c.text } : {},
+			...kind === "press" ? { keys: c.keys } : {},
+			...to ? { to } : {},
+			...path ? { path } : {},
+			...ease ? { ease } : {}
+		};
+	});
+	const start = log.start ? mapPt(log.start) : {
+		x: vW * .25,
+		y: vH * .9
+	};
+	const last = log.events.length ? log.events[log.events.length - 1] : void 0;
+	const lastEnd = last ? last.tMs + ("durationMs" in last ? last.durationMs : 0) : 0;
+	const durationMs = Math.max(log.tEndMs ?? 0, lastEnd + cursor.holdMs + cursor.zoomOutMs + 400);
+	return {
+		output: {
+			width: oW,
+			height: oH,
+			fps
+		},
+		source: {
+			videoUrl: "/capture.mp4",
+			videoWidth: vW,
+			videoHeight: vH,
+			viewport: log.viewport
+		},
+		framing,
+		cursor,
+		motionBlur: DEFAULT_MOTION_BLUR,
+		start,
+		events,
+		durationMs
+	};
+}
+
+//#endregion
+//#region src/validate.ts
+const reqField = {
+	type: "text",
+	press: "keys",
+	drag: "to"
+};
+function validateComposition(comp, opts = {}) {
+	const issues = [];
+	const err = (path, message, fix) => issues.push({
+		severity: "error",
+		path,
+		message,
+		fix
+	});
+	const warn = (path, message, fix) => issues.push({
+		severity: "warn",
+		path,
+		message,
+		fix
+	});
+	const maxScale = opts.maxScale ?? 2.5;
+	const { width: oW, height: oH, fps } = comp.output;
+	if (!(oW > 0 && oH > 0)) err("output", `non-positive output size ${oW}x${oH}`, "set positive width/height");
+	if (!(fps > 0)) err("output.fps", `fps must be > 0 (got ${fps})`, "set output.fps to 30 or 60");
+	const { videoWidth: vW, videoHeight: vH } = comp.source;
+	if (!(vW > 0 && vH > 0)) err("source", `non-positive source video size ${vW}x${vH}`);
+	const rest = restStageScale(vW, vH, oW, oH, comp.framing.insetFrac);
+	const mb = comp.motionBlur;
+	if (mb) {
+		if (!Number.isInteger(mb.samples) || mb.samples < 1 || mb.samples > 16) err("motionBlur.samples", `samples must be an integer 1-16 (got ${mb.samples})`, "6 is the balanced default; 1 turns blur off");
+		else if (mb.samples > 9) warn("motionBlur.samples", `samples ${mb.samples} renders ${mb.samples}× the frames for little extra smoothness`, "9 is the practical ceiling");
+		if (!(mb.shutter >= 0 && mb.shutter <= 1)) err("motionBlur.shutter", `shutter must be 0..1 (got ${mb.shutter})`, "0.7 is the default; 0 turns blur off");
+	}
+	const events = comp.events ?? [];
+	let lastEnd = 0;
+	let prevT = -1;
+	for (let i = 0; i < events.length; i++) {
+		const e = events[i];
+		const p = `events[${i}]`;
+		const dur = e.durationMs ?? 0;
+		const endMs = e.tMs + dur;
+		lastEnd = Math.max(lastEnd, endMs);
+		if (e.tMs < prevT) err(`${p}.tMs`, `tMs ${e.tMs} is before the previous beat (${prevT}) — events out of order`, "events follow the recording; reordering needs a re-capture, not a swap here");
+		prevT = e.tMs;
+		if (e.tMs < 0) err(`${p}.tMs`, `negative tMs ${e.tMs}`);
+		if (e.tMs > comp.durationMs) err(`${p}.tMs`, `tMs ${e.tMs} exceeds composition durationMs ${comp.durationMs}`, "raise durationMs or remove the beat");
+		const need = reqField[e.kind];
+		if (need && e[need] == null) err(`${p}.${need}`, `${e.kind} beat is missing "${need}"`, `restore ${need} from the capture`);
+		const z = e.zoom;
+		if (!z) {
+			err(`${p}.zoom`, "missing zoom decision", "every beat needs a zoom { enabled, scale, center, inAtMs }");
+			continue;
+		}
+		if (z.inAtMs < 0) err(`${p}.zoom.inAtMs`, `negative inAtMs ${z.inAtMs}`, "clamp to 0");
+		if (z.inAtMs > e.tMs) err(`${p}.zoom.inAtMs`, `inAtMs ${z.inAtMs} is AFTER the action at tMs ${e.tMs} — the zoom would arrive late`, `set inAtMs = tMs − cursor.zoomInMs (= ${Math.max(0, e.tMs - comp.cursor.zoomInMs)})`);
+		if (z.enabled) {
+			if (z.scale < rest - 1e-6) err(`${p}.zoom.scale`, `scale ${z.scale.toFixed(3)} is below rest ${rest.toFixed(3)} — that zooms OUT past the frame (dead space)`, `raise to ≥ ${rest.toFixed(2)}, or set zoom.enabled=false for a full-view beat`);
+			else if (z.scale <= rest + 1e-6) warn(`${p}.zoom.scale`, `scale ${z.scale.toFixed(3)} ≈ rest — zoom is enabled but does nothing visible`, "raise scale to actually zoom, or set enabled=false");
+			if (z.scale > maxScale) warn(`${p}.zoom.scale`, `scale ${z.scale.toFixed(2)} exceeds the soft cap ${maxScale} — pixels will soften`, `clamp toward ${maxScale.toFixed(1)} unless the detail truly needs it`);
+			if (z.center.x < 0 || z.center.x > vW || z.center.y < 0 || z.center.y > vH) warn(`${p}.zoom.center`, `center (${z.center.x.toFixed(0)},${z.center.y.toFixed(0)}) is outside the video ${vW}x${vH}`, e.bbox ? "use the bbox center: { x: bbox.x+bbox.w/2, y: bbox.y+bbox.h/2 }" : "point at the on-screen target (video-px)");
+			if (!e.bbox) warn(`${p}.zoom`, "zoom enabled on a beat with no bbox — center/scale are hand-set, not bbox-fit", "double-check the center frames the intended region");
+		}
+	}
+	if (comp.durationMs < lastEnd) err("durationMs", `durationMs ${comp.durationMs} ends before the last action (${lastEnd})`, `raise to ≥ ${Math.round(lastEnd + comp.cursor.holdMs + comp.cursor.zoomOutMs)}`);
+	else if (comp.durationMs < lastEnd + comp.cursor.zoomOutMs) warn("durationMs", `only ${comp.durationMs - lastEnd}ms after the last action — the final zoom-out may be cut`, `allow ≥ ${comp.cursor.zoomOutMs}ms (cursor.zoomOutMs) of tail`);
+	if (opts.captureLog) {
+		const log = opts.captureLog;
+		if (log.events.length !== events.length) warn("events", `composition has ${events.length} beats but the capture log has ${log.events.length} — added/removed actions need a re-capture`, "re-capture to change the choreography; edit only renders the existing recording");
+		const n = Math.min(log.events.length, events.length);
+		for (let i = 0; i < n; i++) {
+			const lt = log.events[i].tMs;
+			const ct = events[i].tMs;
+			if (Math.abs(lt - ct) > 1) err(`events[${i}].tMs`, `tMs ${ct} drifted from the captured ${lt} — an action's tMs is capture-locked (the video shows it at ${lt}ms)`, `restore tMs to ${lt}; to retime the action itself, re-capture`);
+		}
+	}
+	return issues;
+}
+/** Format issues for a human/agent log. Errors first. */
+function formatIssues(issues) {
+	if (!issues.length) return "composition OK (0 issues)";
+	const order = (s) => s === "error" ? 0 : 1;
+	return issues.slice().sort((a, b) => order(a.severity) - order(b.severity)).map((i) => `  [${i.severity}] ${i.path}: ${i.message}${i.fix ? `\n          fix: ${i.fix}` : ""}`).join("\n");
+}
+
+//#endregion
+//#region src/render.ts
+const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const PUBLIC_MP4 = resolve(PKG_ROOT, "public/capture.mp4");
+const COMP_JSON = resolve(PKG_ROOT, "src/scene/.composition.json");
+const RENDER_OUT = "out-render";
+function run(cmd, args) {
+	return new Promise((res, rej) => {
+		const c = spawn(cmd, args, { stdio: [
+			"ignore",
+			"ignore",
+			"pipe"
+		] });
+		let err = "";
+		c.stderr.on("data", (d) => err += d);
+		c.on("error", rej);
+		c.on("close", (code) => code === 0 ? res() : rej(new Error(`${cmd} exited ${code}: ${err}`)));
+	});
+}
+/** Normalise the capture to a constant-fps mp4 the web decoder can read.
+*  fps follows the composition so a hi-fps capture can render at 60 (the
+*  render grid must match — a 30-grid would throw away the extra frames). */
+async function toMp4(videoPath, outMp4, fps) {
+	await mkdir(dirname(outMp4), { recursive: true });
+	await run(await resolveFfmpeg(), [
+		"-y",
+		"-loglevel",
+		"error",
+		"-i",
+		resolve(videoPath),
+		"-c:v",
+		"libx264",
+		"-pix_fmt",
+		"yuv420p",
+		"-crf",
+		"18",
+		"-r",
+		String(fps),
+		"-an",
+		outMp4
+	]);
+}
+/** Temporal-supersampling motion blur: the scene was rendered at fps·samples
+*  (project.ts); average a trailing shutter window of sub-frames back down to the
+*  output fps. `tmix=frames=M` averages M consecutive sub-frames; `fps=baseFps`
+*  then decimates ≈every `samples`-th, so each output frame = the mean of the last
+*  M sub-frames of its interval (a trailing shutter). Re-tags bt709/tv to match
+*  the capture pipeline (the input is already bt709, but tmix→encode must keep it). */
+async function motionBlurMp4(inMp4, outMp4, baseFps, samples, shutter) {
+	const M = Math.max(1, Math.min(samples, Math.round(shutter * samples)));
+	const vf = `tmix=frames=${M},fps=${baseFps},format=yuv420p,setparams=range=tv:colorspace=bt709:color_primaries=bt709:color_trc=bt709`;
+	await run(await resolveFfmpeg(), [
+		"-y",
+		"-loglevel",
+		"error",
+		"-i",
+		resolve(inMp4),
+		"-vf",
+		vf,
+		"-c:v",
+		"libx264",
+		"-pix_fmt",
+		"yuv420p",
+		"-crf",
+		"18",
+		"-r",
+		String(baseFps),
+		"-an",
+		outMp4
+	]);
+}
+async function renderTake(opts) {
+	const composition = opts.composition ?? planComposition(opts.log ?? (() => {
+		throw new Error("renderTake: provide `log` or `composition`");
+	})(), opts.planOpts);
+	if (!opts.skipValidate) {
+		const issues = validateComposition(composition, { captureLog: opts.captureLog ?? opts.log });
+		const errors = issues.filter((i) => i.severity === "error");
+		const warns = issues.filter((i) => i.severity === "warn");
+		if (opts.logProgress && warns.length) process.stderr.write(`composition warnings:\n${formatIssues(warns)}\n`);
+		if (errors.length) throw new Error(`composition has ${errors.length} error(s) — refusing to render:\n${formatIssues(errors)}`);
+	}
+	await toMp4(opts.videoPath, PUBLIC_MP4, composition.output.fps);
+	await mkdir(dirname(COMP_JSON), { recursive: true });
+	await writeFile(COMP_JSON, JSON.stringify(composition, null, 2));
+	if (process.env.DISABLE_TELEMETRY === void 0) process.env.DISABLE_TELEMETRY = "true";
+	const prevCwd = process.cwd();
+	process.chdir(PKG_ROOT);
+	let produced;
+	try {
+		produced = await renderVideo({
+			projectFile: "/src/scene/project.ts",
+			settings: {
+				outFile: "take.mp4",
+				outDir: RENDER_OUT,
+				workers: 1,
+				...opts.rangeSec ? { projectSettings: { range: opts.rangeSec } } : {},
+				logProgress: opts.logProgress ?? false,
+				...opts.onProgress ? { progressCallback: (_worker, progress) => opts.onProgress(progress) } : {},
+				puppeteer: {
+					args: [
+						"--no-sandbox",
+						"--disable-setuid-sandbox",
+						"--password-store=basic",
+						"--use-mock-keychain"
+					],
+					...opts.chromePath ? { executablePath: opts.chromePath } : {}
+				}
+			}
+		});
+	} finally {
+		process.chdir(prevCwd);
+	}
+	await mkdir(dirname(resolve(opts.outPath)), { recursive: true });
+	const producedAbs = resolve(PKG_ROOT, produced);
+	if (motionBlurActive(composition.motionBlur)) await motionBlurMp4(producedAbs, resolve(opts.outPath), composition.output.fps, composition.motionBlur.samples, composition.motionBlur.shutter);
+	else await copyFile(producedAbs, resolve(opts.outPath));
+	const compositionPath = resolve(opts.outPath).replace(/\.mp4$/i, "") + ".composition.json";
+	if (opts.writeCompositionSibling !== false) {
+		const { review: _review,...persisted } = composition;
+		await writeFile(compositionPath, JSON.stringify(persisted, null, 2));
+	}
+	return {
+		mp4Path: resolve(opts.outPath),
+		compositionPath
+	};
+}
+
+//#endregion
+export { DEFAULT_CURSOR, DEFAULT_FRAMING, DEFAULT_MOTION_BLUR, FINISH, LOOKS, MOTION, ZOOM_LEVELS, finishName, formatIssues, lookName, math_exports as math, motionBlurActive, motionName, planComposition, renderTake, resolveFfmpeg, resolveFfprobe, validateComposition, zoomLevelName };
+//# sourceMappingURL=index.js.map