@glissade/cli 0.27.0 → 0.27.1

package/dist/layerCache.js

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { deflateSync, inflateSync } from "node:zlib";
+//#region src/layerCache.ts
+/**
+* §3.5 disk layer-cache (0.27.1): the fs-backed `LayerStore` the CLI injects into
+* the Skia backend. It persists a `cache:true` group's DEVICE-space raster across
+* renders, so an expensive static subtree (a blurred mesh backdrop) rasterizes
+* ONCE and re-blits on later runs — surviving a re-narration that defeats the
+* whole-frame cache (the backdrop's sub-DisplayList is unchanged; only captions /
+* timing move). Sibling of `frameCache.ts`; same on-disk discipline (deflate,
+* atomic write, content-addressed filenames).
+*
+* The compositor supplies the raw key `<sub-DisplayList fnv1a>@<deviceTransformKey>`;
+* this store SALTS it with the toolchain version ⊕ backend caps ⊕ frame size, so a
+* version / capability / resolution change can never serve a stale raster. A
+* restored RGBA composites byte-identically to a fresh raster (the compositor
+* round-trips it through putImageData) — the same contract the frame cache holds.
+*/
+const MAGIC = 1196641329;
+const HEADER_BYTES = 20;
+const BOUNDS_BYTES = 32;
+const FLAG_HAS_BOUNDS = 1;
+const FLAG_UNBOUNDED = 2;
+function encodeEntry(e) {
+	const header = Buffer.alloc(HEADER_BYTES);
+	header.writeUInt32BE(MAGIC, 0);
+	header.writeUInt32BE(1, 4);
+	header.writeUInt32BE(e.w, 8);
+	header.writeUInt32BE(e.h, 12);
+	header.writeUInt32BE((e.bounds ? FLAG_HAS_BOUNDS : 0) | (e.unbounded ? FLAG_UNBOUNDED : 0), 16);
+	const parts = [header];
+	if (e.bounds) {
+		const b = Buffer.alloc(BOUNDS_BYTES);
+		b.writeDoubleBE(e.bounds.minX, 0);
+		b.writeDoubleBE(e.bounds.minY, 8);
+		b.writeDoubleBE(e.bounds.maxX, 16);
+		b.writeDoubleBE(e.bounds.maxY, 24);
+		parts.push(b);
+	}
+	parts.push(deflateSync(Buffer.from(e.rgba.buffer, e.rgba.byteOffset, e.rgba.byteLength)));
+	return Buffer.concat(parts);
+}
+function decodeEntry(buf) {
+	if (buf.length < HEADER_BYTES || buf.readUInt32BE(0) !== MAGIC) throw new Error("corrupt .gsl layer entry (bad magic)");
+	const w = buf.readUInt32BE(8);
+	const h = buf.readUInt32BE(12);
+	const flags = buf.readUInt32BE(16);
+	let off = HEADER_BYTES;
+	let bounds = null;
+	if (flags & FLAG_HAS_BOUNDS) {
+		bounds = {
+			minX: buf.readDoubleBE(off),
+			minY: buf.readDoubleBE(off + 8),
+			maxX: buf.readDoubleBE(off + 16),
+			maxY: buf.readDoubleBE(off + 24)
+		};
+		off += BOUNDS_BYTES;
+	}
+	const raw = inflateSync(buf.subarray(off));
+	return {
+		rgba: new Uint8ClampedArray(raw.buffer, raw.byteOffset, raw.byteLength),
+		w,
+		h,
+		bounds,
+		unbounded: (flags & FLAG_UNBOUNDED) !== 0
+	};
+}
+var LayerCache = class {
+	dir;
+	mode;
+	salt;
+	stats = {
+		hits: 0,
+		misses: 0,
+		stored: 0
+	};
+	constructor(opts) {
+		this.dir = opts.dir;
+		this.mode = opts.mode;
+		this.salt = opts.salt;
+		if (this.mode !== "off") mkdirSync(this.dir, { recursive: true });
+	}
+	fileFor(key) {
+		const h = createHash("sha256").update(this.salt).update("\0").update(key).digest("hex");
+		return join(this.dir, `${h}.gsl`);
+	}
+	get(key) {
+		if (this.mode === "off") return void 0;
+		const f = this.fileFor(key);
+		if (!existsSync(f)) {
+			this.stats.misses++;
+			return;
+		}
+		try {
+			const e = decodeEntry(readFileSync(f));
+			this.stats.hits++;
+			return e;
+		} catch {
+			this.stats.misses++;
+			return;
+		}
+	}
+	put(key, entry) {
+		if (this.mode !== "read-write") return;
+		const f = this.fileFor(key);
+		if (existsSync(f)) return;
+		const tmp = `${f}.tmp${globalThis.process?.pid ?? 0}`;
+		writeFileSync(tmp, encodeEntry(entry));
+		renameSync(tmp, f);
+		this.stats.stored++;
+	}
+	getStats() {
+		return { ...this.stats };
+	}
+};
+//#endregion
+export { LayerCache };

package/dist/render.js

@@ -420,11 +420,19 @@ async function render(opts) {
 			mode: opts.cache.mode,
 			...opts.cache.maxSize !== void 0 ? { maxSize: opts.cache.maxSize } : {}
 		});
+		const version = glissadeVersion();
+		const caps = capsId(backend.caps);
 		keyCtx = {
-			version: glissadeVersion(),
-			capsId: capsId(backend.caps),
+			version,
+			capsId: caps,
 			assetsDigest: combineAssetDigests(assetDigests)
 		};
+		const { LayerCache } = await import("./layerCache.js");
+		backend.setLayerStore(new LayerCache({
+			dir: join(opts.cache.dir, "layers"),
+			mode: opts.cache.mode,
+			salt: `${version}|${caps}|${scene.size.w}x${scene.size.h}`
+		}));
 	}
 	let videoOut;
 	let remuxDigest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/cli",
-  "version": "0.27.0",
+  "version": "0.27.1",
   "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.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"
+    "@glissade/backend-skia": "0.27.1",
+    "@glissade/core": "0.27.1",
+    "@glissade/interact": "0.27.1",
+    "@glissade/lottie": "0.27.1",
+    "@glissade/svg": "0.27.1",
+    "@glissade/narrate": "0.27.1",
+    "@glissade/player": "0.27.1",
+    "@glissade/scene": "0.27.1",
+    "@glissade/sfx": "0.27.1"
   },
   "repository": {
     "type": "git",