@glissade/cli 0.28.0-pre.1 → 0.29.0-pre.0

package/dist/build.js

@@ -0,0 +1,280 @@
+import { t as __exportAll } from "./rolldown-runtime.js";
+import { t as glissadeVersion } from "./version.js";
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+//#region src/buildPlan.ts
+/** The canonical order; a scene runs the subset that applies to it. */
+const PIPELINE = [
+	"narrate",
+	"sfx",
+	"measure-loudness",
+	"render"
+];
+/**
+* Plan one scene's steps. `steps` is the applicable subset in PIPELINE order (a
+* scene with no narration omits 'narrate', etc.). Returns a run/skip decision per
+* step; the first step that runs forces every later step to run (propagation).
+*/
+function planScene(scene, steps, probe) {
+	const plans = [];
+	let upstreamRan = false;
+	for (const step of steps) {
+		let action;
+		let reason;
+		if (upstreamRan) {
+			action = "run";
+			reason = "upstream re-ran";
+		} else if (!probe.outputExists(step)) {
+			action = "run";
+			reason = "output missing";
+		} else {
+			const rec = probe.recordedHash(step);
+			if (rec === void 0) {
+				action = "run";
+				reason = "never built";
+			} else if (rec !== probe.currentHash(step)) {
+				action = "run";
+				reason = "inputs changed";
+			} else {
+				action = "skip";
+				reason = "fresh";
+			}
+		}
+		if (action === "run") upstreamRan = true;
+		plans.push({
+			scene,
+			step,
+			action,
+			reason
+		});
+	}
+	return plans;
+}
+//#endregion
+//#region src/build.ts
+/**
+* `gs build` (0.29): the content-graph DAG runner. A `glissade.config.ts` lists the
+* project's scenes; `gs build` derives each scene's narrate → sfx → measure-loudness
+* → render pipeline, content-hashes every step's inputs (source + upstream outputs +
+* glissade version), and runs ONLY the stale subtree. A one-segment re-narration
+* re-narrates that asset, re-syncs ITS sfx, re-measures ITS loudness, re-renders it —
+* and touches nothing else. `--explain` prints the plan without running anything.
+*
+* Step execution is injectable (`deps.runStep`) so the orchestration — staleness
+* across builds, propagation, the manifest — is unit-testable without a TTS venv or
+* ffmpeg; the default `runStep` delegates to the shipped narrate/sfx/loudness/render.
+*/
+var build_exports = /* @__PURE__ */ __exportAll({
+	applicableSteps: () => applicableSteps,
+	buildCommand: () => buildCommand,
+	defineProject: () => defineProject,
+	hashInputs: () => hashInputs,
+	loadConfig: () => loadConfig,
+	outputVideo: () => outputVideo,
+	resolveScenes: () => resolveScenes,
+	stepInputs: () => stepInputs,
+	stepOutput: () => stepOutput
+});
+/** Identity helper for a typed `glissade.config.ts` default export. */
+function defineProject(config) {
+	return config;
+}
+async function loadConfig(configPath) {
+	const { createJiti } = await import("jiti");
+	const cfg = await createJiti(pathToFileURL(`${process.cwd()}/`).href).import(pathToFileURL(resolve(configPath)).href, { default: true });
+	if (!cfg || !Array.isArray(cfg.scenes)) throw new Error(`${configPath}: config must default-export { scenes: string[] } — use defineProject({ scenes: [...] })`);
+	return cfg;
+}
+/** Expand scene patterns (explicit paths + `dir/**\/*.ts` / `dir/*.ts` globs) to concrete files under `root`. */
+function resolveScenes(patterns, root) {
+	const found = /* @__PURE__ */ new Set();
+	for (const pat of patterns) {
+		if (!pat.includes("*")) {
+			found.add(resolve(root, pat));
+			continue;
+		}
+		const starAt = pat.indexOf("*");
+		const prefix = pat.slice(0, starAt);
+		const baseDir = resolve(root, prefix.includes("/") ? prefix.slice(0, prefix.lastIndexOf("/")) : ".");
+		const recursive = pat.includes("**");
+		const tail = pat.slice(pat.lastIndexOf("/") + 1);
+		const re = new RegExp(`^${tail.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*")}$`);
+		walk(baseDir, recursive, (file) => {
+			if (re.test(basename(file))) found.add(file);
+		});
+	}
+	return [...found].sort();
+}
+function walk(dir, recursive, onFile) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const e of entries) {
+		if (e === "node_modules" || e.startsWith(".")) continue;
+		const full = join(dir, e);
+		let s;
+		try {
+			s = statSync(full);
+		} catch {
+			continue;
+		}
+		if (s.isDirectory()) {
+			if (recursive) walk(full, recursive, onFile);
+		} else onFile(full);
+	}
+}
+const stripExt = (scene) => scene.replace(/\.[jt]sx?$/, "");
+const sib = (scene, ext) => `${stripExt(scene)}${ext}`;
+/** Where a scene's rendered video lands (config `out` dir, else alongside the source). */
+function outputVideo(scene, cfg, root) {
+	return cfg.out ? join(resolve(root, cfg.out), `${basename(stripExt(scene))}.mp4`) : `${stripExt(scene)}.mp4`;
+}
+/** The input files whose bytes decide a step's freshness (upstream outputs included). */
+function stepInputs(scene, step) {
+	switch (step) {
+		case "narrate": return [scene, sib(scene, ".narration.json")];
+		case "sfx": return [sib(scene, ".sfx.json"), sib(scene, ".narration.timing.json")];
+		case "measure-loudness": return [
+			sib(scene, ".narration.timing.json"),
+			sib(scene, ".music.timing.json"),
+			sib(scene, ".sfx.timing.json")
+		];
+		case "render": return [
+			scene,
+			sib(scene, ".narration.timing.json"),
+			sib(scene, ".music.timing.json"),
+			sib(scene, ".sfx.timing.json"),
+			sib(scene, ".loudness.json")
+		];
+	}
+}
+/** The committed output whose existence gates a step (missing → must run). */
+function stepOutput(scene, step, videoPath) {
+	switch (step) {
+		case "narrate": return sib(scene, ".narration.timing.json");
+		case "sfx": return sib(scene, ".sfx.timing.json");
+		case "measure-loudness": return sib(scene, ".loudness.json");
+		case "render": return videoPath;
+	}
+}
+/** Which pipeline steps apply to a scene: narrate/sfx only if their source sidecar exists;
+* measure-loudness only if any audio timing is present; render always. */
+function applicableSteps(scene) {
+	const steps = [];
+	if (existsSync(sib(scene, ".narration.json"))) steps.push("narrate");
+	if (existsSync(sib(scene, ".sfx.json"))) steps.push("sfx");
+	if ([
+		".narration.json",
+		".music.timing.json",
+		".sfx.json"
+	].some((e) => existsSync(sib(scene, e)))) steps.push("measure-loudness");
+	steps.push("render");
+	return PIPELINE.filter((s) => steps.includes(s));
+}
+function hashInputs(paths, salt) {
+	const h = createHash("sha256").update(salt).update("\0");
+	for (const p of paths) {
+		h.update(p).update("\0");
+		h.update(existsSync(p) ? readFileSync(p) : Buffer.from("\0ABSENT\0"));
+		h.update("\0");
+	}
+	return `sha256:${h.digest("hex")}`;
+}
+const manifestPath = (root) => join(root, ".gsbuild.json");
+function loadManifest(root) {
+	const p = manifestPath(root);
+	if (existsSync(p)) try {
+		const m = JSON.parse(readFileSync(p, "utf8"));
+		if (m.version === 1 && m.scenes) return m;
+	} catch {}
+	return {
+		version: 1,
+		scenes: {}
+	};
+}
+function saveManifest(root, m) {
+	writeFileSync(manifestPath(root), JSON.stringify(m, null, 2));
+}
+async function buildCommand(opts, deps = { runStep: defaultRunStep }) {
+	const cfg = await loadConfig(opts.config);
+	const root = dirname(resolve(opts.config));
+	let scenes = resolveScenes(cfg.scenes, root);
+	if (opts.only?.length) scenes = scenes.filter((s) => opts.only.some((o) => s.includes(o)));
+	const version = glissadeVersion();
+	const manifest = loadManifest(root);
+	const log = opts.onLog ?? (() => {});
+	const allPlans = [];
+	let ran = 0;
+	let skipped = 0;
+	for (const scene of scenes) {
+		const key = relative(root, scene);
+		const rec = manifest.scenes[key] ?? {};
+		const videoPath = outputVideo(scene, cfg, root);
+		const plans = planScene(key, applicableSteps(scene), {
+			currentHash: (step) => hashInputs(stepInputs(scene, step), version),
+			recordedHash: (step) => rec[step],
+			outputExists: (step) => existsSync(stepOutput(scene, step, videoPath))
+		});
+		for (const plan of plans) {
+			log(`${key}  ${plan.step}: ${plan.action} (${plan.reason})`);
+			if (plan.action === "skip") {
+				skipped++;
+				continue;
+			}
+			ran++;
+			if (!opts.explain) {
+				await deps.runStep(scene, plan.step, cfg, videoPath);
+				rec[plan.step] = hashInputs(stepInputs(scene, plan.step), version);
+			}
+		}
+		manifest.scenes[key] = rec;
+		allPlans.push(...plans);
+	}
+	if (!opts.explain) saveManifest(root, manifest);
+	return {
+		scenes: scenes.length,
+		ran,
+		skipped,
+		plans: allPlans
+	};
+}
+/** Default step executor — the shipped commands. */
+async function defaultRunStep(scene, step, cfg, videoPath) {
+	switch (step) {
+		case "narrate": {
+			const { narrateCommand } = await import("./narrate.js");
+			await narrateCommand({ input: scene });
+			return;
+		}
+		case "sfx": {
+			const { prepareSfx } = await import("./sfx.js");
+			prepareSfx(sib(scene, ".sfx.json"));
+			return;
+		}
+		case "measure-loudness": {
+			const { measureLoudnessCommand } = await import("./loudness.js").then((n) => n.c);
+			await measureLoudnessCommand({ modulePath: scene });
+			return;
+		}
+		case "render": {
+			const { render } = await import("./render.js").then((n) => n.p);
+			await render({
+				modulePath: scene,
+				out: videoPath,
+				...cfg.defaults?.fps !== void 0 ? { fps: cfg.defaults.fps } : {},
+				...cfg.defaults?.cache ? { cache: {
+					dir: cfg.defaults.cache,
+					mode: "read-write"
+				} } : {}
+			});
+			return;
+		}
+	}
+}
+//#endregion
+export { defineProject as n, build_exports as t };

package/dist/cacheVerify.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime.js";
 import { o as loadSceneModule } from "./render.js";
-import { i as capsId, n as FrameCache, o as frameCacheKey } from "./frameCache.js";
 import { t as glissadeVersion } from "./version.js";
+import { i as capsId, n as FrameCache, o as frameCacheKey } from "./frameCache.js";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";

package/dist/cli.js

@@ -77,6 +77,7 @@ const USAGE = `usage:
   gs fonts audit <scene-module>   list registered families, formats, and missing-glyph runs (§3.6)
   gs cache verify <scene-module> [--range a..b] [--sample <n>]   assert cache hits == cold renders (§3.5)
   gs mcp <scene-module>   start an MCP stdio server for this scene: describe / list_targets / apply_patch / undo / render_frame (the AI-native write layer)
+  gs build [filter...] [--config <glissade.config.ts>] [--explain]   content-graph DAG runner: narrate→sfx→loudness→render per scene, runs ONLY the stale subtree
 
 render options:
   --out <path>     output directory for a PNG sequence, or .mp4/.webm (needs ffmpeg). default: ./out
@@ -167,7 +168,7 @@ narration-lint options (lint the committed *.narration.timing.json + the real ca
 `;
 async function main() {
 	const [command, ...rest] = process.argv.slice(2);
-	if (command !== "render" && command !== "diff" && command !== "verify-determinism" && command !== "dev" && command !== "import" && command !== "narrate" && command !== "narration-lint" && command !== "sfx" && command !== "prepare" && command !== "measure-loudness" && command !== "fonts" && command !== "cache" && command !== "mcp") {
+	if (command !== "render" && command !== "diff" && command !== "verify-determinism" && command !== "dev" && command !== "import" && command !== "narrate" && command !== "narration-lint" && command !== "sfx" && command !== "prepare" && command !== "measure-loudness" && command !== "fonts" && command !== "cache" && command !== "mcp" && command !== "build") {
 		console.error(USAGE);
 		process.exit(command === void 0 || command === "help" || command === "--help" ? 0 : 1);
 	}
@@ -190,6 +191,24 @@ async function main() {
 		}
 		return;
 	}
+	if (command === "build") {
+		const { positional: bp, flags: bf } = parseArgs(rest);
+		const { buildCommand } = await import("./build.js").then((n) => n.t);
+		const config = bf.get("config") || "glissade.config.ts";
+		const explain = bf.has("explain");
+		try {
+			const r = await buildCommand({
+				config,
+				explain,
+				...bp.length ? { only: bp } : {},
+				onLog: (line) => process.stderr.write(`${line}\n`)
+			});
+			process.stderr.write(`gs build: ${r.ran} step${r.ran === 1 ? "" : "s"} ${explain ? "WOULD run" : "ran"}, ${r.skipped} fresh, across ${r.scenes} scene${r.scenes === 1 ? "" : "s"}${explain ? " (--explain: nothing executed)" : ""}\n`);
+		} catch (err) {
+			fail(err instanceof Error ? err.message : String(err));
+		}
+		return;
+	}
 	if (command === "cache") {
 		const { positional: cp, flags: cf } = parseArgs(rest);
 		const sub = cp[0];

package/dist/config.d.ts

@@ -0,0 +1,17 @@
+//#region src/build.d.ts
+
+interface ProjectConfig {
+  /** scene module paths or globs (`episodes/**\/*.ts`), relative to the config file. */
+  scenes: string[];
+  /** output dir for rendered videos (default: alongside each scene as `<base>.mp4`). */
+  out?: string;
+  /** per-scene render/cache defaults. */
+  defaults?: {
+    fps?: number;
+    cache?: string;
+  };
+}
+/** Identity helper for a typed `glissade.config.ts` default export. */
+declare function defineProject(config: ProjectConfig): ProjectConfig;
+//#endregion
+export { type ProjectConfig, defineProject };

package/dist/config.js

@@ -0,0 +1,2 @@
+import { n as defineProject } from "./build.js";
+export { defineProject };

package/dist/index.js

@@ -1,4 +1,5 @@
 import { a as ffmpegAvailable, d as render, f as renderLocales, i as collectAudioClips, l as parseLocalesList, m as resolveLoudnessGainDb, n as SceneModuleError, o as loadSceneModule, r as buildMixWav, s as localeOutPath, t as LocaleArgsError, u as planFinalAudio } from "./render.js";
+import { t as glissadeVersion } from "./version.js";
 import { a as computeGainDb, d as parseLoudnormJson, f as peakClampBinds, i as PUBLISH_PROFILES, l as measureFile, m as resolveProfile, n as LOUDNESS_SCHEMA_VERSION, o as computeMixHash, p as readLoudness, r as LoudnessError, s as loudnessPathFor, t as DEFAULT_PROFILE_ID, u as measureLoudnessCommand } from "./loudness.js";
 import { a as pickEncoder, i as parseEncoderList, n as availableEncoders, t as NoEncoderError } from "./encoders.js";
 import { a as splitFrameRange, n as renderSharded, r as sceneHasGpuNodes, t as ShardError } from "./shards.js";
@@ -10,6 +11,5 @@ import { t as importCommand } from "./import.js";
 import { i as snapshotAt, r as evaluateAt, t as diffCommand } from "./diff.js";
 import { a as fixDiff, c as lintNarration, n as lintTimingPathFor, o as formatTable, r as narrationLintCommand, s as hasErrors, t as buildCaptionProbe } from "./narrationLintCommand.js";
 import { a as clearFrameCache, c as parseCacheMaxSize, i as capsId, l as probeEntryHeader, n as FrameCache, o as frameCacheKey, r as FrameCacheError, t as DEFAULT_CACHE_MAX_SIZE } from "./frameCache.js";
-import { t as glissadeVersion } from "./version.js";
 import { t as cacheVerifyCommand } from "./cacheVerify.js";
 export { AudioMixError, DEFAULT_CACHE_MAX_SIZE, DEFAULT_PROFILE_ID, FfmpegVideoFrameSource, FrameCache, FrameCacheError, LOUDNESS_SCHEMA_VERSION, LocaleArgsError, LoudnessError, MachineExportError, NoEncoderError, PUBLISH_PROFILES, SceneModuleError, ShardError, VideoProbeError, applyMixGainDb, atempoChain, availableEncoders, buildCaptionProbe, buildMixWav, cacheVerifyCommand, capsId, clearFrameCache, collectAudioClips, computeGainDb, computeMixHash, dev, diffCommand, evaluateAt, ffmpegAvailable, fixDiff, formatTable, frameCacheKey, gainExpression, glissadeVersion, hasErrors, importCommand, lintNarration, lintTimingPathFor, loadSceneModule, localeOutPath, loudnessPathFor, measureFile, measureLoudnessCommand, narrationLintCommand, parseCacheMaxSize, parseEncoderList, parseLocalesList, parseLoudnormJson, peakClampBinds, pickEncoder, planAudioMix, planFinalAudio, probeEntryHeader, probeVideo, readLoudness, render, renderLocales, renderSharded, resolveAssetPath, resolveLoudnessGainDb, resolveProfile, resolveRenderDoc, sceneHasGpuNodes, snapshotAt, splitFrameRange };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glissade/cli",
-  "version": "0.28.0-pre.1",
+  "version": "0.29.0-pre.0",
   "description": "glissade CLI: headless rendering via backend-skia (+ FFmpeg mux).",
   "license": "Apache-2.0",
   "engines": {
@@ -14,6 +14,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
     }
   },
   "files": [
@@ -24,15 +28,15 @@
     "@napi-rs/canvas": "^0.1.65",
     "esbuild": "0.28.0",
     "jiti": "^2.4.2",
-    "@glissade/backend-skia": "0.28.0-pre.1",
-    "@glissade/core": "0.28.0-pre.1",
-    "@glissade/interact": "0.28.0-pre.1",
-    "@glissade/lottie": "0.28.0-pre.1",
-    "@glissade/narrate": "0.28.0-pre.1",
-    "@glissade/player": "0.28.0-pre.1",
-    "@glissade/scene": "0.28.0-pre.1",
-    "@glissade/sfx": "0.28.0-pre.1",
-    "@glissade/svg": "0.28.0-pre.1"
+    "@glissade/backend-skia": "0.29.0-pre.0",
+    "@glissade/interact": "0.29.0-pre.0",
+    "@glissade/core": "0.29.0-pre.0",
+    "@glissade/lottie": "0.29.0-pre.0",
+    "@glissade/narrate": "0.29.0-pre.0",
+    "@glissade/player": "0.29.0-pre.0",
+    "@glissade/scene": "0.29.0-pre.0",
+    "@glissade/sfx": "0.29.0-pre.0",
+    "@glissade/svg": "0.29.0-pre.0"
   },
   "repository": {
     "type": "git",