@glissade/cli 0.11.0 → 0.12.0-pre.0

package/dist/loudness.js

@@ -0,0 +1,254 @@
+import { t as __exportAll } from "./rolldown-runtime.js";
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+//#region src/loudness.ts
+/**
+* gs measure-loudness (0.12, DESIGN §5.3): loudness-normalized PUBLISH profiles
+* via a deterministic, peak-clamped scalar GAIN — NOT a render-pipeline change.
+*
+* The key insight: YouTube/Shorts re-normalize loudness platform-side, so the
+* publish target is *≤ target-LUFS AND ≤ -1 dBTP*, not exact. So we never need a
+* two-pass limiter on the render hot path. Instead:
+*
+*   1. `gs measure-loudness` runs ffmpeg's `loudnorm` measurement pass (a
+*      print-only ebur128 + true-peak gate) at MEASURE-time over the final
+*      mixed PCM, reading `inputI` (integrated LUFS), `inputTp` (true peak
+*      dBTP), `inputLra`. This is the ONE non-deterministic stage and it is
+*      QUARANTINED to commit-time — §5.3 already concedes mix-to-PCM bytes are
+*      per-path only.
+*   2. It commits a `<scene>.loudness.json` carrying the measured numbers, the
+*      chosen profile, the resulting `gain` (dB), and a `mixHash` binding the
+*      measurement to the mix CONTENT (the narration/music/sfx manifests).
+*   3. `gs render` reads that file and applies `gain` as a PURE scalar
+*      `volume=<gain>dB` multiply on the FINAL mix node — a single scalar in the
+*      existing filter graph, NOT a new ffmpeg pass. That stage is bit-exact and
+*      golden-hashable (a multiply at the same float→Int16 boundary the rest of
+*      the audio path shares).
+*
+* The gain is peak-clamped: `gain = min(gainForTargetLUFS, (-1 dBTP) - inputTp)`.
+* The clamp uses the MEASURED true-peak, so the published output is guaranteed
+* ≤ -1 dBTP with no render-time oversampling. (For 0.12 the brickwall true-peak
+* LIMITER is DEFERRED — un-normalized profiles still get the gain plus an
+* advisory warning when a peaky source would have needed brickwalling.)
+*/
+var loudness_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_PROFILE_ID: () => DEFAULT_PROFILE_ID,
+	LOUDNESS_SCHEMA_VERSION: () => 1,
+	LoudnessError: () => LoudnessError,
+	PUBLISH_PROFILES: () => PUBLISH_PROFILES,
+	computeGainDb: () => computeGainDb,
+	computeMixHash: () => computeMixHash,
+	loudnessPathFor: () => loudnessPathFor,
+	measureFile: () => measureFile,
+	measureLoudnessCommand: () => measureLoudnessCommand,
+	parseLoudnormJson: () => parseLoudnormJson,
+	peakClampBinds: () => peakClampBinds,
+	readLoudness: () => readLoudness,
+	resolveProfile: () => resolveProfile
+});
+var LoudnessError = class extends Error {
+	constructor(detail) {
+		super(`loudness: ${detail}`);
+		this.name = "LoudnessError";
+	}
+};
+const PUBLISH_PROFILES = Object.freeze({
+	youtube: {
+		id: "youtube",
+		targetLufs: -14,
+		truePeakDb: -1,
+		platformNormalized: true
+	},
+	shorts: {
+		id: "shorts",
+		targetLufs: -14,
+		truePeakDb: -1,
+		platformNormalized: true
+	},
+	podcast: {
+		id: "podcast",
+		targetLufs: -16,
+		truePeakDb: -1,
+		platformNormalized: false
+	},
+	broadcast: {
+		id: "broadcast",
+		targetLufs: -23,
+		truePeakDb: -1,
+		platformNormalized: false
+	},
+	ebu: {
+		id: "ebu",
+		targetLufs: -23,
+		truePeakDb: -1,
+		platformNormalized: false
+	}
+});
+const DEFAULT_PROFILE_ID = "youtube";
+/** Resolve a profile id (case-insensitive) or throw with the valid set. */
+function resolveProfile(id) {
+	const p = PUBLISH_PROFILES[id.trim().toLowerCase()];
+	if (!p) throw new LoudnessError(`unknown publish profile '${id}' (have: ${Object.keys(PUBLISH_PROFILES).join(", ")})`);
+	return p;
+}
+const LOUDNESS_SCHEMA_VERSION = 1;
+/**
+* The peak-clamped publish gain (dB). `gainForTargetLUFS = target - inputI`
+* raises/lowers to the integrated target; the clamp `truePeak - inputTp` caps it
+* so the result never exceeds the true-peak ceiling. We take the min: a source
+* that can't reach the loudness target without clipping is left below it (the
+* platform re-normalizes the rest for `youtube`/`shorts`).
+*/
+function computeGainDb(profile, inputI, inputTp) {
+	const gainForTargetLufs = profile.targetLufs - inputI;
+	const peakClamp = profile.truePeakDb - inputTp;
+	return Math.min(gainForTargetLufs, peakClamp);
+}
+/**
+* True when the peak clamp BOUND the gain — i.e. the source is too peaky to reach
+* the loudness target without exceeding the true-peak ceiling. For an
+* un-normalized profile this is where a brickwall limiter would normally recover
+* the headroom (deferred in 0.12 → advisory warning).
+*/
+function peakClampBinds(profile, inputI, inputTp) {
+	return profile.truePeakDb - inputTp < profile.targetLufs - inputI;
+}
+/**
+* Hash the CONTENT of the mix's input manifests so a re-narrate / re-sfx / music
+* change invalidates a committed measurement. We hash the files' BYTES (not
+* mtime): the narration/music/sfx timing manifests and any wired timeline audio
+* sidecars. Missing siblings are recorded by name with a sentinel so adding one
+* later also changes the hash. The scene module path itself is excluded — the
+* mix is a function of the manifests, and timeline `audio` clips flow through the
+* narration/music/sfx manifests or the explicitly-passed extra inputs.
+*/
+function computeMixHash(modulePath, extraInputs = []) {
+	const base = modulePath.replace(/\.[jt]sx?$/, "");
+	const siblings = [
+		`${base}.narration.timing.json`,
+		`${base}.music.timing.json`,
+		`${base}.sfx.timing.json`
+	];
+	const h = createHash("sha256");
+	for (const path of [...siblings, ...extraInputs]) {
+		h.update(path);
+		h.update("\0");
+		if (existsSync(path)) h.update(readFileSync(path));
+		else h.update("\0ABSENT\0");
+		h.update("\0");
+	}
+	return `sha256:${h.digest("hex")}`;
+}
+/** `<module>.loudness.json` for a scene module. */
+function loudnessPathFor(modulePath) {
+	return modulePath.replace(/\.[jt]sx?$/, "") + ".loudness.json";
+}
+/** Read + validate a committed measurement, or null when none is committed. */
+function readLoudness(modulePath) {
+	const path = loudnessPathFor(modulePath);
+	if (!existsSync(path)) return null;
+	const raw = JSON.parse(readFileSync(path, "utf8"));
+	if (raw.loudnessVersion !== 1) throw new LoudnessError(`${path}: unsupported loudnessVersion ${String(raw.loudnessVersion)} (expected 1); re-run gs measure-loudness`);
+	if (typeof raw.gain !== "number" || typeof raw.inputI !== "number" || typeof raw.inputTp !== "number" || typeof raw.inputLra !== "number" || typeof raw.mixHash !== "string" || typeof raw.profileId !== "string") throw new LoudnessError(`${path}: malformed measurement; re-run gs measure-loudness`);
+	return raw;
+}
+/**
+* Parse the JSON block ffmpeg's `loudnorm=print_format=json` prints to stderr.
+* It carries `input_i` / `input_tp` / `input_lra` (the measured loudness),
+* alongside the would-be normalization params (which we ignore — we apply our
+* own peak-clamped scalar gain instead).
+*/
+function parseLoudnormJson(stderr) {
+	const start = stderr.lastIndexOf("{");
+	const end = stderr.lastIndexOf("}");
+	if (start < 0 || end < 0 || end < start) throw new LoudnessError(`could not find loudnorm JSON in ffmpeg output:\n${stderr.slice(-1e3)}`);
+	let parsed;
+	try {
+		parsed = JSON.parse(stderr.slice(start, end + 1));
+	} catch {
+		throw new LoudnessError(`could not parse loudnorm JSON:\n${stderr.slice(start, end + 1)}`);
+	}
+	const num = (k) => {
+		const v = Number(parsed[k]);
+		if (!Number.isFinite(v)) throw new LoudnessError(`loudnorm JSON missing finite '${k}' (got '${parsed[k]}')`);
+		return v;
+	};
+	return {
+		inputI: num("input_i"),
+		inputTp: num("input_tp"),
+		inputLra: num("input_lra")
+	};
+}
+/**
+* Run ffmpeg's loudnorm measurement pass over a built mix WAV/PCM file and return
+* the measured loudness. This is the quarantined non-deterministic stage — it
+* runs ONLY at measure-time (commit), never during render.
+*/
+function measureFile(audioPath) {
+	const result = spawnSync("ffmpeg", [
+		"-hide_banner",
+		"-nostats",
+		"-i",
+		audioPath,
+		"-af",
+		"loudnorm=print_format=json",
+		"-f",
+		"null",
+		"-"
+	], { encoding: "utf8" });
+	if (result.status !== 0) throw new LoudnessError(`ffmpeg loudnorm measurement failed (exit ${result.status}):\n${(result.stderr ?? "").slice(-1e3)}`);
+	return parseLoudnormJson(result.stderr ?? "");
+}
+/**
+* Build the final mix to a WAV, run the ffmpeg loudnorm measurement over it, and
+* commit a `<scene>.loudness.json` with the peak-clamped publish gain + a mixHash
+* bound to the mix-input manifests. This is the measure step (commit-time); it is
+* the only place the non-deterministic ebur128/mix-to-PCM stages run.
+*/
+async function measureLoudnessCommand(opts) {
+	const profile = resolveProfile(opts.profile ?? "youtube");
+	const { buildMixWav } = await import("./render.js").then((n) => n.l);
+	const tmp = mkdtempSync(join(tmpdir(), "glissade-loudness-"));
+	try {
+		const wavPath = join(tmp, "mix.wav");
+		if (!await buildMixWav({
+			modulePath: opts.modulePath,
+			narration: opts.narration ?? "auto",
+			music: opts.music ?? "auto",
+			sfx: opts.sfx ?? "auto"
+		}, wavPath)) throw new LoudnessError(`${opts.modulePath} has no audio to measure (no timeline audio and no narration/music/sfx manifests)`);
+		const { inputI, inputTp, inputLra } = measureFile(wavPath);
+		const gain = computeGainDb(profile, inputI, inputTp);
+		const clampBound = peakClampBinds(profile, inputI, inputTp);
+		const mixHash = computeMixHash(opts.modulePath);
+		const measurement = {
+			loudnessVersion: 1,
+			profileId: profile.id,
+			inputI: round2(inputI),
+			inputTp: round2(inputTp),
+			inputLra: round2(inputLra),
+			gain: round2(gain),
+			mixHash
+		};
+		const loudnessPath = loudnessPathFor(opts.modulePath);
+		writeFileSync(loudnessPath, JSON.stringify(measurement, null, 2) + "\n");
+		return {
+			measurement,
+			loudnessPath,
+			profile,
+			clampBound,
+			warning: clampBound && !profile.platformNormalized ? `profile '${profile.id}' targets ${profile.targetLufs} LUFS but the source true-peak (${measurement.inputTp} dBTP) clamps the gain to ${measurement.gain} dB, leaving the mix at ~${round2(inputI + gain)} LUFS (below target). A brickwall true-peak limiter (deferred in 0.12) would recover the headroom; for now this profile under-shoots loudness.` : null
+		};
+	} finally {
+		rmSync(tmp, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+const round2 = (v) => Math.round(v * 100) / 100;
+//#endregion
+export { computeGainDb as a, loudness_exports as c, parseLoudnormJson as d, peakClampBinds as f, PUBLISH_PROFILES as i, measureFile as l, resolveProfile as m, LOUDNESS_SCHEMA_VERSION as n, computeMixHash as o, readLoudness as p, LoudnessError as r, loudnessPathFor as s, DEFAULT_PROFILE_ID as t, measureLoudnessCommand as u };

package/dist/music.js

@@ -1,4 +1,4 @@
-import { o as resolveAssetPath } from "./audioMix.js";
+import { s as resolveAssetPath } from "./audioMix.js";
 import { existsSync, readFileSync } from "node:fs";
 import { basename } from "node:path";
 import { music, narration, validateMusicTiming } from "@glissade/narrate";

package/dist/narrationLintCommand.js

@@ -0,0 +1,314 @@
+import { t as __exportAll } from "./rolldown-runtime.js";
+import { a as loadSceneModule } from "./render.js";
+import { existsSync, readFileSync } from "node:fs";
+import { splitCaption } from "@glissade/narrate";
+//#region src/narrationLint.ts
+/**
+* gs narration-lint (§5 narration): catch slow-re-narrate failures — a segment
+* that overran its beat, a caption too dense to read, a caption that overflows
+* its box — at BUILD, not render-hours-later.
+*
+* PURE over the committed `*.narration.timing.json` + the REAL measured caption
+* geometry: no clock, no RNG, no I/O of its own (the CLI reads the files and
+* builds the probe). The only environmental caveat is WHICH measurer feeds the
+* caption-fit rule — the CLI defaults to the Skia measurer with the render's
+* own fonts and drives the REAL caption node (its width/baseFont/autoFit
+* formula + the real `breakLines`), so a lint that passes can't burn-overflow.
+*
+* Tiers (§narration-lint LOCKED):
+*   Tier-1 (HARD, deterministic, CAN fail CI / exit non-zero):
+*     reading-speed  — chars-per-second over committed cue text vs `maxCps`
+*     anchor-budget  — a segment/pause that overran its allotted beat
+*     caption-fit    — a cue that overflows its box / exceeds maxLines, using
+*                      the REAL measured geometry
+*   Tier-2 (WARN-only, NEVER fails CI):
+*     beat-drift     — caption cue boundary drifts from its word timing
+*     silence        — implausible silence (a long unscripted gap / a segment
+*                      that reads suspiciously slow)
+*/
+function cuesOf(timing) {
+	const out = [];
+	for (const s of timing.segments) splitCaption(s, timing.captionSplit?.maxChars).forEach((c, i) => {
+		out.push({
+			segId: s.id,
+			index: i,
+			text: c.text,
+			start: c.start,
+			end: c.end
+		});
+	});
+	return out;
+}
+/** A stable cue id: the segment id, suffixed `#n` when a segment splits. */
+function cueId(c, total) {
+	return total > 1 ? `${c.segId}#${c.index}` : c.segId;
+}
+/** Visible characters in a cue (whitespace collapsed) — the reading-load proxy. */
+function readingChars(text) {
+	return text.replace(/\s+/g, " ").trim().length;
+}
+/**
+* Lint the committed narration timing. Pure: same inputs (timing + the probe's
+* measurements) → same diagnostics, in any order. Tier-1 diagnostics are
+* errors a caller can exit non-zero on; Tier-2 are warnings that never gate CI.
+*/
+function lintNarration(timing, opts = {}) {
+	const maxCps = opts.maxCps ?? 17;
+	const warnings = opts.warnings ?? true;
+	const out = [];
+	const cues = cuesOf(timing);
+	const perSeg = /* @__PURE__ */ new Map();
+	for (const c of cues) perSeg.set(c.segId, (perSeg.get(c.segId) ?? 0) + 1);
+	for (const c of cues) {
+		const chars = readingChars(c.text);
+		const window = c.end - c.start;
+		if (chars === 0 || window <= 0) continue;
+		const cps = chars / window;
+		if (cps > maxCps + 1e-6) {
+			const id = cueId(c, perSeg.get(c.segId) ?? 1);
+			out.push({
+				rule: "reading-speed",
+				tier: 1,
+				severity: "error",
+				id,
+				message: `reads at ${cps.toFixed(1)} cps (${chars} chars in ${window.toFixed(2)}s) — over ${maxCps} cps`,
+				detail: {
+					cps: round(cps),
+					maxCps,
+					chars,
+					seconds: round(window)
+				}
+			});
+		}
+	}
+	const budgets = timing.budgets ?? {};
+	const checkBudget = (id, duration, maxSec) => {
+		if (maxSec === void 0 || !(maxSec > 0)) return;
+		if (duration > maxSec + 1e-6) out.push({
+			rule: "anchor-budget",
+			tier: 1,
+			severity: "error",
+			id,
+			message: `beat ran ${duration.toFixed(2)}s, over its ${maxSec.toFixed(2)}s budget (by ${(duration - maxSec).toFixed(2)}s)`,
+			detail: {
+				duration: round(duration),
+				maxSec,
+				overBy: round(duration - maxSec)
+			}
+		});
+	};
+	for (const s of timing.segments) checkBudget(s.id, s.duration, s.maxSec ?? budgets[s.id]);
+	for (const p of timing.pauses ?? []) checkBudget(p.id, p.duration, budgets[p.id]);
+	if (opts.caption) {
+		const probe = opts.caption;
+		for (const c of cues) {
+			const id = cueId(c, perSeg.get(c.segId) ?? 1);
+			const { lines, bottomY } = probe.measure(c.text);
+			if (lines > probe.maxLines) out.push({
+				rule: "caption-fit",
+				tier: 1,
+				severity: "error",
+				id,
+				message: `caption wraps to ${lines} lines, over maxLines ${probe.maxLines}`,
+				detail: {
+					lines,
+					maxLines: probe.maxLines,
+					text: c.text
+				}
+			});
+			else if (bottomY > probe.sceneH + 1e-6) out.push({
+				rule: "caption-fit",
+				tier: 1,
+				severity: "error",
+				id,
+				message: `caption overflows the frame: its lowest line ends at y=${bottomY.toFixed(0)} of ${probe.sceneH}`,
+				detail: {
+					bottomY: round(bottomY),
+					sceneH: probe.sceneH,
+					lines,
+					text: c.text
+				}
+			});
+		}
+	}
+	if (!warnings) return out;
+	const pauseSpans = (timing.pauses ?? []).map((p) => ({
+		start: p.start,
+		end: p.start + p.duration
+	}));
+	const isPauseGap = (start, end) => pauseSpans.some((p) => p.start <= start + 1e-6 && p.end >= end - 1e-6);
+	const sorted = [...timing.segments].sort((a, b) => a.start - b.start);
+	for (let i = 0; i < sorted.length - 1; i++) {
+		const a = sorted[i];
+		const b = sorted[i + 1];
+		const gap = b.start - (a.start + a.duration);
+		if (gap > 2 && !isPauseGap(a.start + a.duration, b.start)) out.push({
+			rule: "silence",
+			tier: 2,
+			severity: "warn",
+			id: `${a.id}→${b.id}`,
+			message: `${gap.toFixed(2)}s of unscripted silence between '${a.id}' and '${b.id}' (no pause declared)`,
+			detail: { gap: round(gap) }
+		});
+	}
+	for (const s of timing.segments) {
+		if (!s.words || s.words.length === 0) continue;
+		const split = splitCaption(s, timing.captionSplit?.maxChars);
+		if (split.length < 2) continue;
+		for (let i = 1; i < split.length; i++) {
+			const cueStart = split[i].start;
+			const nearest = s.words.reduce((best, w) => Math.abs(w.start - cueStart) < Math.abs(best - cueStart) ? w.start : best, s.words[0].start);
+			const drift = Math.abs(nearest - cueStart);
+			if (drift > .4) out.push({
+				rule: "beat-drift",
+				tier: 2,
+				severity: "warn",
+				id: `${s.id}#${i}`,
+				message: `caption cue starts ${drift.toFixed(2)}s off the nearest word boundary`,
+				detail: { drift: round(drift) }
+			});
+		}
+	}
+	return out;
+}
+function round(n) {
+	return Math.round(n * 1e3) / 1e3;
+}
+/** True when any Tier-1 diagnostic is present — the CI gate / exit-code signal. */
+function hasErrors(diags) {
+	return diags.some((d) => d.tier === 1);
+}
+/** A human-readable table (the default terminal output). */
+function formatTable(diags) {
+	if (diags.length === 0) return "narration-lint: clean — no issues\n";
+	const rows = diags.map((d) => {
+		return `  ${d.tier === 1 ? "ERROR" : "warn "}  ${d.rule.padEnd(13)}  ${d.id.padEnd(16)}  ${d.message}`;
+	});
+	const errs = diags.filter((d) => d.tier === 1).length;
+	const warns = diags.length - errs;
+	return `${`narration-lint: ${errs} error${errs === 1 ? "" : "s"}, ${warns} warning${warns === 1 ? "" : "s"}`}\n${rows.join("\n")}\n`;
+}
+/**
+* A git-apply-able unified diff that bumps the committed budgets (and
+* captionSplit, when a caption is too dense) to the values the manifest already
+* shows — the `--fix` SUGGESTION. NEVER writes anything: it prints a diff the
+* author reviews and applies (re-narrate is the real fix; this just unblocks CI
+* when the over-budget value is genuinely the new intent). Targets the SCRIPT
+* (`*.narration.json`), since budgets are committed there.
+*/
+function fixDiff(diags, scriptPath, script) {
+	const bumps = /* @__PURE__ */ new Map();
+	for (const d of diags) if (d.rule === "anchor-budget" && typeof d.detail?.["duration"] === "number") bumps.set(d.id, Math.ceil(d.detail["duration"] * 10) / 10);
+	if (bumps.size === 0) return "";
+	const before = { ...script.budgets ?? {} };
+	const after = { ...before };
+	for (const [id, sec] of bumps) after[id] = sec;
+	const fmt = (b) => JSON.stringify({ budgets: b }, null, 2).split("\n");
+	const beforeLines = fmt(before);
+	const afterLines = fmt(after);
+	return [
+		`--- a/${scriptPath}`,
+		`+++ b/${scriptPath}`,
+		"@@ budgets @@",
+		...beforeLines.map((l) => `-${l}`),
+		...afterLines.map((l) => `+${l}`)
+	].join("\n") + "\n";
+}
+//#endregion
+//#region src/narrationLintCommand.ts
+/**
+* The `gs narration-lint` command wiring: read the committed timing manifest,
+* build the REAL caption-fit probe (Skia measurer + the render's fonts driving
+* the actual caption node), run `lintNarration`, and render JSON / a table /
+* the --fix diff. The pure rules live in narrationLint.ts; this file owns only
+* the I/O + the Skia-measurer plumbing (so the lint's geometry == render's).
+*/
+var narrationLintCommand_exports = /* @__PURE__ */ __exportAll({
+	buildCaptionProbe: () => buildCaptionProbe,
+	lintTimingPathFor: () => lintTimingPathFor,
+	narrationLintCommand: () => narrationLintCommand
+});
+/** `<scene>.narration.timing.json` or the manifest path itself. */
+async function lintTimingPathFor(input) {
+	if (input.endsWith(".narration.timing.json")) {
+		if (!existsSync(input)) throw new Error(`no narration timing manifest at ${input}`);
+		return input;
+	}
+	const { timingPathFor } = await import("./captions.js").then((n) => n.t);
+	const p = timingPathFor(input);
+	if (!p) throw new Error(`no narration timing manifest beside ${input} — run \`gs narrate\` first, or pass a *.narration.timing.json path directly`);
+	return p;
+}
+/**
+* Build a caption-fit probe by loading the scene, registering its fonts, and
+* driving the REAL `captions` node with the Skia measurer. Returns null when
+* the input is a bare manifest (no scene module) or the scene has no caption
+* node — caption-fit then doesn't run, and the lint is still exact for the
+* other rules. Async because font registration + the scene load are.
+*/
+async function buildCaptionProbe(input, maxLines) {
+	if (input.endsWith(".narration.timing.json")) return null;
+	let mod;
+	try {
+		mod = await loadSceneModule(input);
+	} catch {
+		return null;
+	}
+	const scene = mod.createScene();
+	const cap = scene.nodes.get("captions");
+	if (!cap || typeof cap.lineBoxes !== "function" || typeof cap.text !== "function" || typeof cap.text.set !== "function") return null;
+	const { resolveAssetPath } = await import("./audioMix.js").then((n) => n.i);
+	const { buildFontRegistry } = await import("@glissade/core");
+	const fontRegistry = buildFontRegistry(mod.timeline.assets);
+	const fonts = {};
+	for (const face of fontRegistry.faces()) fonts[face.family] = resolveAssetPath(face.url, input);
+	const { createMeasurer } = await import("@glissade/backend-skia");
+	const measurer = createMeasurer({ fonts });
+	scene.setTextMeasurer(measurer);
+	return {
+		sceneH: scene.size.h,
+		maxLines,
+		measure: (cueText) => {
+			cap.text.set(cueText);
+			const boxes = cap.lineBoxes();
+			const lines = boxes.length;
+			const deepest = boxes.reduce((m, b) => Math.max(m, b.y + b.h), 0);
+			return {
+				lines,
+				bottomY: cap.position.y() + deepest
+			};
+		}
+	};
+}
+/** Run the lint end-to-end and render the output (JSON / table / --fix diff). */
+async function narrationLintCommand(opts) {
+	const timingPath = await lintTimingPathFor(opts.input);
+	const timing = JSON.parse(readFileSync(timingPath, "utf8"));
+	if (timing.timingVersion !== 1) throw new Error(`unsupported timingVersion ${String(timing.timingVersion)} in ${timingPath}`);
+	const maxLines = opts.maxLines ?? 2;
+	const caption = await buildCaptionProbe(opts.input, maxLines);
+	const diagnostics = lintNarration(timing, {
+		...opts.maxCps !== void 0 ? { maxCps: opts.maxCps } : {},
+		...caption ? { caption } : {},
+		...opts.noWarnings ? { warnings: false } : {}
+	});
+	const errors = hasErrors(diagnostics);
+	let output;
+	if (opts.fix) {
+		const scriptPath = opts.input.endsWith(".narration.timing.json") ? opts.input.replace(/\.narration\.timing\.json$/, ".narration.json") : opts.input.replace(/\.[jt]sx?$/, "") + ".narration.json";
+		output = fixDiff(diagnostics, scriptPath, existsSync(scriptPath) ? JSON.parse(readFileSync(scriptPath, "utf8")) : {}) || "narration-lint --fix: nothing to suggest (no budget bumps apply)\n";
+	} else if (opts.json) output = JSON.stringify({
+		timingPath,
+		hasErrors: errors,
+		diagnostics
+	}, null, 2) + "\n";
+	else output = formatTable(diagnostics);
+	return {
+		diagnostics,
+		hasErrors: errors,
+		output,
+		timingPath
+	};
+}
+//#endregion
+export { fixDiff as a, lintNarration as c, narrationLintCommand_exports as i, lintTimingPathFor as n, formatTable as o, narrationLintCommand as r, hasErrors as s, buildCaptionProbe as t };

package/dist/prepare.js

@@ -1,4 +1,4 @@
-import { r as loadSceneModule } from "./render.js";
+import { a as loadSceneModule } from "./render.js";
 import { narrateCommand } from "./narrate.js";
 import { prepareSfx, sfxScriptPathFor } from "./sfx.js";
 import { existsSync } from "node:fs";