@glissade/cli 0.26.0 → 0.27.0

package/dist/cacheVerify.js

@@ -6,8 +6,8 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { evaluate, withDeterminismGuards } from "@glissade/scene";
-import { SkiaBackend } from "@glissade/backend-skia";
 import { createHash } from "node:crypto";
+import { SkiaBackend } from "@glissade/backend-skia";
 //#region src/cacheVerify.ts
 /**
 * gs cache verify — THE verify gate for the persistent `.gscache` (DESIGN.md §3.5,

package/dist/render.js

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime.js";
 import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -8,7 +8,59 @@ import { readFile } from "node:fs/promises";
 import { createJiti } from "jiti";
 import { buildFontRegistry } from "@glissade/core";
 import { collectLocalizedTextUsages, evaluate, validateSceneFonts, withDeterminismGuards } from "@glissade/scene";
+import { createHash } from "node:crypto";
 import { SkiaBackend } from "@glissade/backend-skia";
+//#region src/renderManifest.ts
+/**
+* Render manifest (0.27): the byte-identical-video proof that powers the
+* audio-only REMUX fast path. When `gs render --cache` finishes a video, it
+* writes `<out>.gsrender.json` recording the ORDERED digest of every frame's
+* content-cache key plus the video-encode parameters. On a re-render, a cheap
+* key-only pre-pass (evaluate + frameCacheKey, NO raster) recomputes that digest;
+* if it matches — the visual inputs are byte-identical, so the encoded video
+* would be too — and the prior output still exists with the same encode params,
+* we skip re-encoding entirely and `ffmpeg -c:v copy` the existing video stream
+* with the new audio. An audio-only re-master becomes a remux in seconds.
+*
+* The digest IS a determinism proof: identical DisplayList per frame (the same
+* thing the frame cache and the golden corpus hash) ⇒ identical raster on the
+* pinned Skia toolchain ⇒ identical encode. Any pixel change flips the digest and
+* falls back to a full encode — the cache-hit ≡ cold-render invariant, one level up.
+*/
+/** sha256 of the ordered frame keys (NUL-separated so keys can't run together). */
+function frameKeyDigest(keys) {
+	const h = createHash("sha256");
+	for (const k of keys) {
+		h.update(k);
+		h.update("\0");
+	}
+	return h.digest("hex");
+}
+const manifestPathFor = (videoPath) => `${videoPath}.gsrender.json`;
+/** Read the manifest beside a video output, or undefined if absent/unreadable/old-format. */
+function readRenderManifest(videoPath) {
+	const p = manifestPathFor(videoPath);
+	if (!existsSync(p)) return void 0;
+	try {
+		const m = JSON.parse(readFileSync(p, "utf8"));
+		return m && m.v === 1 && typeof m.frameKeyDigest === "string" ? m : void 0;
+	} catch {
+		return;
+	}
+}
+function writeRenderManifest(videoPath, m) {
+	writeFileSync(manifestPathFor(videoPath), JSON.stringify(m));
+}
+/**
+* Decide whether a re-render can take the remux fast path: the prior manifest's
+* frame-key digest matches this render's, the prior output still exists, and the
+* encode parameters are unchanged. Pure — the caller supplies the freshly computed
+* digest + params and whether the output file exists.
+*/
+function canRemux(prev, now, outputExists) {
+	return prev !== void 0 && outputExists && prev.frameKeyDigest === now.frameKeyDigest && prev.container === now.container && prev.videoCodec === now.videoCodec && prev.fps === now.fps && prev.firstFrame === now.firstFrame && prev.frames === now.frames;
+}
+//#endregion
 //#region src/assetValidation.ts
 /**
 * Walk a scene's node tree and collect every Image/Video asset reference. Pure
@@ -374,12 +426,48 @@ async function render(opts) {
 			assetsDigest: combineAssetDigests(assetDigests)
 		};
 	}
-	for (let f = firstFrame; f <= lastFrame; f++) {
+	let videoOut;
+	let remuxDigest;
+	if (isVideo) {
+		const outAbs = resolve(opts.out);
+		const container = /\.webm$/i.test(outAbs) ? "webm" : "mp4";
+		const { pickEncoder } = await import("./encoders.js").then((n) => n.r);
+		const enc = pickEncoder("video", container);
+		videoOut = {
+			outAbs,
+			container,
+			encName: enc.name,
+			...enc.note ? { encNote: enc.note } : {}
+		};
+		if (frameCache && keyCtx && opts.cache.mode !== "off") {
+			const prev = readRenderManifest(outAbs);
+			if (prev && existsSync(outAbs)) {
+				const { frameCacheKey } = await import("./frameCache.js").then((n) => n.s);
+				const keys = [];
+				for (let f = firstFrame; f <= lastFrame; f++) {
+					const dl = withDeterminismGuards("throw", () => evaluate(scene, doc, f / fps));
+					keys.push(frameCacheKey(dl, keyCtx));
+				}
+				const digest = frameKeyDigest(keys);
+				if (canRemux(prev, {
+					frameKeyDigest: digest,
+					container,
+					videoCodec: enc.name,
+					fps,
+					firstFrame,
+					frames: total
+				}, true)) remuxDigest = digest;
+			}
+		}
+	}
+	const frameKeys = [];
+	if (!remuxDigest) for (let f = firstFrame; f <= lastFrame; f++) {
 		const dl = withDeterminismGuards("throw", () => evaluate(scene, doc, f / fps));
 		let pngBytes;
 		if (frameCache && keyCtx) {
 			const { frameCacheKey } = await import("./frameCache.js").then((n) => n.s);
 			const key = frameCacheKey(dl, keyCtx);
+			frameKeys.push(key);
 			const cached = frameCache.get(key);
 			if (cached) {
 				backend.putPixels(cached);
@@ -397,10 +485,11 @@ async function render(opts) {
 		opts.onProgress?.(f - firstFrame + 1, total);
 	}
 	backend.dispose();
-	if (frameCache) {
+	if (frameCache && !remuxDigest) {
 		const s = frameCache.getStats();
 		process.stderr.write(`cache (${opts.cache.mode}): ${s.hits} hit${s.hits === 1 ? "" : "s"}, ${s.misses} miss${s.misses === 1 ? "" : "es"}` + (s.stored ? `, ${s.stored} stored` : "") + (s.evicted ? `, ${s.evicted} evicted (LRU cap ${frameCache.maxSize} B)` : "") + ` → ${opts.cache.dir}\n`);
 	}
+	const newDigest = frameCache && !remuxDigest && frameKeys.length === total ? frameKeyDigest(frameKeys) : void 0;
 	for (const source of videoSources) source.close();
 	const emitSidecars = (target) => {
 		if (captionsMode === "off") return;
@@ -429,18 +518,69 @@ async function render(opts) {
 			out: framesDir
 		};
 	}
-	const outAbs = resolve(opts.out);
+	const outAbs = videoOut.outAbs;
+	const container = videoOut.container;
 	mkdirSync(dirname(outAbs), { recursive: true });
 	emitSidecars(outAbs);
 	emitCues(outAbs);
-	const isWebm = /\.webm$/i.test(outAbs);
-	const container = isWebm ? "webm" : "mp4";
-	const { pickEncoder } = await import("./encoders.js").then((n) => n.r);
-	const videoEnc = pickEncoder("video", container);
-	if (videoEnc.note) process.stderr.write(`note: ${videoEnc.note}\n`);
+	if (videoOut.encNote) process.stderr.write(`note: ${videoOut.encNote}\n`);
+	const { audioInputs, audioArgs } = await planFinalAudio(opts, [...compiled.audio], duration, container);
+	if (remuxDigest) {
+		const remuxArgs = [
+			"-y",
+			"-i",
+			outAbs,
+			...audioInputs,
+			...audioArgs,
+			"-map",
+			"0:v:0",
+			"-c:v",
+			"copy",
+			...container === "webm" ? [] : ["-movflags", "+faststart"],
+			"-t",
+			String(duration)
+		];
+		const encodeDir = mkdtempSync(join(dirname(outAbs), ".gs-remux-"));
+		const tmpOut = join(encodeDir, `out.${container}`);
+		const result = spawnSync("ffmpeg", [...remuxArgs, tmpOut], { stdio: [
+			"ignore",
+			"ignore",
+			"pipe"
+		] });
+		rmSync(framesDir, {
+			recursive: true,
+			force: true
+		});
+		if (result.status !== 0) {
+			rmSync(encodeDir, {
+				recursive: true,
+				force: true
+			});
+			throw new Error(`ffmpeg remux failed (exit ${result.status}):\n${result.stderr?.toString().slice(-2e3)}`);
+		}
+		renameSync(tmpOut, outAbs);
+		rmSync(encodeDir, {
+			recursive: true,
+			force: true
+		});
+		writeRenderManifest(outAbs, {
+			v: 1,
+			frameKeyDigest: remuxDigest,
+			container,
+			videoCodec: videoOut.encName,
+			fps,
+			firstFrame,
+			frames: total
+		});
+		process.stderr.write(`cache: ${total}/${total} frames unchanged (audio-only) — video copy + remux → ${outAbs}\n`);
+		return {
+			frames: total,
+			out: outAbs
+		};
+	}
 	const codec = [
 		"-c:v",
-		videoEnc.name,
+		videoOut.encName,
 		...{
 			"libx264": ["-crf", "18"],
 			"libvpx-vp9": [
@@ -452,15 +592,14 @@ async function render(opts) {
 			"libvpx": ["-b:v", "2M"],
 			"libopenh264": ["-b:v", "4M"],
 			"mpeg4": ["-q:v", "3"]
-		}[videoEnc.name] ?? [],
-		...isWebm ? [] : [
+		}[videoOut.encName] ?? [],
+		...container === "webm" ? [] : [
 			"-pix_fmt",
 			"yuv420p",
 			"-movflags",
 			"+faststart"
 		]
 	];
-	const { audioInputs, audioArgs } = await planFinalAudio(opts, [...compiled.audio], duration, container);
 	const result = spawnSync("ffmpeg", [
 		"-y",
 		"-framerate",
@@ -485,6 +624,15 @@ async function render(opts) {
 		force: true
 	});
 	if (result.status !== 0) throw new Error(`ffmpeg failed (exit ${result.status}):\n${result.stderr?.toString().slice(-2e3)}`);
+	if (newDigest) writeRenderManifest(outAbs, {
+		v: 1,
+		frameKeyDigest: newDigest,
+		container,
+		videoCodec: videoOut.encName,
+		fps,
+		firstFrame,
+		frames: total
+	});
 	return {
 		frames: total,
 		out: outAbs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/cli",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "glissade CLI: headless rendering via backend-skia (+ FFmpeg mux).",
   "license": "Apache-2.0",
   "engines": {
@@ -23,15 +23,15 @@
     "@napi-rs/canvas": "^0.1.65",
     "esbuild": "0.28.0",
     "jiti": "^2.4.2",
-    "@glissade/backend-skia": "0.26.0",
-    "@glissade/core": "0.26.0",
-    "@glissade/interact": "0.26.0",
-    "@glissade/lottie": "0.26.0",
-    "@glissade/svg": "0.26.0",
-    "@glissade/narrate": "0.26.0",
-    "@glissade/player": "0.26.0",
-    "@glissade/scene": "0.26.0",
-    "@glissade/sfx": "0.26.0"
+    "@glissade/backend-skia": "0.27.0",
+    "@glissade/core": "0.27.0",
+    "@glissade/interact": "0.27.0",
+    "@glissade/lottie": "0.27.0",
+    "@glissade/svg": "0.27.0",
+    "@glissade/narrate": "0.27.0",
+    "@glissade/player": "0.27.0",
+    "@glissade/sfx": "0.27.0",
+    "@glissade/scene": "0.27.0"
   },
   "repository": {
     "type": "git",