@glissade/cli 0.42.0 → 0.43.0-pre.1

package/dist/build.js

@@ -1,5 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime.js";
 import { t as glissadeVersion } from "./version.js";
+import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -67,15 +68,19 @@ function planScene(scene, steps, probe) {
 * ffmpeg; the default `runStep` delegates to the shipped narrate/sfx/loudness/render.
 */
 var build_exports = /* @__PURE__ */ __exportAll({
+	affectedScenes: () => affectedScenes,
 	applicableSteps: () => applicableSteps,
 	buildCommand: () => buildCommand,
 	defineProject: () => defineProject,
+	gitChangedFiles: () => gitChangedFiles,
 	hashInputs: () => hashInputs,
 	loadConfig: () => loadConfig,
 	mixDefaults: () => mixDefaults,
 	outputVideo: () => outputVideo,
 	renderDefaults: () => renderDefaults,
 	resolveScenes: () => resolveScenes,
+	sceneInputFiles: () => sceneInputFiles,
+	selectAffectedScenes: () => selectAffectedScenes,
 	stepInputs: () => stepInputs,
 	stepOutput: () => stepOutput,
 	stepSalt: () => stepSalt
@@ -213,6 +218,64 @@ function applicableSteps(scene) {
 	steps.push("render");
 	return PIPELINE.filter((s) => steps.includes(s));
 }
+/** Every input file whose change makes a scene stale — the scene source + every
+*  step's inputs (upstream sidecars included), as absolute paths. */
+function sceneInputFiles(scene) {
+	const files = new Set([scene]);
+	for (const step of applicableSteps(scene)) for (const f of stepInputs(scene, step)) files.add(f);
+	return [...files];
+}
+/**
+* Restrict a scene list to those a git diff TOUCHED — a scene is affected when any
+* of its input files (source + sidecars) is in `changedPaths`. Pure: the caller
+* supplies the resolved changed-file set (from `gitChangedFiles`), so the whole
+* selector is unit-testable without git. This is a COARSE pre-filter on top of the
+* per-step content-hash staleness (planScene still hash-checks each selected scene),
+* so it never runs a scene the diff didn't touch, and never skips a real hash change
+* within the ones it keeps. `changedPaths` are absolute.
+*/
+function affectedScenes(scenes, changedPaths) {
+	return scenes.filter((s) => sceneInputFiles(s).some((f) => changedPaths.has(f)));
+}
+const isCodeFile = (f) => /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(f);
+/**
+* The `--affected` selector with a SAFE-BY-DEFAULT fallback. A scene's staleness is
+* tracked by its own files (source + sidecars), but a scene `.ts` *imports* other
+* modules — and a change to a shared `src/util.ts` (or the config, or any code file
+* not attributable to a scene) affects scenes transitively, invisibly to the
+* file-level diff. Silently narrowing that to nothing would ship stale renders — the
+* exact silent-skip the rest of the system fails loud on. So: if the diff touched a
+* CODE file (`.ts`/`.js`/…) that is NOT any scene's recognized input, we cannot
+* attribute it, so we DON'T narrow — rebuild every scene (the per-step content hash
+* still skips the genuinely-fresh ones). A diff of only non-code files (docs, an
+* unrelated JSON) narrows normally. (Precise import-graph affectedness — rebuild only
+* true dependents — is a follow-up; footgun-free-80% over precise-but-unshipped-100%.)
+*/
+function selectAffectedScenes(scenes, changedPaths) {
+	const accountedFor = new Set(scenes.flatMap(sceneInputFiles));
+	return [...changedPaths].some((f) => isCodeFile(f) && !accountedFor.has(f)) ? [...scenes] : affectedScenes(scenes, changedPaths);
+}
+/** The files changed since a git ref (`git diff --name-only <ref>`), as absolute paths. */
+function gitChangedFiles(ref, root) {
+	const top = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+		cwd: root,
+		encoding: "utf8"
+	}).trim();
+	const out = execFileSync("git", [
+		"diff",
+		"--name-only",
+		ref
+	], {
+		cwd: root,
+		encoding: "utf8"
+	});
+	const files = /* @__PURE__ */ new Set();
+	for (const line of out.split("\n")) {
+		const rel = line.trim();
+		if (rel) files.add(resolve(top, rel));
+	}
+	return files;
+}
 function hashInputs(paths, salt) {
 	const h = createHash("sha256").update(salt).update("\0");
 	for (const p of paths) {
@@ -237,49 +300,82 @@ function loadManifest(root) {
 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 = [];
+/** One pass of the per-scene pipeline (plan run/skip per step, execute the stale ones,
+*  record hashes). Shared by the render phase and the post-master remux phase — the
+*  same staleness machinery, so the master's committed loudness re-runs exactly the
+*  render steps whose `loudness.json` changed. Mutates `manifest` in place. */
+async function runScenePass(scenes, cfg, root, version, manifest, deps, explain, log) {
+	const plans = [];
 	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), {
+		const scenePlans = planScene(key, applicableSteps(scene), {
 			currentHash: (step) => hashInputs(stepInputs(scene, step), stepSalt(step, cfg, version)),
 			recordedHash: (step) => rec[step],
 			outputExists: (step) => existsSync(stepOutput(scene, step, videoPath))
 		});
-		for (const plan of plans) {
+		for (const plan of scenePlans) {
 			log(`${key}  ${plan.step}: ${plan.action} (${plan.reason})`);
 			if (plan.action === "skip") {
 				skipped++;
 				continue;
 			}
 			ran++;
-			if (!opts.explain) {
+			if (!explain) {
 				await deps.runStep(scene, plan.step, cfg, videoPath);
 				rec[plan.step] = hashInputs(stepInputs(scene, plan.step), stepSalt(plan.step, cfg, version));
 			}
 		}
 		manifest.scenes[key] = rec;
-		allPlans.push(...plans);
+		plans.push(...scenePlans);
+	}
+	return {
+		ran,
+		skipped,
+		plans
+	};
+}
+async function buildCommand(opts, deps = { runStep: defaultRunStep }) {
+	const cfg = await loadConfig(opts.config);
+	const root = dirname(resolve(opts.config));
+	const allScenes = resolveScenes(cfg.scenes, root);
+	let renderScenes = allScenes;
+	if (opts.only?.length) renderScenes = renderScenes.filter((s) => opts.only.some((o) => s.includes(o)));
+	if (opts.affected !== void 0) renderScenes = selectAffectedScenes(renderScenes, gitChangedFiles(opts.affected, root));
+	const version = glissadeVersion();
+	const manifest = loadManifest(root);
+	const log = opts.onLog ?? (() => {});
+	const p1 = await runScenePass(renderScenes, cfg, root, version, manifest, deps, !!opts.explain, log);
+	let ran = p1.ran;
+	let skipped = p1.skipped;
+	const allPlans = [...p1.plans];
+	let mastered = 0;
+	if (cfg.master && allScenes.length > 0) if (opts.explain) log(`master: WOULD master ${allScenes.length} member(s) to a shared target, then remux any whose loudness moves`);
+	else {
+		log("master: shared-target loudness across the project");
+		mastered = await (deps.runMaster ?? defaultRunMaster)(allScenes, cfg.master, log);
+		const p3 = await runScenePass(allScenes, cfg, root, version, manifest, deps, false, log);
+		ran += p3.ran;
+		skipped += p3.skipped;
+		allPlans.push(...p3.plans);
 	}
 	if (!opts.explain) saveManifest(root, manifest);
 	return {
-		scenes: scenes.length,
+		scenes: renderScenes.length,
 		ran,
 		skipped,
-		plans: allPlans
+		plans: allPlans,
+		mastered
 	};
 }
+/** Default project-master executor — the real shared-target `runMaster`. */
+async function defaultRunMaster(members, opts, log) {
+	const { runMaster } = await import("./master.js").then((n) => n.a);
+	return (await runMaster(members, opts, log)).members.length;
+}
 /** Default step executor — the shipped commands. */
 async function defaultRunStep(scene, step, cfg, videoPath) {
 	switch (step) {

package/dist/cli.js

@@ -88,7 +88,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
+  gs build [filter...] [--config <glissade.config.ts>] [--affected <git-ref>] [--explain]   content-graph DAG runner: narrate→sfx→loudness→render per scene, runs ONLY the stale subtree. --affected <ref> pre-filters to scenes a git diff since <ref> touched (rebuild only what a change set touched; composed with the per-step content-hash staleness)
   gs describe [--out <api.json>] [--examples]   snapshot THIS engine's describe() API manifest (stdout, or --out to a file) — the input to gs migrate
   gs migrate <baseline-api.json> [--json] [--check]   diff a saved API manifest against the current engine: moved imports / removed / added / changed, with a suggested fix per breaking item (advisory; --check exits non-zero on any breaking change for CI gating)
   gs repin <scene-module> --golden <dir> [--name <p>] [--frames a,b,..] [--fps <n>] [--since <ref>] [--write] [--only a,b] [--heatmap <dir>] [--floor <ssim>] [--force]   narration-aware golden reviewer: render current vs committed goldens, report perceptual delta + the re-narration cause, re-pin only frames you allow (default dry-run; --floor refuses a bigger-than-expected drop)
@@ -227,6 +227,7 @@ async function main() {
 				config,
 				explain,
 				...bp.length ? { only: bp } : {},
+				...bf.get("affected") ? { affected: bf.get("affected") } : {},
 				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`);

package/dist/config.d.ts

@@ -1,3 +1,5 @@
+import { c as MasterRunOptions } from "./master.js";
+
 //#region src/build.d.ts
 
 interface ProjectConfig {
@@ -5,6 +7,14 @@ interface ProjectConfig {
   scenes: string[];
   /** output dir for rendered videos (default: alongside each scene as `<base>.mp4`). */
   out?: string;
+  /**
+   * 0.43 project runtime: master the WHOLE project to a SHARED loudness target after
+   * rendering. When set, `gs build` runs a second, cross-scene phase — render all →
+   * BARRIER → master (one shared LUFS target + limiter across every member) → the
+   * render staleness (a changed `<scene>.loudness.json`) remuxes exactly the members
+   * whose gain moved. Absent → the classic per-scene pipeline, unchanged.
+   */
+  master?: MasterRunOptions;
   /** per-scene render/cache defaults. */
   defaults?: {
     fps?: number;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { A as peakClampBinds, C as PublishProfile, D as measureFile, E as loudnessPathFor, M as resolveProfile, O as measureLoudnessCommand, S as PUBLISH_PROFILES, T as computeMixHash, _ as LOUDNESS_SCHEMA_VERSION, a as MasterMemberResult, b as MeasureLoudnessOptions, d as masterAfChain, f as masterCommand, g as DEFAULT_PROFILE_ID, h as CommittedLimiter, i as MasterLimiter, j as readLoudness, k as parseLoudnormJson, l as MemberMeasure, m as planMaster, n as MasterConfig, o as MasterPlan, p as normalizeMasterConfig, r as MasterError, s as MasterResult, t as DEFAULT_MAX_GR_DB, u as MemberPlan, v as LoudnessError, w as computeGainDb, x as MeasureLoudnessResult, y as LoudnessMeasurement } from "./master.js";
 import { AudioClip, CompiledTimeline, Key, Timeline } from "@glissade/core";
 import { DisplayList, Scene, SceneModule, VideoFrameSource } from "@glissade/scene";
 import { NarrationTiming } from "@glissade/narrate";
@@ -129,200 +130,6 @@ declare function probeEntryHeader(file: string): {
 /** Remove the whole `.gscache` dir (a `gs cache clear` convenience / test cleanup). */
 declare function clearFrameCache(dir: string): void;
 //#endregion
-//#region src/loudness.d.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.)
- */
-declare class LoudnessError extends Error {
-  constructor(detail: string);
-}
-/** A publish target: integrated-loudness goal + the true-peak ceiling. */
-interface PublishProfile {
-  readonly id: string;
-  /** integrated-loudness target, LUFS */
-  readonly targetLufs: number;
-  /** true-peak ceiling, dBTP (the peak clamp is computed against this) */
-  readonly truePeakDb: number;
-  /**
-   * Whether the platform re-normalizes loudness on its side. For
-   * platform-normalized targets (YouTube/Shorts) a peaky source that can't reach
-   * `targetLufs` without clipping is fine — the platform finishes the job. For
-   * un-normalized targets (podcast/broadcast) it earns an advisory warning,
-   * since 0.12 ships no brickwall limiter to recover the headroom.
-   */
-  readonly platformNormalized: boolean;
-}
-declare const PUBLISH_PROFILES: Readonly<Record<string, PublishProfile>>;
-declare const DEFAULT_PROFILE_ID = "youtube";
-/** Resolve a profile id (case-insensitive) or throw with the valid set. */
-declare function resolveProfile(id: string): PublishProfile;
-declare const LOUDNESS_SCHEMA_VERSION: 1;
-/**
- * The brickwall true-peak limiter a `gs master` pass commits (0.39). Absent on a
- * plain `gs measure-loudness` measurement (that stays a pure peak-clamped scalar
- * gain, byte-identical). Present, render/remux applies `volume=<gain>dB` THEN an
- * `alimiter` holding the true peak at `ceilingDb` — the non-linear stage that lets
- * a peaky member reach the target instead of landing LUs low. Applied in the mix
- * filter graph (deterministic ffmpeg), NOT a render-time per-frame scalar.
- */
-interface CommittedLimiter {
-  readonly mode: 'truepeak';
-  /** the true-peak ceiling the limiter holds, dBTP. */
-  readonly ceilingDb: number;
-}
-/** The committed `<scene>.loudness.json`. */
-interface LoudnessMeasurement {
-  loudnessVersion: typeof LOUDNESS_SCHEMA_VERSION;
-  /** the resolved publish profile id (youtube/shorts/podcast/broadcast/ebu) */
-  profileId: string;
-  /** measured integrated loudness, LUFS (ebur128) */
-  inputI: number;
-  /** measured true peak, dBTP */
-  inputTp: number;
-  /** measured loudness range, LU */
-  inputLra: number;
-  /**
-   * the deterministic gain to apply at render, in dB.
-   * `gain = min(targetLufs - inputI, truePeakDb - inputTp)` — the peak clamp
-   * guarantees the published output is ≤ truePeakDb using the MEASURED peak.
-   */
-  gain: number;
-  /**
-   * binds this measurement to the mix CONTENT version (a hash of the mix input
-   * manifests — narration/music/sfx timing + any wired timeline audio — NOT
-   * mtime). Render recomputes it and HARD-THROWS on mismatch so a re-narrate
-   * invalidates the measurement loudly instead of silently mis-normalizing.
-   */
-  mixHash: string;
-  /**
-   * the true-peak limiter to apply after the gain (0.39 `gs master`). Absent on a
-   * plain `gs measure-loudness` measurement (gain-only, byte-identical). When
-   * present, `gain` may exceed the raw peak clamp (the limiter shaves the
-   * overshoot to `limiter.ceilingDb`).
-   */
-  limiter?: CommittedLimiter;
-}
-/**
- * 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`).
- */
-declare function computeGainDb(profile: PublishProfile, inputI: number, inputTp: number): number;
-/**
- * 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).
- */
-declare function peakClampBinds(profile: PublishProfile, inputI: number, inputTp: number): boolean;
-/**
- * Hash the CONTENT of the mix's inputs so a re-narrate / re-sfx / music change OR
- * an in-place edit of an audio file invalidates a committed measurement. We hash
- * the files' BYTES (not mtime): the narration/music/sfx timing manifests AND every
- * path in `extraInputs` — the resolved mix AUDIO files (timeline clips + the music
- * stem + narration cache audio), supplied by `collectMixAudioInputs` at both the
- * measure and render call sites so the two agree. Hashing only the timing manifests
- * would miss an edited `.wav`/stem (same manifest, changed bytes) and apply a stale
- * publish gain silently — so `extraInputs` MUST be passed on the gate path. Missing
- * files are recorded by name with a sentinel so adding one later also changes the
- * hash. The scene module path itself is excluded.
- */
-declare function computeMixHash(modulePath: string, extraInputs?: readonly string[]): string;
-/**
- * The committed loudness measurement path for a scene module.
- *
- * Base (no locale): `<stem>.loudness.json` — UNCHANGED. With a locale set (0.15
- * FIX 2): `<stem>.<locale>.loudness.json`. A localized render mixes the per-locale
- * narration (e.g. the zh wavs) → a DIFFERENT mixHash than the base, so it needs its
- * OWN committed measurement; one base file can't gate a localized render (it would
- * always read as a stale mixHash, with no supported way to commit a per-locale one).
- */
-declare function loudnessPathFor(modulePath: string, locale?: string): string;
-/** Read + validate a committed measurement, or null when none is committed. */
-declare function readLoudness(modulePath: string, locale?: string): LoudnessMeasurement | null;
-/**
- * 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).
- */
-declare function parseLoudnormJson(stderr: string): {
-  inputI: number;
-  inputTp: number;
-  inputLra: number;
-};
-/**
- * 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.
- */
-declare function measureFile(audioPath: string): {
-  inputI: number;
-  inputTp: number;
-  inputLra: number;
-};
-interface MeasureLoudnessOptions {
-  modulePath: string;
-  /** publish profile id; default 'youtube' */
-  profile?: string;
-  /** narration auto-mix toggle (mirrors render); default auto */
-  narration?: 'auto' | 'off';
-  music?: 'auto' | 'off';
-  sfx?: 'auto' | 'off';
-  /**
-   * locale code (0.15 FIX 2). When set, measure the per-locale mix (the localized
-   * narration sibling) and commit `<stem>.<locale>.loudness.json` instead of the
-   * base file. Mirrors `gs render --locale`, so the measured content matches what
-   * a localized render mixes.
-   */
-  locale?: string;
-}
-interface MeasureLoudnessResult {
-  measurement: LoudnessMeasurement;
-  loudnessPath: string;
-  /** profile the measurement was taken against */
-  profile: PublishProfile;
-  /** true when the peak clamp bound the gain (advisory: would need a brickwall limiter on an un-normalized profile) */
-  clampBound: boolean;
-  /** an advisory warning string when an un-normalized profile can't reach its target without clipping; else null */
-  warning: string | null;
-}
-/**
- * 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.
- */
-declare function measureLoudnessCommand(opts: MeasureLoudnessOptions): Promise<MeasureLoudnessResult>;
-//#endregion
 //#region src/render.d.ts
 interface RenderOptions {
   modulePath: string;
@@ -571,126 +378,6 @@ declare function planFinalAudio(opts: RenderOptions, timelineClips: AudioClip[],
  */
 declare function buildMixWav(opts: Pick<RenderOptions, 'modulePath' | 'narration' | 'music' | 'sfx' | 'locale'>, wavOut: string): Promise<boolean>;
 //#endregion
-//#region src/master.d.ts
-declare class MasterError extends Error {
-  constructor(message: string);
-}
-/** How much gain-reduction the limiter may apply to buy headroom (dB). */
-declare const DEFAULT_MAX_GR_DB = 6;
-/** The limiter spec (from `glissade.master.json`). */
-interface MasterLimiter {
-  /** true-peak brickwall (the only mode today). */
-  readonly mode: 'truepeak';
-  /** the true-peak ceiling, dBTP (defaults to the profile's `truePeakDb`). */
-  readonly ceilingDb?: number;
-  /** limiter lookahead, ms (advisory — maps to the ffmpeg attack window). */
-  readonly lookaheadMs?: number;
-  /** max gain-reduction the limiter may apply (dB); beyond this a member can't
-   *  reach the target cleanly and the shared target drops. Default 6. */
-  readonly maxGrDb?: number;
-}
-/** `glissade.master.json`. */
-interface MasterConfig {
-  /** publish profile id (youtube/shorts/podcast/broadcast/ebu). */
-  readonly profile?: string;
-  /** member scene globs (like `gs build`'s `scenes`). */
-  readonly members: readonly string[];
-  /** the limiter (or `false` to keep the legacy peak-clamp behaviour). */
-  readonly limiter?: MasterLimiter | false;
-  /** `shared-target` (all members hit one LUFS) or `per-asset` (each hits its own max). */
-  readonly consistency?: 'shared-target' | 'per-asset';
-}
-/** One member's measured input loudness (from the ffmpeg measure pass). */
-interface MemberMeasure {
-  readonly id: string;
-  /** integrated loudness, LUFS. */
-  readonly inputI: number;
-  /** true peak, dBTP. */
-  readonly inputTp: number;
-}
-/** The plan for one member: its target + the gain to apply + predicted limiting. */
-interface MemberPlan extends MemberMeasure {
-  /** the output LUFS this member is driven to. */
-  readonly target: number;
-  /** the gain to apply before the limiter, dB. */
-  readonly gain: number;
-  /** predicted limiter gain-reduction, dB (0 when the raw peak clears the ceiling). */
-  readonly grDb: number;
-  /** predicted output true peak, dBTP (== ceiling when the limiter engages). */
-  readonly predOutTp: number;
-  /** true when this member reaches the shared target within the GR budget. */
-  readonly reachable: boolean;
-}
-interface MasterPlan {
-  /** the LUFS target the set is normalized to (shared-target) or the profile cap. */
-  readonly sharedTarget: number;
-  readonly profileTarget: number;
-  readonly ceilingDb: number;
-  /** true when a limiter is in play (false = legacy peak-clamp). */
-  readonly limiter: boolean;
-  readonly maxGrDb: number;
-  readonly members: readonly MemberPlan[];
-}
-/**
- * Plan a master pass. Pure: measured members → shared target + per-member gains.
- *
- * - With a limiter, a member reaches `target` by applying `gain = target - inputI`
- *   and the limiter shaves any overshoot (`grDb`) down to the ceiling.
- * - Without a limiter (`limiter: null`), the gain is peak-CLAMPED (the legacy
- *   `min(target-inputI, ceiling-inputTp)`), so a peaky member lands below target.
- * - `shared-target` normalizes every member to one LUFS (the loudest all reach);
- *   `per-asset` drives each to its own max.
- */
-declare function planMaster(measures: readonly MemberMeasure[], profile: PublishProfile, opts: {
-  limiter: MasterLimiter | null;
-  consistency: 'shared-target' | 'per-asset';
-}): MasterPlan;
-/**
- * The `-af` chain that applies a master's gain + (optional) TRUE-peak limiter to a
- * WAV — the SAME {@link loudnessFilterNodes} the render `filter_complex` applies,
- * so the `gs master` verify pass measures exactly what a render will produce.
- */
-declare function masterAfChain(gainDb: number, limiter: CommittedLimiter | null): Promise<string>;
-interface MasterMemberResult {
-  readonly id: string;
-  readonly loudnessPath: string;
-  readonly measurement: LoudnessMeasurement;
-  /** measured input LUFS / dBTP. */
-  readonly inputI: number;
-  readonly inputTp: number;
-  /** VERIFIED output LUFS / dBTP (re-measured after gain+limiter). */
-  readonly outI: number;
-  readonly outTp: number;
-  readonly gain: number;
-  readonly grDb: number;
-  /** true when the verified output true-peak exceeded the ceiling (shouldn't happen). */
-  readonly overCeiling: boolean;
-}
-interface MasterResult {
-  readonly sharedTarget: number;
-  readonly ceilingDb: number;
-  readonly limiter: boolean;
-  readonly members: readonly MasterMemberResult[];
-  readonly report: string;
-}
-interface MasterCommandOptions {
-  configPath: string;
-  onLog?: (line: string) => void;
-}
-/**
- * `gs master <glissade.master.json>` — measure every member, plan the shared
- * target + limiter, apply+VERIFY per member, and commit `<scene>.loudness.json`
- * ×N. Reuses `buildMixWav`/`measureFile` (measure) and `resolveScenes` (globs);
- * writes the existing sidecar shape + the `limiter` block so render composes it as
- * a mix-only remux under the mixHash preflight.
- */
-declare function masterCommand(opts: MasterCommandOptions): Promise<MasterResult>;
-/** Validate + normalize a parsed `glissade.master.json` (fail-loud). */
-declare function normalizeMasterConfig(raw: unknown): Required<Pick<MasterConfig, 'members' | 'consistency'>> & {
-  profile: string;
-  limiter: MasterLimiter | null;
-};
-//#endregion
 //#region src/shards.d.ts
 declare class ShardError extends Error {
   constructor(message: string);

package/dist/master.d.ts

@@ -0,0 +1,330 @@
+//#region src/loudness.d.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.)
+ */
+declare class LoudnessError extends Error {
+  constructor(detail: string);
+}
+/** A publish target: integrated-loudness goal + the true-peak ceiling. */
+interface PublishProfile {
+  readonly id: string;
+  /** integrated-loudness target, LUFS */
+  readonly targetLufs: number;
+  /** true-peak ceiling, dBTP (the peak clamp is computed against this) */
+  readonly truePeakDb: number;
+  /**
+   * Whether the platform re-normalizes loudness on its side. For
+   * platform-normalized targets (YouTube/Shorts) a peaky source that can't reach
+   * `targetLufs` without clipping is fine — the platform finishes the job. For
+   * un-normalized targets (podcast/broadcast) it earns an advisory warning,
+   * since 0.12 ships no brickwall limiter to recover the headroom.
+   */
+  readonly platformNormalized: boolean;
+}
+declare const PUBLISH_PROFILES: Readonly<Record<string, PublishProfile>>;
+declare const DEFAULT_PROFILE_ID = "youtube";
+/** Resolve a profile id (case-insensitive) or throw with the valid set. */
+declare function resolveProfile(id: string): PublishProfile;
+declare const LOUDNESS_SCHEMA_VERSION: 1;
+/**
+ * The brickwall true-peak limiter a `gs master` pass commits (0.39). Absent on a
+ * plain `gs measure-loudness` measurement (that stays a pure peak-clamped scalar
+ * gain, byte-identical). Present, render/remux applies `volume=<gain>dB` THEN an
+ * `alimiter` holding the true peak at `ceilingDb` — the non-linear stage that lets
+ * a peaky member reach the target instead of landing LUs low. Applied in the mix
+ * filter graph (deterministic ffmpeg), NOT a render-time per-frame scalar.
+ */
+interface CommittedLimiter {
+  readonly mode: 'truepeak';
+  /** the true-peak ceiling the limiter holds, dBTP. */
+  readonly ceilingDb: number;
+}
+/** The committed `<scene>.loudness.json`. */
+interface LoudnessMeasurement {
+  loudnessVersion: typeof LOUDNESS_SCHEMA_VERSION;
+  /** the resolved publish profile id (youtube/shorts/podcast/broadcast/ebu) */
+  profileId: string;
+  /** measured integrated loudness, LUFS (ebur128) */
+  inputI: number;
+  /** measured true peak, dBTP */
+  inputTp: number;
+  /** measured loudness range, LU */
+  inputLra: number;
+  /**
+   * the deterministic gain to apply at render, in dB.
+   * `gain = min(targetLufs - inputI, truePeakDb - inputTp)` — the peak clamp
+   * guarantees the published output is ≤ truePeakDb using the MEASURED peak.
+   */
+  gain: number;
+  /**
+   * binds this measurement to the mix CONTENT version (a hash of the mix input
+   * manifests — narration/music/sfx timing + any wired timeline audio — NOT
+   * mtime). Render recomputes it and HARD-THROWS on mismatch so a re-narrate
+   * invalidates the measurement loudly instead of silently mis-normalizing.
+   */
+  mixHash: string;
+  /**
+   * the true-peak limiter to apply after the gain (0.39 `gs master`). Absent on a
+   * plain `gs measure-loudness` measurement (gain-only, byte-identical). When
+   * present, `gain` may exceed the raw peak clamp (the limiter shaves the
+   * overshoot to `limiter.ceilingDb`).
+   */
+  limiter?: CommittedLimiter;
+}
+/**
+ * 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`).
+ */
+declare function computeGainDb(profile: PublishProfile, inputI: number, inputTp: number): number;
+/**
+ * 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).
+ */
+declare function peakClampBinds(profile: PublishProfile, inputI: number, inputTp: number): boolean;
+/**
+ * Hash the CONTENT of the mix's inputs so a re-narrate / re-sfx / music change OR
+ * an in-place edit of an audio file invalidates a committed measurement. We hash
+ * the files' BYTES (not mtime): the narration/music/sfx timing manifests AND every
+ * path in `extraInputs` — the resolved mix AUDIO files (timeline clips + the music
+ * stem + narration cache audio), supplied by `collectMixAudioInputs` at both the
+ * measure and render call sites so the two agree. Hashing only the timing manifests
+ * would miss an edited `.wav`/stem (same manifest, changed bytes) and apply a stale
+ * publish gain silently — so `extraInputs` MUST be passed on the gate path. Missing
+ * files are recorded by name with a sentinel so adding one later also changes the
+ * hash. The scene module path itself is excluded.
+ */
+declare function computeMixHash(modulePath: string, extraInputs?: readonly string[]): string;
+/**
+ * The committed loudness measurement path for a scene module.
+ *
+ * Base (no locale): `<stem>.loudness.json` — UNCHANGED. With a locale set (0.15
+ * FIX 2): `<stem>.<locale>.loudness.json`. A localized render mixes the per-locale
+ * narration (e.g. the zh wavs) → a DIFFERENT mixHash than the base, so it needs its
+ * OWN committed measurement; one base file can't gate a localized render (it would
+ * always read as a stale mixHash, with no supported way to commit a per-locale one).
+ */
+declare function loudnessPathFor(modulePath: string, locale?: string): string;
+/** Read + validate a committed measurement, or null when none is committed. */
+declare function readLoudness(modulePath: string, locale?: string): LoudnessMeasurement | null;
+/**
+ * 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).
+ */
+declare function parseLoudnormJson(stderr: string): {
+  inputI: number;
+  inputTp: number;
+  inputLra: number;
+};
+/**
+ * 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.
+ */
+declare function measureFile(audioPath: string): {
+  inputI: number;
+  inputTp: number;
+  inputLra: number;
+};
+interface MeasureLoudnessOptions {
+  modulePath: string;
+  /** publish profile id; default 'youtube' */
+  profile?: string;
+  /** narration auto-mix toggle (mirrors render); default auto */
+  narration?: 'auto' | 'off';
+  music?: 'auto' | 'off';
+  sfx?: 'auto' | 'off';
+  /**
+   * locale code (0.15 FIX 2). When set, measure the per-locale mix (the localized
+   * narration sibling) and commit `<stem>.<locale>.loudness.json` instead of the
+   * base file. Mirrors `gs render --locale`, so the measured content matches what
+   * a localized render mixes.
+   */
+  locale?: string;
+}
+interface MeasureLoudnessResult {
+  measurement: LoudnessMeasurement;
+  loudnessPath: string;
+  /** profile the measurement was taken against */
+  profile: PublishProfile;
+  /** true when the peak clamp bound the gain (advisory: would need a brickwall limiter on an un-normalized profile) */
+  clampBound: boolean;
+  /** an advisory warning string when an un-normalized profile can't reach its target without clipping; else null */
+  warning: string | null;
+}
+/**
+ * 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.
+ */
+declare function measureLoudnessCommand(opts: MeasureLoudnessOptions): Promise<MeasureLoudnessResult>;
+//#endregion
+//#region src/master.d.ts
+declare class MasterError extends Error {
+  constructor(message: string);
+}
+/** How much gain-reduction the limiter may apply to buy headroom (dB). */
+declare const DEFAULT_MAX_GR_DB = 6;
+/** The limiter spec (from `glissade.master.json`). */
+interface MasterLimiter {
+  /** true-peak brickwall (the only mode today). */
+  readonly mode: 'truepeak';
+  /** the true-peak ceiling, dBTP (defaults to the profile's `truePeakDb`). */
+  readonly ceilingDb?: number;
+  /** limiter lookahead, ms (advisory — maps to the ffmpeg attack window). */
+  readonly lookaheadMs?: number;
+  /** max gain-reduction the limiter may apply (dB); beyond this a member can't
+   *  reach the target cleanly and the shared target drops. Default 6. */
+  readonly maxGrDb?: number;
+}
+/** `glissade.master.json`. */
+interface MasterConfig {
+  /** publish profile id (youtube/shorts/podcast/broadcast/ebu). */
+  readonly profile?: string;
+  /** member scene globs (like `gs build`'s `scenes`). */
+  readonly members: readonly string[];
+  /** the limiter (or `false` to keep the legacy peak-clamp behaviour). */
+  readonly limiter?: MasterLimiter | false;
+  /** `shared-target` (all members hit one LUFS) or `per-asset` (each hits its own max). */
+  readonly consistency?: 'shared-target' | 'per-asset';
+}
+/** One member's measured input loudness (from the ffmpeg measure pass). */
+interface MemberMeasure {
+  readonly id: string;
+  /** integrated loudness, LUFS. */
+  readonly inputI: number;
+  /** true peak, dBTP. */
+  readonly inputTp: number;
+}
+/** The plan for one member: its target + the gain to apply + predicted limiting. */
+interface MemberPlan extends MemberMeasure {
+  /** the output LUFS this member is driven to. */
+  readonly target: number;
+  /** the gain to apply before the limiter, dB. */
+  readonly gain: number;
+  /** predicted limiter gain-reduction, dB (0 when the raw peak clears the ceiling). */
+  readonly grDb: number;
+  /** predicted output true peak, dBTP (== ceiling when the limiter engages). */
+  readonly predOutTp: number;
+  /** true when this member reaches the shared target within the GR budget. */
+  readonly reachable: boolean;
+}
+interface MasterPlan {
+  /** the LUFS target the set is normalized to (shared-target) or the profile cap. */
+  readonly sharedTarget: number;
+  readonly profileTarget: number;
+  readonly ceilingDb: number;
+  /** true when a limiter is in play (false = legacy peak-clamp). */
+  readonly limiter: boolean;
+  readonly maxGrDb: number;
+  readonly members: readonly MemberPlan[];
+}
+/**
+ * Plan a master pass. Pure: measured members → shared target + per-member gains.
+ *
+ * - With a limiter, a member reaches `target` by applying `gain = target - inputI`
+ *   and the limiter shaves any overshoot (`grDb`) down to the ceiling.
+ * - Without a limiter (`limiter: null`), the gain is peak-CLAMPED (the legacy
+ *   `min(target-inputI, ceiling-inputTp)`), so a peaky member lands below target.
+ * - `shared-target` normalizes every member to one LUFS (the loudest all reach);
+ *   `per-asset` drives each to its own max.
+ */
+declare function planMaster(measures: readonly MemberMeasure[], profile: PublishProfile, opts: {
+  limiter: MasterLimiter | null;
+  consistency: 'shared-target' | 'per-asset';
+}): MasterPlan;
+/**
+ * The `-af` chain that applies a master's gain + (optional) TRUE-peak limiter to a
+ * WAV — the SAME {@link loudnessFilterNodes} the render `filter_complex` applies,
+ * so the `gs master` verify pass measures exactly what a render will produce.
+ */
+declare function masterAfChain(gainDb: number, limiter: CommittedLimiter | null): Promise<string>;
+interface MasterMemberResult {
+  readonly id: string;
+  readonly loudnessPath: string;
+  readonly measurement: LoudnessMeasurement;
+  /** measured input LUFS / dBTP. */
+  readonly inputI: number;
+  readonly inputTp: number;
+  /** VERIFIED output LUFS / dBTP (re-measured after gain+limiter). */
+  readonly outI: number;
+  readonly outTp: number;
+  readonly gain: number;
+  readonly grDb: number;
+  /** true when the verified output true-peak exceeded the ceiling (shouldn't happen). */
+  readonly overCeiling: boolean;
+}
+interface MasterResult {
+  readonly sharedTarget: number;
+  readonly ceilingDb: number;
+  readonly limiter: boolean;
+  readonly members: readonly MasterMemberResult[];
+  readonly report: string;
+}
+interface MasterCommandOptions {
+  configPath: string;
+  onLog?: (line: string) => void;
+}
+/**
+ * `gs master <glissade.master.json>` — measure every member, plan the shared
+ * target + limiter, apply+VERIFY per member, and commit `<scene>.loudness.json`
+ * ×N. Reuses `buildMixWav`/`measureFile` (measure) and `resolveScenes` (globs);
+ * writes the existing sidecar shape + the `limiter` block so render composes it as
+ * a mix-only remux under the mixHash preflight.
+ */
+declare function masterCommand(opts: MasterCommandOptions): Promise<MasterResult>;
+/** The shared-target loudness options a master pass needs, minus the member list. */
+interface MasterRunOptions {
+  profile?: string;
+  limiter?: MasterLimiter | false | null;
+  consistency?: 'shared-target' | 'per-asset';
+}
+/**
+ * The master core, callable with ALREADY-RESOLVED member paths + options — so both
+ * `gs master <glissade.master.json>` and the 0.43 project runtime's shared-master
+ * phase drive it (the runtime passes the project's scenes as members directly, no
+ * temp config file). Measures every member's mix, plans one shared target, and
+ * commits `<scene>.loudness.json` ×N with the limiter block (render applies it as a
+ * mix-only remux under the mixHash preflight).
+ */
+
+/** Validate + normalize a parsed `glissade.master.json` (fail-loud). */
+declare function normalizeMasterConfig(raw: unknown): Required<Pick<MasterConfig, 'members' | 'consistency'>> & {
+  profile: string;
+  limiter: MasterLimiter | null;
+};
+//#endregion
+export { peakClampBinds as A, PublishProfile as C, measureFile as D, loudnessPathFor as E, resolveProfile as M, measureLoudnessCommand as O, PUBLISH_PROFILES as S, computeMixHash as T, LOUDNESS_SCHEMA_VERSION as _, MasterMemberResult as a, MeasureLoudnessOptions as b, MasterRunOptions as c, masterAfChain as d, masterCommand as f, DEFAULT_PROFILE_ID as g, CommittedLimiter as h, MasterLimiter as i, readLoudness as j, parseLoudnormJson as k, MemberMeasure as l, planMaster as m, MasterConfig as n, MasterPlan as o, normalizeMasterConfig as p, MasterError as r, MasterResult as s, DEFAULT_MAX_GR_DB as t, MemberPlan as u, LoudnessError as v, computeGainDb as w, MeasureLoudnessResult as x, LoudnessMeasurement as y };

package/dist/master.js

@@ -30,7 +30,8 @@ var master_exports = /* @__PURE__ */ __exportAll({
 	masterAfChain: () => masterAfChain,
 	masterCommand: () => masterCommand,
 	normalizeMasterConfig: () => normalizeMasterConfig,
-	planMaster: () => planMaster
+	planMaster: () => planMaster,
+	runMaster: () => runMaster
 });
 var MasterError = class extends Error {
 	constructor(message) {
@@ -109,14 +110,32 @@ async function masterAfChain(gainDb, limiter) {
 */
 async function masterCommand(opts) {
 	const cfg = normalizeMasterConfig(JSON.parse(readFileSync(opts.configPath, "utf8")));
-	const profile = resolveProfile(cfg.profile);
-	const log = opts.onLog ?? (() => {});
 	const { resolveScenes } = await import("./build.js").then((n) => n.t);
-	const { buildMixWav, collectMixAudioInputs } = await import("./render.js").then((n) => n.p);
 	const members = resolveScenes(cfg.members, process.cwd());
 	if (members.length === 0) throw new MasterError(`master: no scenes matched members ${JSON.stringify(cfg.members)}`);
-	const ceilingDb = cfg.limiter?.ceilingDb ?? profile.truePeakDb;
-	const committedLimiter = cfg.limiter ? {
+	return runMaster(members, {
+		profile: cfg.profile,
+		limiter: cfg.limiter,
+		consistency: cfg.consistency
+	}, opts.onLog);
+}
+/**
+* The master core, callable with ALREADY-RESOLVED member paths + options — so both
+* `gs master <glissade.master.json>` and the 0.43 project runtime's shared-master
+* phase drive it (the runtime passes the project's scenes as members directly, no
+* temp config file). Measures every member's mix, plans one shared target, and
+* commits `<scene>.loudness.json` ×N with the limiter block (render applies it as a
+* mix-only remux under the mixHash preflight).
+*/
+async function runMaster(members, opts = {}, onLog) {
+	const profile = resolveProfile(opts.profile ?? "youtube");
+	const consistency = opts.consistency ?? "shared-target";
+	const limiter = opts.limiter || null;
+	const log = onLog ?? (() => {});
+	const { buildMixWav, collectMixAudioInputs } = await import("./render.js").then((n) => n.p);
+	if (members.length === 0) throw new MasterError("master: no members to master");
+	const ceilingDb = limiter?.ceilingDb ?? profile.truePeakDb;
+	const committedLimiter = limiter ? {
 		mode: "truepeak",
 		ceilingDb
 	} : null;
@@ -148,8 +167,8 @@ async function masterCommand(opts) {
 			inputI: m.inputI,
 			inputTp: m.inputTp
 		})), profile, {
-			limiter: cfg.limiter,
-			consistency: cfg.consistency
+			limiter,
+			consistency
 		});
 		log(`shared target ${plan.sharedTarget} LUFS, ceiling ${ceilingDb} dBTP${plan.limiter ? "" : " (no limiter — legacy peak-clamp)"}`);
 		const results = [];

package/package.json

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