cozyclay 1.7.1 → 1.8.1

package/CHANGELOG.md

@@ -1,5 +1,91 @@
 # Changelog
 
+## 1.8.1
+
+The Studio camera tutorial now starts where the landing page does and shows
+where to click.
+
+- Opening the tutorial (Settings ▾ → Camera tutorial or `/app/?tutorial=camera`)
+  loads the City Block starter scene with the walk take on its character, at
+  frame 0 in the free camera, so Shot / Rail / Play have something to frame.
+  A scene with unsaved changes is replaced only after a confirm.
+- Each step points at its control: a pulsing spotlight plus a numbered beacon
+  and caption pinned to `+ Add shot`, the shot block and `Draw rail`, the
+  top view, and the look-through button; the Look / Walk / Dolly / Orbit steps
+  show an animated mouse-and-keys cue in the viewport, with the walk keycaps
+  turning green as they are pressed. The hint card names the region ("↓
+  Timeline, Shots lane", "→ Viewport"). Overlays never take the pointer and go
+  static under `prefers-reduced-motion`.
+
+## 1.8.0
+
+The Studio's chrome gets a research-backed cut: the same capabilities, a third
+fewer controls on screen at once, and one place for each of them. A first-time
+creator can now learn the camera inside the Studio itself, or on cozyclay.org
+before installing, and keep the scene they made. Video mocap gets a quality
+gate, and AI video takes are checked against the scene they were supposed to
+preserve.
+
+### Studio UI simplification
+
+- Simultaneously visible controls drop from 49 / 54 / 65 (Scene / Camera /
+  Motion mode) to 35 / 38 / 51, measured by `tools/qa/studio-control-count.mjs`
+  and recorded with the per-control rationale in `docs/studio-ui-ia.md`.
+- The top bar keeps five actions. One **Export ▾** menu leads with the keyframe
+  pack and folds the mp4, depth/normal passes, storyboard and blocking frame
+  under it; the three Record buttons and the inspector's duplicate FOV/Recenter
+  are gone. **Settings ▾** holds language and analytics.
+- **View ▾** on the viewport bar owns the reference grid, Auto Color and body
+  part colours; Move/Rotate/Scale stay on the transform strip only.
+- The scene switcher sits on the hierarchy's root row; the Projects… button,
+  the root fold caret and the Characters group row are removed and characters
+  sit directly under the scene.
+- Timeline motion tools (IK, Foot, Body, speed, Clear, take bar) render only in
+  Motion mode; Foot snap and Body contact appear only while IK is on.
+- The Scene/PlayView tabs are replaced by the viewport's look-through button:
+  it enters an explicit preview of the shot camera and Esc returns.
+- Selecting the camera switches to Camera mode; the Placement row appears in
+  Motion mode; Generate all waits for at least one prompt block.
+- The `advancedMode` / `beginnerMode` gates that had been hardcoded on are
+  removed.
+
+### Learn the camera
+
+- A seven-step camera tutorial runs inside the Studio: Look, Walk (W A S D
+  Q E), Dolly, Orbit, Shot, Rail, Play. Open it from Settings ▾ → Camera
+  tutorial or `/app/?tutorial=camera`; each step completes only when the
+  gesture actually happens, and the strip never takes the pointer.
+- cozyclay.org embeds a live Studio playground on a preset city block with the
+  same seven steps, a second demo reel, and leaner copy. The tutorial ends by
+  handing over `npx cozyclay --scene city-block`, which opens the local Studio
+  on that starter scene; starter scenes are also offered from the project
+  browser, and the visitor can download the scene they made.
+
+### Agent panel in the Studio
+
+- The Workflow page's Agent chat column is available in the Studio, toggled
+  from View ▾ → Panels → Agent panel or Cmd/Ctrl+B. It boots collapsed so the
+  mode budgets above are unchanged.
+
+### Video mocap and AI video takes
+
+- GVHMR is the only extraction backend; the bridge and the Studio return a
+  named error instead of silently falling back to browser MediaPipe.
+- GVHMR output goes through adaptive position/rotation stabilisation, explicit
+  contact correction, support-surface height (a chair lifts the motion), a
+  mocap quality gate, and scene calibration that survives restore. Palette
+  segmentation diagnostics are exposed for AI-rendered mannequin clips.
+- H3 video takes are checked against the requested scene and camera: the
+  Workflow shows a lock receipt on success and rejects a take whose background
+  or camera drifted, keeping no stale preview.
+
+### Site
+
+- Four search-facing pages (greybox to video, previs software, Seedance camera
+  control, privacy), `robots.txt` with an explicit AI-crawler policy,
+  `llms.txt`, a generated sitemap with real last-modified dates, and IndexNow
+  pings on deploy.
+
 ## 1.7.1
 
 - Open the complete Studio at the development server root; the unfinished

package/README.md

@@ -18,7 +18,9 @@
 </p>
 
 <p align="center">
-  <a href="https://cozyclay.org/">Demo reel</a> ·
+  <a href="https://cozyclay.org/#try">Try it in the browser</a> ·
+  <a href="https://cozyclay.org/greybox-to-video/">Greybox to AI video</a> ·
+  <a href="https://cozyclay.org/previs-software/">Previs software compared</a> ·
   <a href="#quick-start">Quick start</a> ·
   <a href="#what-you-can-do">Features</a> ·
   <a href="#ai-control-mcp">AI control</a> ·
@@ -34,7 +36,13 @@ CozyClay is a browser-based 3D staging studio built with Three.js and React Thre
 npx cozyclay
 ```
 
-That is the whole install. **[cozyclay.org](https://cozyclay.org/)** has the demo reel and a walkthrough of what the studio does; to use it, run it on your own machine. It ships seeded with a pre-generated motion clip, so you can scrub the timeline, drive the cameras and draw a dolly rail straight away — generating *new* motion is optional and uses the Kimodo bridge when configured.
+That is the whole install. Not sure yet? **[Try it in the browser first](https://cozyclay.org/#try)** — a seven-step camera tutorial on a live scene — then keep going on your machine with the same set:
+
+```bash
+npx cozyclay --scene city-block
+```
+
+The studio ships seeded with a pre-generated motion clip, so you can scrub the timeline, drive the cameras and draw a dolly rail straight away — generating *new* motion is optional and uses the Kimodo bridge when configured.
 
 ## Demo
 
@@ -65,7 +73,7 @@ npx cozyclay
 bunx cozyclay
 ```
 
-That downloads the built studio and opens it at `http://127.0.0.1:5180/app/`. Nothing to compile, no dependency tree to install. Useful flags: `--port 5200`, `--no-open`, `--no-motion`.
+That downloads the built studio and opens it at `http://127.0.0.1:5180/app/`. Nothing to compile, no dependency tree to install. Useful flags: `--port 5200`, `--no-open`, `--no-motion`, `--scene city-block` (start on the bundled starter scene instead of an empty room; the first-run dialog offers the same under **Start from a scene**, and a `.cclayproject` downloaded from the browser tutorial opens with **Open a project**).
 
 A global install gives you `cclay`, the same command with less typing. Once a day the launcher checks npm for a newer release and prints a one-line notice after the studio is up; it stays quiet when you're current or offline. `cclay update` installs the latest release, and `--no-update-check` skips the check entirely.
 

package/bin/agent/agent-routes.mjs

@@ -196,8 +196,14 @@ export function createAgentHandler({ auth = defaultAuth, codex, handlers, liveHu
 			if (!adapter || !adapter.configured()) { json(res, 409, { error: "video provider is not configured" }); return true; }
 			try {
 				const result = await adapter.generate({ ...value, durationSeconds: Number(value.durationSeconds) });
-				json(res, 200, { ...(result.mp4Base64 ? { dataUrl: `data:video/mp4;base64,${result.mp4Base64}` } : { url: result.url }), width: result.width, height: result.height, seconds: result.seconds });
-			} catch (error) { json(res, 502, { error: error?.message || "video provider failed" }); }
+				json(res, 200, { ...(result.mp4Base64 ? { dataUrl: `data:video/mp4;base64,${result.mp4Base64}` } : { url: result.url }), width: result.width, height: result.height, seconds: result.seconds, ...(result.preservation ? { preservation: result.preservation } : {}) });
+			} catch (error) {
+				// A generated H3 take that fails the plate check is unsafe to show as
+				// a locked shot. Keep the distinction visible to the client so it can
+				// ask for a retry instead of silently accepting a drifting set.
+				const status = error?.code === "h3-preservation-failed" ? 422 : 502;
+				json(res, status, { error: error?.message || "video provider failed", ...(error?.preservation ? { preservation: error.preservation } : {}) });
+			}
 			return true;
 		}
 		if (req.method !== "POST" || !["/agent/turn", "/agent/stop"].includes(path)) {

package/bin/agent/h3-preservation.mjs

@@ -0,0 +1,218 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+
+/**
+ * H3 is an image-to-video model: a prompt can request a locked camera, but it
+ * cannot prove that the returned pixels stayed on that camera.  This module
+ * is the output-side guard.  It compares several decoded frames with the
+ * uploaded plate in a border band where the animated performer normally is
+ * absent. A request is accepted only when the output dimensions/aspect and
+ * the measured plate drift are inside the contract.
+ */
+
+export const H3_OUTPUT_LIMITS = Object.freeze({
+	// JPEG/AVC quantisation and the model's first-frame reconstruction create a
+	// small amount of noise. A real camera move changes many edge pixels by much
+	// more than this value.
+	edgeP95Rgb: 14,
+	edgeMeanRgb: 6,
+	// The full-frame 80th percentile catches a camera translation in the
+	// middle of the set even when the border happens to be covered by a subject.
+	globalP80Rgb: 16,
+	// Once the output's first decoded frame has established the model's codec
+	// reconstruction, every later frame must keep the static scene band stable.
+	// This catches a camera move that happens to reconstruct to a similar value
+	// relative to the uploaded plate (and avoids treating subject motion as set
+	// motion).
+	temporalEdgeP95Rgb: 14,
+	temporalEdgeMeanRgb: 6,
+	temporalGlobalP80Rgb: 16,
+	cameraDriftPx: 2,
+	aspectError: 0.01,
+	borderFraction: 0.12,
+});
+
+/** Estimate a rigid camera translation against the plate in the static band. */
+export function estimateH3CameraShift(reference, frame, width, height, { borderFraction = H3_OUTPUT_LIMITS.borderFraction, maxShift = 4 } = {}) {
+	const borderX = Math.max(1, Math.floor(width * borderFraction));
+	const borderY = Math.max(1, Math.floor(height * borderFraction));
+	if (width <= borderX * 2 + 2 || height <= borderY * 2 + 2) return { x: 0, y: 0, errorRgb: 0, distancePx: 0 };
+	let best = { x: 0, y: 0, error: Infinity }; let baseline = Infinity;
+	for (let dy = -maxShift; dy <= maxShift; dy += 1) for (let dx = -maxShift; dx <= maxShift; dx += 1) {
+		let sum = 0; let count = 0;
+		for (let y = 0; y < height; y += 4) for (let x = 0; x < width; x += 4) {
+			// Estimate rigid movement only from the static perimeter. Sampling the
+			// interior lets a moving performer win the alignment search and can
+			// incorrectly call subject motion a camera correction.
+			if (!(x < borderX || x >= width - borderX || y < borderY || y >= height - borderY)) continue;
+			if (x + dx < 0 || x + dx >= width || y + dy < 0 || y + dy >= height) continue;
+			const a = (y * width + x) * 3; const b = ((y + dy) * width + x + dx) * 3;
+			sum += (Math.abs(reference[a] - frame[b]) + Math.abs(reference[a + 1] - frame[b + 1]) + Math.abs(reference[a + 2] - frame[b + 2])) / 3;
+			count += 1;
+		}
+		const error = sum / Math.max(1, count);
+		if (dx === 0 && dy === 0) baseline = error;
+		if (error < best.error) best = { x: dx, y: dy, error };
+	}
+	const improvementRgb = Math.max(0, baseline - best.error);
+	// A flat/softly lit border has many equally good translations. Only treat a
+	// shift as camera evidence when the alignment materially improves error.
+	const distancePx = improvementRgb >= 8 ? Math.hypot(best.x, best.y) : 0;
+	return { x: best.x, y: best.y, errorRgb: best.error, baselineErrorRgb: baseline, improvementRgb, distancePx };
+}
+
+/** Compare two generated frames in the static perimeter and full frame. */
+export function compareH3FrameStability(reference, frame, width, height, { borderFraction = H3_OUTPUT_LIMITS.borderFraction } = {}) {
+	if (!(reference instanceof Uint8Array) || !(frame instanceof Uint8Array) || reference.length < width * height * 3 || frame.length < width * height * 3) throw new TypeError("compareH3FrameStability needs two decoded RGB frames");
+	const borderX = Math.max(1, Math.floor(width * borderFraction));
+	const borderY = Math.max(1, Math.floor(height * borderFraction));
+	const edge = []; const global = [];
+	for (let y = 0; y < height; y += 2) for (let x = 0; x < width; x += 2) {
+		const i = (y * width + x) * 3;
+		const d = (Math.abs(reference[i] - frame[i]) + Math.abs(reference[i + 1] - frame[i + 1]) + Math.abs(reference[i + 2] - frame[i + 2])) / 3;
+		global.push(d);
+		if (x < borderX || x >= width - borderX || y < borderY || y >= height - borderY) edge.push(d);
+	}
+	edge.sort((a, b) => a - b); global.sort((a, b) => a - b);
+	const meanRgb = edge.reduce((sum, value) => sum + value, 0) / Math.max(1, edge.length);
+	const p95Rgb = edge[Math.min(edge.length - 1, Math.floor(edge.length * 0.95))] ?? 255;
+	const globalP80Rgb = global[Math.min(global.length - 1, Math.floor(global.length * 0.8))] ?? 255;
+	const camera = estimateH3CameraShift(reference, frame, width, height, { borderFraction });
+	return { meanRgb, p95Rgb, globalP80Rgb, cameraDriftPx: camera.distancePx, cameraShift: { x: camera.x, y: camera.y }, cameraErrorRgb: camera.errorRgb, cameraImprovementRgb: camera.improvementRgb, samples: edge.length, globalSamples: global.length };
+}
+
+function run(command, args, input = null) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+		const out = []; const err = [];
+		child.stdout.on("data", (chunk) => out.push(chunk));
+		child.stderr.on("data", (chunk) => err.push(chunk));
+		child.once("error", reject);
+		child.once("close", (code) => {
+			if (code === 0) resolve({ stdout: Buffer.concat(out), stderr: Buffer.concat(err).toString("utf8") });
+			else reject(new Error(`${command} exited ${code}: ${Buffer.concat(err).toString("utf8").trim()}`));
+		});
+		if (input) child.stdin.end(input); else child.stdin.end();
+	});
+}
+
+async function decode(path, width, height, seek = null, inputFormat = null) {
+	const args = ["-hide_banner", "-loglevel", "error"];
+	if (inputFormat) args.push("-f", inputFormat);
+	args.push("-i", path);
+	// Place -ss after the input so ffmpeg decodes through the preceding GOP and
+	// returns the requested frame. Fast input seeking would repeatedly return
+	// the first keyframe on long-GOP H3 clips, making temporal camera drift look
+	// stable when it was never inspected.
+	if (seek !== null) args.push("-ss", String(Math.max(0, seek)));
+	args.push("-vf", `scale=${width}:${height}:flags=bicubic`, "-frames:v", "1", "-f", "rawvideo", "-pix_fmt", "rgb24", "pipe:1");
+	const { stdout } = await run("ffmpeg", args);
+	const expected = width * height * 3;
+	if (stdout.length < expected) throw new Error(`decoded frame is ${stdout.length} bytes; expected ${expected}`);
+	return stdout.subarray(0, expected);
+}
+
+async function decodeNearest(path, width, height, seek, duration) {
+	// Short test clips and variable frame rate outputs may have no frame at an
+	// arbitrary timestamp near the end. Walk backwards to the nearest decoded
+	// frame instead of treating a valid clip as an inspection failure.
+	for (let offset = 0; offset <= Math.max(1, duration); offset += 1 / 12) {
+		try { return await decode(path, width, height, Math.max(0, seek - offset)); } catch { /* try the preceding frame */ }
+	}
+	throw new Error("H3 output has no decodable video frame.");
+}
+
+async function probe(path) {
+	const { stdout } = await run("ffprobe", ["-v", "error", "-select_streams", "v:0", "-show_entries", "stream=width,height,duration,nb_frames,r_frame_rate", "-of", "json", path]);
+	const stream = JSON.parse(stdout.toString("utf8"))?.streams?.[0];
+	if (!stream || !Number.isFinite(Number(stream.width)) || !Number.isFinite(Number(stream.height))) throw new Error("H3 output has no video stream metadata.");
+	const [rateNumerator, rateDenominator] = String(stream.r_frame_rate || "").split("/").map(Number);
+	const fps = rateNumerator > 0 && rateDenominator > 0 ? rateNumerator / rateDenominator : null;
+	return { width: Number(stream.width), height: Number(stream.height), seconds: Number.isFinite(Number(stream.duration)) ? Number(stream.duration) : null, frames: Number.isFinite(Number(stream.nb_frames)) ? Number(stream.nb_frames) : null, fps };
+}
+
+/** Compare a decoded RGB frame to the plate. Returns mean and p95 RGB error. */
+export function compareH3Plate(reference, frame, width, height, { borderFraction = H3_OUTPUT_LIMITS.borderFraction } = {}) {
+	if (!(reference instanceof Uint8Array) || !(frame instanceof Uint8Array) || reference.length < width * height * 3 || frame.length < width * height * 3) throw new TypeError("compareH3Plate needs two decoded RGB frames");
+	const borderX = Math.max(1, Math.floor(width * borderFraction));
+	const borderY = Math.max(1, Math.floor(height * borderFraction));
+	const errors = []; const globalErrors = [];
+	for (let y = 0; y < height; y += 2) for (let x = 0; x < width; x += 2) {
+		const i = (y * width + x) * 3;
+		const d = (Math.abs(reference[i] - frame[i]) + Math.abs(reference[i + 1] - frame[i + 1]) + Math.abs(reference[i + 2] - frame[i + 2])) / 3;
+		globalErrors.push(d);
+		if (x < borderX || x >= width - borderX || y < borderY || y >= height - borderY) errors.push(d);
+	}
+	errors.sort((a, b) => a - b);
+	globalErrors.sort((a, b) => a - b);
+	const mean = errors.reduce((sum, value) => sum + value, 0) / Math.max(1, errors.length);
+	const p95 = errors[Math.min(errors.length - 1, Math.floor(errors.length * 0.95))] ?? 255;
+	const globalP80 = globalErrors[Math.min(globalErrors.length - 1, Math.floor(globalErrors.length * 0.8))] ?? 255;
+	const camera = estimateH3CameraShift(reference, frame, width, height, { borderFraction });
+	return { meanRgb: mean, p95Rgb: p95, globalP80Rgb: globalP80, cameraDriftPx: camera.distancePx, cameraShift: { x: camera.x, y: camera.y }, cameraErrorRgb: camera.errorRgb, cameraImprovementRgb: camera.improvementRgb, samples: errors.length, globalSamples: globalErrors.length };
+}
+
+/**
+ * Decode and validate an H3 output against the uploaded first frame. This is
+ * deliberately fail-closed: if ffmpeg/ffprobe cannot inspect the result, the
+ * caller must not present it as a scene-locked take.
+ */
+export async function inspectH3Output({ imageDataUrl, videoBytes, expectedWidth, expectedHeight, limits = H3_OUTPUT_LIMITS, compositorVerified = false }) {
+	if (!imageDataUrl?.startsWith("data:image/")) throw new Error("H3 preservation requires the uploaded first image.");
+	if (!Buffer.isBuffer(videoBytes) || videoBytes.length === 0) throw new Error("H3 preservation requires non-empty video bytes.");
+	const dir = await mkdtemp(join(tmpdir(), "cozyclay-h3-"));
+	const mime = /^data:([^;,]+)/.exec(imageDataUrl)?.[1] || "image/png";
+	const extension = mime.includes("jpeg") || mime.includes("jpg") ? "jpg" : mime.includes("webp") ? "webp" : "png";
+	const imagePath = join(dir, `plate.${extension}`); const videoPath = join(dir, "output.mp4");
+	try {
+		const match = /^data:[^;,]+;base64,(.+)$/.exec(imageDataUrl);
+		if (!match) throw new Error("H3 preservation received an invalid image data URL.");
+		await writeFile(imagePath, Buffer.from(match[1], "base64"));
+		await writeFile(videoPath, videoBytes);
+		const meta = await probe(videoPath);
+		const plateMeta = await probe(imagePath);
+		const width = meta.width; const height = meta.height;
+		// H3 may quantise the canvas to its own 32-pixel grid. The uploaded plate
+		// is the source of truth for a locked camera; accepting a second requested
+		// ratio would allow a crop/reframe to pass the preservation gate.
+		const plateAspect = Number(plateMeta.width) / Number(plateMeta.height);
+		const requestedAspect = Number(expectedWidth) / Number(expectedHeight);
+		const outputAspect = width / height;
+		const targetAspect = Number.isFinite(plateAspect) && plateAspect > 0 ? plateAspect : requestedAspect;
+		const aspectError = Number.isFinite(targetAspect) && targetAspect > 0 ? Math.abs(outputAspect - targetAspect) / targetAspect : 0;
+		if (aspectError > limits.aspectError) throw new Error(`H3 preservation failed: output aspect drift ${(aspectError * 100).toFixed(2)}%.`);
+		const reference = await decode(imagePath, width, height);
+		const duration = Number.isFinite(meta.seconds) && meta.seconds > 0 ? meta.seconds : 1;
+		// Container duration points just past the final decoded frame. Clamp all
+		// seeks to that frame so short clips (and VFR outputs) cannot fail closed
+		// merely because a probe sample landed in the tail gap.
+		const frameStep = Number.isFinite(meta.fps) && meta.fps > 0 ? 1 / meta.fps : 1 / 24;
+		const lastFrameTime = Math.max(0, duration - frameStep);
+		const times = [...new Set([0, lastFrameTime * 0.25, lastFrameTime * 0.5, lastFrameTime * 0.75, lastFrameTime])];
+		const frames = []; const decoded = [];
+		for (const time of times) {
+			const frame = await decodeNearest(videoPath, width, height, time, duration);
+			decoded.push(frame); frames.push(compareH3Plate(reference, frame, width, height, limits));
+		}
+		const temporal = decoded.slice(1).map((frame) => compareH3FrameStability(decoded[0], frame, width, height, limits));
+		const worst = frames.reduce((acc, item) => ({ meanRgb: Math.max(acc.meanRgb, item.meanRgb), p95Rgb: Math.max(acc.p95Rgb, item.p95Rgb), globalP80Rgb: Math.max(acc.globalP80Rgb, item.globalP80Rgb), cameraDriftPx: Math.max(acc.cameraDriftPx, item.cameraDriftPx) }), { meanRgb: 0, p95Rgb: 0, globalP80Rgb: 0, cameraDriftPx: 0 });
+		const temporalWorst = temporal.reduce((acc, item) => ({ meanRgb: Math.max(acc.meanRgb, item.meanRgb), p95Rgb: Math.max(acc.p95Rgb, item.p95Rgb), globalP80Rgb: Math.max(acc.globalP80Rgb, item.globalP80Rgb), cameraDriftPx: Math.max(acc.cameraDriftPx, item.cameraDriftPx) }), { meanRgb: 0, p95Rgb: 0, globalP80Rgb: 0, cameraDriftPx: 0 });
+		// A verified SAM3/ImageCompositeMasked graph owns the foreground mask and
+		// copies the uploaded plate into every non-subject pixel. In that mode a
+		// full-frame percentile would mistake legitimate actor motion for a set
+		// change (especially in close-up shots). Keep the hard perimeter checks for
+		// camera/background drift; retain full-frame checks for unverified callers.
+		const plateGlobalPass = compositorVerified || worst.globalP80Rgb <= limits.globalP80Rgb;
+		const temporalGlobalPass = compositorVerified || temporalWorst.globalP80Rgb <= limits.temporalGlobalP80Rgb;
+		const pass = worst.p95Rgb <= limits.edgeP95Rgb && worst.meanRgb <= limits.edgeMeanRgb && plateGlobalPass && worst.cameraDriftPx <= limits.cameraDriftPx && temporalWorst.p95Rgb <= limits.temporalEdgeP95Rgb && temporalWorst.meanRgb <= limits.temporalEdgeMeanRgb && temporalGlobalPass && temporalWorst.cameraDriftPx <= limits.cameraDriftPx;
+		return { pass, width, height, seconds: meta.seconds, aspectError, frames, temporal, worst, temporalWorst, compositorVerified, limits };
+	} finally {
+		await rm(dir, { recursive: true, force: true });
+	}
+}
+
+export async function inspectH3OutputFromData({ imageDataUrl, videoBytes, expectedWidth, expectedHeight, limits, compositorVerified = false }) {
+	return inspectH3Output({ imageDataUrl, videoBytes, expectedWidth, expectedHeight, limits, compositorVerified });
+}