reframe-video 0.6.26 → 0.6.28

package/dist/cli.js

@@ -6,6 +6,42 @@ 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",
+  "swoosh",
+  "rise",
+  "riser",
+  "warp",
+  "tick",
+  "click",
+  "blip",
+  "pop",
+  "select",
+  "thud",
+  "boom",
+  "knock",
+  "sub",
+  "chime",
+  "ding",
+  "coin",
+  "sparkle",
+  "shimmer",
+  "success",
+  "zap",
+  "error",
+  "glitch",
+  "static",
+  "scan",
+  "powerup",
+  "powerdown",
+  "snare",
+  "hat",
+  "bubble",
+  "notify",
+  "camera"
+];
+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 +692,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 +727,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 +1030,46 @@ var SET = 1 / 120;
 
 // ../core/src/audio.ts
 var SFX_DURATION = {
+  // transition
   whoosh: 0.35,
-  pop: 0.12,
-  tick: 0.03,
+  swish: 0.32,
+  swoosh: 0.35,
   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,
+  sub: 0.7,
+  // 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,
+  // tech
+  glitch: 0.3,
+  static: 0.18,
+  scan: 0.45,
+  powerup: 0.4,
+  powerdown: 0.5,
+  // rhythm / foley
+  snare: 0.18,
+  hat: 0.05,
+  bubble: 0.16,
+  notify: 0.45,
+  camera: 0.18
 };
 var FILE_CUE_DURATION = 0.4;
 function collectClipAudio(ir, duration, warnings) {
@@ -1056,7 +1129,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 +1213,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 +1321,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 +1346,568 @@ 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 shimmer(seed) {
+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, 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;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const freq = 1600 * pitch * Math.pow(0.12, u);
+    phase += TAU * freq / SAMPLE_RATE;
+    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;
+}
+function swoosh(seed, pitch) {
+  const dur = 0.35;
+  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 = 300 * pitch * Math.pow(7.3, u);
+    const alpha = Math.min(1, TAU * center / SAMPLE_RATE);
+    lp += alpha * (noise(i, seed) - lp);
+    lp2 += alpha * 0.5 * (lp - lp2);
+    const env = Math.sin(Math.PI * u) ** 0.9;
+    out[i] = (lp - lp2) * env * 2.4;
+  }
+  return out;
+}
+function glitch(seed, pitch) {
+  const dur = 0.3;
+  const { out, n } = buffer(dur);
+  const cell = Math.round(SAMPLE_RATE * 0.012);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const c = Math.floor(i / cell);
+    const on = hash01(c, seed) > 0.4 ? 1 : 0;
+    const freq = 400 * pitch * (1 + Math.floor(hash01(c, seed + 1) * 6));
+    phase += TAU * freq / SAMPLE_RATE;
+    const crush = Math.round(square(phase) * 4) / 4;
+    out[i] = (crush * 0.7 + noise(i, seed + c) * 0.3) * on * (1 - u * 0.3) * 0.55;
+  }
+  return out;
+}
+function staticHit(seed, pitch) {
+  const dur = 0.18;
+  const { out, n } = buffer(dur);
   let lp = 0;
+  const alpha = Math.min(0.8, TAU * 3e3 * pitch / SAMPLE_RATE);
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    lp += alpha * (noise(i, seed) - lp);
+    const env = Math.min(1, u * 30) * expDecay(t, dur, 5);
+    out[i] = (noise(i, seed) - lp) * env * 1.4;
+  }
+  return out;
+}
+function scan(seed, pitch) {
+  const dur = 0.45;
+  const { out, n } = buffer(dur);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur;
+    const step = Math.floor(u * 6) / 6;
+    const freq = 500 * pitch * Math.pow(3, step);
+    phase += TAU * freq / SAMPLE_RATE;
+    const cell = u * 6 % 1;
+    const env = Math.min(1, cell * 12) * Math.min(1, (1 - cell) * 4) * 0.7;
+    out[i] = square(phase) * env * 0.5;
+  }
+  return out;
+}
+function powerup(seed, pitch) {
+  const dur = 0.4;
+  const { out, n } = buffer(dur);
+  const notes = [392, 523, 659, 784, 1046].map((f) => f * pitch);
+  let phase = 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 * notes.length));
+    phase += TAU * notes[idx] / SAMPLE_RATE;
+    const local = u * notes.length - idx;
+    const env = Math.min(1, local * 14) * Math.min(1, (1 - Math.min(1, local)) * 4 + 0.3);
+    out[i] = (Math.sin(phase) + 0.25 * Math.sin(2 * phase)) * env * 0.45;
+  }
+  return out;
+}
+function powerdown(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 = 700 * pitch * Math.pow(0.18, u);
+    phase += TAU * freq / SAMPLE_RATE;
+    const env = (1 - u) ** 0.8;
+    out[i] = (square(phase) * 0.7 + Math.sin(phase) * 0.3) * env * 0.5;
+  }
+  return out;
+}
+function sub(seed, pitch) {
+  const dur = 0.7;
+  const { out, n } = buffer(dur);
+  let phase = 0;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const freq = 90 * Math.pow(45 / 90, t / 0.15);
+    const freq = 80 * pitch * Math.pow(0.45, t / 0.4);
     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 click2 = t < 4e-3 ? noise(i, seed) * 0.4 : 0;
+    out[i] = (Math.sin(phase) + click2) * expDecay(t, dur, 3) * 0.95;
+  }
+  return out;
+}
+function snare(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;
+    phase += TAU * 180 * pitch / SAMPLE_RATE;
+    const body = Math.sin(phase) * 0.5 * expDecay(t, dur, 16);
+    const rattle = noise(i, seed) * expDecay(t, dur, 7);
+    out[i] = (body + rattle * 0.8) * 0.7;
+  }
+  return out;
+}
+function hat(seed, pitch) {
+  const dur = 0.05;
+  const { out, n } = buffer(dur);
+  let lp = 0;
+  const alpha = Math.min(0.85, TAU * 2500 * pitch / SAMPLE_RATE);
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    lp += alpha * (noise(i, seed) - lp);
+    out[i] = (noise(i, seed) - lp) * expDecay(t, dur, 14) * 0.9;
+  }
+  return out;
+}
+function bubble(seed, pitch) {
+  const dur = 0.16;
+  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 = 400 * pitch * Math.pow(3, u);
+    phase += TAU * freq / SAMPLE_RATE;
+    const env = Math.sin(Math.PI * u) ** 1.1;
+    out[i] = Math.sin(phase) * env * 0.6;
+  }
+  return out;
+}
+function notify(seed, pitch) {
+  const dur = 0.45;
+  const { out, n } = buffer(dur);
+  const f0 = 880 * pitch;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    const a = Math.sin(TAU * f0 * t) * expDecay(t, dur, 5);
+    const b = t > 0.09 ? Math.sin(TAU * f0 * 1.5 * t) * expDecay(t - 0.09, dur, 4.5) : 0;
+    out[i] = (a * 0.55 + b * 0.6) * 0.55;
+  }
+  return out;
+}
+function camera(seed, pitch) {
+  const dur = 0.18;
+  const { out, n } = buffer(dur);
+  let lp = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE;
+    lp += 0.45 * (noise(i, seed) - lp);
+    const k1 = t < 0.02 ? expDecay(t, 0.02, 6) : 0;
+    const k2 = t > 0.08 && t < 0.12 ? expDecay(t - 0.08, 0.04, 6) : 0;
+    const sine = Math.sin(TAU * 2200 * pitch * t);
+    out[i] = (lp * 0.7 + sine * 0.3) * (k1 + k2) * 1.3;
   }
   return out;
 }
 var RECIPES = {
   whoosh,
-  pop,
-  tick,
+  swish,
+  swoosh,
   rise,
+  riser,
+  warp,
+  tick,
+  click,
+  blip,
+  pop,
+  select,
+  thud,
+  boom,
+  knock,
+  sub,
+  chime,
+  ding,
+  coin,
+  sparkle,
   shimmer,
-  thud
+  success,
+  zap,
+  error,
+  glitch,
+  static: staticHit,
+  scan,
+  powerup,
+  powerdown,
+  snare,
+  hat,
+  bubble,
+  notify,
+  camera
 };
 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 * 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);
     }
-    out[i] = s / voices.length * 0.7;
+    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 +1957,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