reframe-video 0.6.26 → 0.6.27

package/dist/cli.js

@@ -6,6 +6,30 @@ import { tmpdir as tmpdir6 } from "node:os";
 import { basename, dirname as dirname7, join as join9, resolve as resolve6 } from "node:path";
 
 // ../core/src/ir.ts
+var SFX_NAMES = [
+  "whoosh",
+  "swish",
+  "rise",
+  "riser",
+  "warp",
+  "tick",
+  "click",
+  "blip",
+  "pop",
+  "select",
+  "thud",
+  "boom",
+  "knock",
+  "chime",
+  "ding",
+  "coin",
+  "sparkle",
+  "shimmer",
+  "success",
+  "zap",
+  "error"
+];
+var BGM_SYNTHS = ["ambient-pad", "lofi", "pulse", "tension", "uplift"];
 var DEFAULT_CROSSFADE = 0.5;
 var DEFAULT_TO_DURATION = 0.5;
 var DEFAULT_TWEEN_DURATION = 0.5;
@@ -656,7 +680,6 @@ function validateScene(ir) {
       }
     }
   }
-  const SFX_NAMES = ["whoosh", "pop", "tick", "rise", "shimmer", "thud"];
   for (const [i, cue] of (ir.audio?.cues ?? []).entries()) {
     if (typeof cue.at === "string" && !labels.has(cue.at)) {
       problems.push(
@@ -692,6 +715,10 @@ function validateScene(ir) {
   if (ir.audio?.bgm?.file !== void 0 && ir.audio.bgm.synth !== void 0) {
     problems.push('audio.bgm: use either "file" or "synth", not both');
   }
+  const bgmSynth = ir.audio?.bgm?.synth;
+  if (bgmSynth !== void 0 && !BGM_SYNTHS.includes(bgmSynth)) {
+    problems.push(`audio.bgm.synth: unknown synth "${bgmSynth}" \u2014 valid: ${BGM_SYNTHS.join(", ")}`);
+  }
   if (problems.length > 0) throw new SceneValidationError(problems);
 }
 var TRANSITIONS = ["cut", "crossfade"];
@@ -991,12 +1018,32 @@ var SET = 1 / 120;
 
 // ../core/src/audio.ts
 var SFX_DURATION = {
+  // transition
   whoosh: 0.35,
-  pop: 0.12,
-  tick: 0.03,
+  swish: 0.32,
   rise: 0.5,
+  riser: 0.85,
+  warp: 0.5,
+  // ui
+  tick: 0.03,
+  click: 0.05,
+  blip: 0.1,
+  pop: 0.12,
+  select: 0.18,
+  // impact
+  thud: 0.25,
+  boom: 0.6,
+  knock: 0.14,
+  // positive
+  chime: 0.7,
+  ding: 0.5,
+  coin: 0.3,
+  sparkle: 0.6,
   shimmer: 0.9,
-  thud: 0.25
+  success: 0.6,
+  // alert
+  zap: 0.22,
+  error: 0.4
 };
 var FILE_CUE_DURATION = 0.4;
 function collectClipAudio(ir, duration, warnings) {
@@ -1056,7 +1103,11 @@ function resolveAudioPlan(compiled) {
       fadeIn: cue.fadeIn ?? 0,
       fadeOut: cue.fadeOut ?? 0,
       pan: cue.pan ?? 0,
-      source: cue.sfx ? { kind: "sfx", name: cue.sfx, params: cue.params ?? {} } : { kind: "file", path: cue.file }
+      source: cue.sfx ? (
+        // auto-vary: default the seed to the cue's order so repeated sfx differ
+        // (pitch/texture); an explicit params.seed always wins.
+        { kind: "sfx", name: cue.sfx, params: { seed: index, ...cue.params } }
+      ) : { kind: "file", path: cue.file }
     });
   }
   cues.sort((a, b) => a.t - b.t);
@@ -1136,7 +1187,11 @@ function resolveCompositionAudioPlan(comp) {
       fadeIn: cue.fadeIn ?? 0,
       fadeOut: cue.fadeOut ?? 0,
       pan: cue.pan ?? 0,
-      source: cue.sfx ? { kind: "sfx", name: cue.sfx, params: cue.params ?? {} } : { kind: "file", path: cue.file }
+      source: cue.sfx ? (
+        // auto-vary: default the seed to the cue's order so repeated sfx differ
+        // (pitch/texture); an explicit params.seed always wins.
+        { kind: "sfx", name: cue.sfx, params: { seed: index, ...cue.params } }
+      ) : { kind: "file", path: cue.file }
     });
   }
   if (!audio?.bgm && cues.length === 0 && clipAudio.length === 0) return null;
@@ -1240,19 +1295,23 @@ function hash01(n, seed) {
 var noise = (n, seed) => hash01(n, seed) * 2 - 1;
 var TAU = Math.PI * 2;
 var expDecay = (t, dur, k = 5) => Math.exp(-k * t / dur);
+var square = (ph) => (Math.sin(ph) + 0.33 * Math.sin(3 * ph) + 0.2 * Math.sin(5 * ph)) / 1.4;
+var PITCH_STEPS = [0, 2, 4, 7, 9, 12, 5, -3, 16, -5];
+function seedPitch(seed) {
+  const i = (Math.round(seed) % PITCH_STEPS.length + PITCH_STEPS.length) % PITCH_STEPS.length;
+  return Math.pow(2, PITCH_STEPS[i] / 12);
+}
 function buffer(duration) {
   const n = Math.round(duration * SAMPLE_RATE);
   return { out: new Float32Array(n), n };
 }
-function whoosh(seed) {
+function whoosh(seed, pitch) {
   const dur = 0.35;
   const { out, n } = buffer(dur);
-  let lp = 0;
-  let lp2 = 0;
+  let lp = 0, lp2 = 0;
   for (let i = 0; i < n; i++) {
-    const t = i / SAMPLE_RATE;
-    const u = t / dur;
-    const center = 1200 * Math.pow(300 / 1200, u);
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const center = 1200 * pitch * Math.pow(0.25, u);
     const alpha = Math.min(1, TAU * center / SAMPLE_RATE);
     lp += alpha * (noise(i, seed) - lp);
     lp2 += alpha * 0.5 * (lp - lp2);
@@ -1261,110 +1320,392 @@ function whoosh(seed) {
   }
   return out;
 }
-function pop(seed) {
+function swish(seed, pitch) {
+  const dur = 0.32;
+  const { out, n } = buffer(dur);
+  let lp = 0, lp2 = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const center = 2600 * pitch * Math.pow(0.2, u);
+    const alpha = Math.min(1, TAU * center / SAMPLE_RATE);
+    lp += alpha * (noise(i, seed) - lp);
+    lp2 += alpha * 0.5 * (lp - lp2);
+    const env = u < 0.15 ? u / 0.15 : expDecay(t - 0.15 * dur, dur * 0.85, 5);
+    out[i] = (lp - lp2) * env * 2.4;
+  }
+  return out;
+}
+function rise(_seed, pitch) {
+  const dur = 0.5;
+  const { out, n } = buffer(dur);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const freq = 220 * pitch * Math.pow(4, u);
+    phase += TAU * freq / SAMPLE_RATE;
+    const env = Math.sin(Math.PI * Math.min(1, u * 1.05)) ** 1.5;
+    out[i] = (Math.sin(phase) + 0.3 * Math.sin(2 * phase)) * env * 0.45;
+  }
+  return out;
+}
+function riser(seed, pitch) {
+  const dur = 0.85;
+  const { out, n } = buffer(dur);
+  let lp = 0, phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const center = 200 * pitch * Math.pow(12, u);
+    const alpha = Math.min(1, TAU * center / SAMPLE_RATE);
+    lp += alpha * (noise(i, seed) - lp);
+    const freq = 120 * pitch * Math.pow(6, u);
+    phase += TAU * freq / SAMPLE_RATE;
+    const env = Math.pow(u, 1.6);
+    out[i] = (lp * 1.6 + Math.sin(phase) * 0.5) * env * 0.9;
+  }
+  return out;
+}
+function warp(_seed, pitch) {
+  const dur = 0.5;
+  const { out, n } = buffer(dur);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const bend = Math.sin(Math.PI * u);
+    const vib = 1 + 0.4 * Math.sin(TAU * 18 * t);
+    const freq = 300 * pitch * (1 + 2.5 * bend) * vib;
+    phase += TAU * freq / SAMPLE_RATE;
+    const env = Math.sin(Math.PI * u) ** 0.8;
+    out[i] = square(phase) * env * 0.5;
+  }
+  return out;
+}
+function tick(seed, pitch) {
+  const dur = 0.03;
+  const { out, n } = buffer(dur);
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    const sine = t < 4e-3 ? Math.sin(TAU * 4e3 * pitch * t) : 0;
+    out[i] = (sine * 0.6 + noise(i, seed) * 0.35) * expDecay(t, dur, 8);
+  }
+  return out;
+}
+function click(seed, pitch) {
+  const dur = 0.05;
+  const { out, n } = buffer(dur);
+  let lp = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    lp += 0.5 * (noise(i, seed) - lp);
+    const sine = Math.sin(TAU * 1500 * pitch * t);
+    out[i] = (sine * 0.5 + lp * 0.6) * expDecay(t, dur, 11);
+  }
+  return out;
+}
+function blip(_seed, pitch) {
+  const dur = 0.1;
+  const { out, n } = buffer(dur);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    phase += TAU * 880 * pitch / SAMPLE_RATE;
+    const env = Math.min(1, u * 12) * Math.min(1, (1 - u) * 6);
+    out[i] = square(phase) * env * 0.5;
+  }
+  return out;
+}
+function pop(seed, pitch) {
   const dur = 0.12;
   const { out, n } = buffer(dur);
   let phase = 0;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const freq = 600 * Math.pow(150 / 600, t / 0.08);
+    const freq = 600 * pitch * Math.pow(0.25, t / 0.08);
     phase += TAU * freq / SAMPLE_RATE;
     const transient = t < 2e-3 ? noise(i, seed) * 0.5 : 0;
     out[i] = (Math.sin(phase) + transient) * expDecay(t, dur, 6) * 0.8;
   }
   return out;
 }
-function tick(seed) {
-  const dur = 0.03;
+function select(_seed, pitch) {
+  const dur = 0.18;
+  const { out, n } = buffer(dur);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const freq = (t < 0.08 ? 620 : 930) * pitch;
+    phase += TAU * freq / SAMPLE_RATE;
+    const env = Math.min(1, u * 16) * Math.min(1, (1 - u) * 5);
+    out[i] = (Math.sin(phase) + 0.25 * Math.sin(2 * phase)) * env * 0.5;
+  }
+  return out;
+}
+function thud(seed, pitch) {
+  const dur = 0.25;
   const { out, n } = buffer(dur);
+  let phase = 0, lp = 0;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const sine = t < 4e-3 ? Math.sin(TAU * 4e3 * t) : 0;
-    out[i] = (sine * 0.6 + noise(i, seed) * 0.35) * expDecay(t, dur, 8);
+    const freq = 90 * pitch * Math.pow(0.5, t / 0.15);
+    phase += TAU * freq / SAMPLE_RATE;
+    lp += 0.02 * (noise(i, seed) - lp);
+    const attack = t < 0.01 ? lp * 3 : 0;
+    out[i] = (Math.sin(phase) * 0.9 + attack) * expDecay(t, dur, 5);
   }
   return out;
 }
-function rise(seed) {
+function boom(seed, pitch) {
+  const dur = 0.6;
+  const { out, n } = buffer(dur);
+  let phase = 0, lp = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    const freq = 70 * pitch * Math.pow(0.5, t / 0.3);
+    phase += TAU * freq / SAMPLE_RATE;
+    lp += 0.06 * (noise(i, seed) - lp);
+    const body = t < 0.06 ? lp * 2.5 * (1 - t / 0.06) : 0;
+    out[i] = (Math.sin(phase) * 1 + body) * expDecay(t, dur, 3.2);
+  }
+  return out;
+}
+function knock(seed, pitch) {
+  const dur = 0.14;
+  const { out, n } = buffer(dur);
+  let phase = 0, lp = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    const freq = 220 * pitch * Math.pow(0.7, t / 0.05);
+    phase += TAU * freq / SAMPLE_RATE;
+    lp += 0.3 * (noise(i, seed) - lp);
+    const tap = t < 5e-3 ? lp : 0;
+    out[i] = (Math.sin(phase) * 0.8 + tap * 0.6) * expDecay(t, dur, 9);
+  }
+  return out;
+}
+function chime(seed, pitch) {
+  const dur = 0.7;
+  const { out, n } = buffer(dur);
+  const f0 = 800 * pitch;
+  const partials = [
+    { f: f0, a: 1, k: 4 },
+    { f: f0 * 2.76, a: 0.5, k: 5.5 },
+    { f: f0 * 5.4, a: 0.28, k: 7 },
+    { f: f0 * 8.9, a: 0.13, k: 9 }
+  ];
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    let s = 0;
+    for (const p of partials) s += Math.sin(TAU * p.f * t) * p.a * expDecay(t, dur, p.k);
+    const strike = t < 3e-3 ? noise(i, seed) * 0.3 : 0;
+    out[i] = (s / 1.9 + strike) * 0.6;
+  }
+  return out;
+}
+function ding(_seed, pitch) {
   const dur = 0.5;
   const { out, n } = buffer(dur);
-  let phase = 0;
+  const f0 = 1200 * pitch;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const u = t / dur;
-    const freq = 220 * Math.pow(880 / 220, u);
+    const s = Math.sin(TAU * f0 * t) + 0.4 * Math.sin(TAU * f0 * 2 * t) + 0.2 * Math.sin(TAU * f0 * 3.01 * t);
+    out[i] = s / 1.6 * expDecay(t, dur, 4.5) * 0.6;
+  }
+  return out;
+}
+function coin(_seed, pitch) {
+  const dur = 0.3;
+  const { out, n } = buffer(dur);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const freq = (t < 0.06 ? 988 : 1319) * pitch;
     phase += TAU * freq / SAMPLE_RATE;
-    const env = Math.sin(Math.PI * Math.min(1, u * 1.05)) ** 1.5;
-    out[i] = (Math.sin(phase) + 0.3 * Math.sin(2 * phase)) * env * 0.45;
+    const env = Math.min(1, u * 30) * expDecay(Math.max(0, t - 0.06), dur, 3.5);
+    out[i] = square(phase) * env * 0.55;
+  }
+  return out;
+}
+function sparkle(seed, pitch) {
+  const dur = 0.6;
+  const { out, n } = buffer(dur);
+  const steps = [1, 1.5, 2, 3, 4, 5, 6];
+  const base = 1200 * pitch;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    let s = 0;
+    for (let g = 0; g < steps.length; g++) {
+      const on = u * steps.length - g;
+      if (on > 0 && on < 3) {
+        const ge = Math.exp(-on * 1.8);
+        s += Math.sin(TAU * base * steps[g] * t + hash01(g, seed) * TAU) * ge;
+      }
+    }
+    out[i] = s / 2.4 * Math.sin(Math.PI * u) ** 0.5 * 0.5;
+  }
+  return out;
+}
+function success(_seed, pitch) {
+  const dur = 0.6;
+  const { out, n } = buffer(dur);
+  const notes = [523.25, 659.25, 783.99].map((f) => f * pitch);
+  let phase = 0, cur = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const idx = Math.min(notes.length - 1, Math.floor(u * 3.2));
+    if (idx !== cur) cur = idx;
+    phase += TAU * notes[cur] / SAMPLE_RATE;
+    const local = u * 3.2 - idx;
+    const env = Math.min(1, local * 12) * Math.min(1, (1 - Math.min(1, local)) * 4 + 0.2);
+    out[i] = (Math.sin(phase) + 0.3 * Math.sin(2 * phase)) * env * 0.42;
   }
   return out;
 }
-function shimmer(seed) {
+function shimmer(seed, pitch) {
   const dur = 0.9;
   const { out, n } = buffer(dur);
   const partials = Array.from({ length: 5 }, (_, p) => ({
-    freq: 2e3 + hash01(p, seed + 7) * 2e3,
+    freq: (2e3 + hash01(p, seed + 7) * 2e3) * pitch,
     am: 0.5 + hash01(p, seed + 8) * 1.5,
     phase: hash01(p, seed + 9) * TAU
   }));
   for (let i = 0; i < n; i++) {
-    const t = i / SAMPLE_RATE;
-    const u = t / dur;
+    const t = i / SAMPLE_RATE, u = t / dur;
     const env = Math.sin(Math.PI * u) ** 1.2;
     let s = 0;
-    for (const part of partials) {
-      s += Math.sin(TAU * part.freq * t + part.phase) * (0.6 + 0.4 * Math.sin(TAU * part.am * t));
-    }
+    for (const part of partials) s += Math.sin(TAU * part.freq * t + part.phase) * (0.6 + 0.4 * Math.sin(TAU * part.am * t));
     out[i] = s / 5 * env * 0.5;
   }
   return out;
 }
-function thud(seed) {
-  const dur = 0.25;
+function zap(seed, pitch) {
+  const dur = 0.22;
   const { out, n } = buffer(dur);
   let phase = 0;
-  let lp = 0;
   for (let i = 0; i < n; i++) {
-    const t = i / SAMPLE_RATE;
-    const freq = 90 * Math.pow(45 / 90, t / 0.15);
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const freq = 1600 * pitch * Math.pow(0.12, u);
     phase += TAU * freq / SAMPLE_RATE;
-    lp += 0.02 * (noise(i, seed) - lp);
-    const attack = t < 0.01 ? lp * 3 : 0;
-    out[i] = (Math.sin(phase) * 0.9 + attack) * expDecay(t, dur, 5);
+    const grit = noise(i, seed) * 0.25;
+    out[i] = (square(phase) + grit) * expDecay(t, dur, 4.5) * 0.5;
+  }
+  return out;
+}
+function error(_seed, pitch) {
+  const dur = 0.4;
+  const { out, n } = buffer(dur);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const freq = (t < 0.16 ? 311 : 233) * pitch;
+    phase += TAU * freq / SAMPLE_RATE;
+    const seg = t < 0.16 ? u / 0.4 : (u - 0.4) / 0.6;
+    const env = Math.min(1, seg * 18) * Math.min(1, (1 - seg) * 6);
+    out[i] = square(phase) * env * 0.5;
   }
   return out;
 }
 var RECIPES = {
   whoosh,
-  pop,
-  tick,
+  swish,
   rise,
+  riser,
+  warp,
+  tick,
+  click,
+  blip,
+  pop,
+  select,
+  thud,
+  boom,
+  knock,
+  chime,
+  ding,
+  coin,
+  sparkle,
   shimmer,
-  thud
+  success,
+  zap,
+  error
 };
 function synthSfx(name, params = {}) {
-  const samples = RECIPES[name](params.seed ?? 0);
+  const seed = params.seed ?? 0;
+  const pitch = (params.pitch ?? 1) * seedPitch(seed);
+  const samples = RECIPES[name](seed, pitch);
   if (params.gainDb) {
     const g = Math.pow(10, params.gainDb / 20);
     for (let i = 0; i < samples.length; i++) samples[i] *= g;
   }
+  let peak = 0;
+  for (let i = 0; i < samples.length; i++) peak = Math.max(peak, Math.abs(samples[i]));
+  if (peak > 0.95) {
+    const g = 0.95 / peak;
+    for (let i = 0; i < samples.length; i++) samples[i] *= g;
+  }
   return samples;
 }
-function synthAmbientPad(duration, seed = 0) {
+function pad(freqs, duration, seed, opts) {
   const { out, n } = buffer(duration);
-  const voices = [110, 165, 220].flatMap((f, v) => [
-    { freq: f * (1 + (hash01(v, seed + 3) - 0.5) * 4e-3), am: 0.05 + hash01(v, seed + 4) * 0.08, phase: hash01(v, seed + 5) * TAU },
-    { freq: f * (1 - (hash01(v, seed + 6) - 0.5) * 4e-3), am: 0.05 + hash01(v, seed + 7) * 0.08, phase: hash01(v, seed + 8) * TAU }
+  const voices = freqs.flatMap((f, v) => [
+    { freq: f * (1 + (hash01(v, seed + 3) - 0.5) * 4e-3), am: opts.amBase + hash01(v, seed + 4) * 0.08, phase: hash01(v, seed + 5) * TAU },
+    { freq: f * (1 - (hash01(v, seed + 6) - 0.5) * 4e-3), am: opts.amBase + hash01(v, seed + 7) * 0.08, phase: hash01(v, seed + 8) * TAU }
   ]);
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
     let s = 0;
     for (const voice of voices) {
       s += Math.sin(TAU * voice.freq * t + voice.phase) * (0.75 + 0.25 * Math.sin(TAU * voice.am * t));
+      if (opts.bright > 0) s += opts.bright * Math.sin(TAU * voice.freq * 2 * t + voice.phase);
     }
-    out[i] = s / voices.length * 0.7;
+    out[i] = s / voices.length * opts.gain;
   }
   return out;
 }
+function synthAmbientPad(duration, seed = 0) {
+  return pad([110, 165, 220], duration, seed, { amBase: 0.05, bright: 0, gain: 0.7 });
+}
+function synthLofi(duration, seed = 0) {
+  return pad([130.81, 164.81, 196, 246.94], duration, seed, { amBase: 0.04, bright: 0.04, gain: 0.62 });
+}
+function synthPulse(duration, _seed = 0) {
+  const { out, n } = buffer(duration);
+  const beat2 = 2.2;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    const ph = t * beat2 % 1;
+    const gate = Math.exp(-ph * 5) * 0.9 + 0.1;
+    const s = Math.sin(TAU * 82 * t) + 0.6 * Math.sin(TAU * 123 * t) + 0.3 * Math.sin(TAU * 246 * t);
+    out[i] = s / 1.9 * gate * 0.6;
+  }
+  return out;
+}
+function synthTension(duration, seed = 0) {
+  const { out, n } = buffer(duration);
+  const base = [98, 104, 110];
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    const drift = 1 + 0.03 * (t / Math.max(1e-3, duration));
+    let s = 0;
+    for (let v = 0; v < base.length; v++) {
+      const f = base[v] * drift * (1 + (hash01(v, seed) - 0.5) * 6e-3);
+      s += Math.sin(TAU * f * t + hash01(v, seed + 1) * TAU);
+    }
+    const swell = 0.6 + 0.4 * Math.sin(TAU * 0.08 * t);
+    out[i] = s / base.length * swell * 0.6;
+  }
+  return out;
+}
+function synthUplift(duration, seed = 0) {
+  return pad([196, 246.94, 293.66, 392], duration, seed, { amBase: 0.07, bright: 0.1, gain: 0.6 });
+}
+var BGM_RECIPES = {
+  "ambient-pad": synthAmbientPad,
+  lofi: synthLofi,
+  pulse: synthPulse,
+  tension: synthTension,
+  uplift: synthUplift
+};
+function synthBgm(name, duration, seed = 0) {
+  return BGM_RECIPES[name](duration, seed);
+}
 
 // ../render-cli/src/audio/sfx.ts
 var ROOT = true ? resolve(dirname(fileURLToPath(import.meta.url)), "..") : resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "..");
@@ -1414,7 +1755,7 @@ async function resolveBgmFile(source, duration, sceneDir) {
     }
     throw new Error(`bgm file "${p}" not found`);
   }
-  return writeCached(`ambient-pad-${duration.toFixed(2)}`, () => synthAmbientPad(duration));
+  return writeCached(`${source.name}-${duration.toFixed(2)}`, () => synthBgm(source.name, duration));
 }
 
 // ../render-cli/src/audio/clip.ts

package/dist/compile-api.js

@@ -4,6 +4,32 @@ import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// ../core/src/ir.ts
+var SFX_NAMES = [
+  "whoosh",
+  "swish",
+  "rise",
+  "riser",
+  "warp",
+  "tick",
+  "click",
+  "blip",
+  "pop",
+  "select",
+  "thud",
+  "boom",
+  "knock",
+  "chime",
+  "ding",
+  "coin",
+  "sparkle",
+  "shimmer",
+  "success",
+  "zap",
+  "error"
+];
+var BGM_SYNTHS = ["ambient-pad", "lofi", "pulse", "tension", "uplift"];
+
 // ../core/src/interpolate.ts
 var BACK_C1 = 1.70158;
 var BACK_C2 = BACK_C1 * 1.525;
@@ -329,7 +355,6 @@ function validateScene(ir) {
       }
     }
   }
-  const SFX_NAMES = ["whoosh", "pop", "tick", "rise", "shimmer", "thud"];
   for (const [i, cue] of (ir.audio?.cues ?? []).entries()) {
     if (typeof cue.at === "string" && !labels.has(cue.at)) {
       problems.push(
@@ -365,6 +390,10 @@ function validateScene(ir) {
   if (ir.audio?.bgm?.file !== void 0 && ir.audio.bgm.synth !== void 0) {
     problems.push('audio.bgm: use either "file" or "synth", not both');
   }
+  const bgmSynth = ir.audio?.bgm?.synth;
+  if (bgmSynth !== void 0 && !BGM_SYNTHS.includes(bgmSynth)) {
+    problems.push(`audio.bgm.synth: unknown synth "${bgmSynth}" \u2014 valid: ${BGM_SYNTHS.join(", ")}`);
+  }
   if (problems.length > 0) throw new SceneValidationError(problems);
 }
 var TRANSITIONS = ["cut", "crossfade"];

package/dist/compile.js

@@ -9,6 +9,32 @@ import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+// ../core/src/ir.ts
+var SFX_NAMES = [
+  "whoosh",
+  "swish",
+  "rise",
+  "riser",
+  "warp",
+  "tick",
+  "click",
+  "blip",
+  "pop",
+  "select",
+  "thud",
+  "boom",
+  "knock",
+  "chime",
+  "ding",
+  "coin",
+  "sparkle",
+  "shimmer",
+  "success",
+  "zap",
+  "error"
+];
+var BGM_SYNTHS = ["ambient-pad", "lofi", "pulse", "tension", "uplift"];
+
 // ../core/src/interpolate.ts
 var BACK_C1 = 1.70158;
 var BACK_C2 = BACK_C1 * 1.525;
@@ -334,7 +360,6 @@ function validateScene(ir) {
       }
     }
   }
-  const SFX_NAMES = ["whoosh", "pop", "tick", "rise", "shimmer", "thud"];
   for (const [i, cue] of (ir.audio?.cues ?? []).entries()) {
     if (typeof cue.at === "string" && !labels.has(cue.at)) {
       problems.push(
@@ -370,6 +395,10 @@ function validateScene(ir) {
   if (ir.audio?.bgm?.file !== void 0 && ir.audio.bgm.synth !== void 0) {
     problems.push('audio.bgm: use either "file" or "synth", not both');
   }
+  const bgmSynth = ir.audio?.bgm?.synth;
+  if (bgmSynth !== void 0 && !BGM_SYNTHS.includes(bgmSynth)) {
+    problems.push(`audio.bgm.synth: unknown synth "${bgmSynth}" \u2014 valid: ${BGM_SYNTHS.join(", ")}`);
+  }
   if (problems.length > 0) throw new SceneValidationError(problems);
 }