reframe-video 0.6.26 → 0.6.28

package/dist/bin.js

@@ -10,10 +10,46 @@ var __export = (target, all) => {
 };
 
 // ../core/src/ir.ts
-var DEFAULT_TO_DURATION, DEFAULT_TWEEN_DURATION, DEFAULT_MOTIONPATH_DURATION, DEFAULT_STILL_DURATION;
+var SFX_NAMES, BGM_SYNTHS, DEFAULT_TO_DURATION, DEFAULT_TWEEN_DURATION, DEFAULT_MOTIONPATH_DURATION, DEFAULT_STILL_DURATION;
 var init_ir = __esm({
   "../core/src/ir.ts"() {
     "use strict";
+    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"
+    ];
+    BGM_SYNTHS = ["ambient-pad", "lofi", "pulse", "tension", "uplift"];
     DEFAULT_TO_DURATION = 0.5;
     DEFAULT_TWEEN_DURATION = 0.5;
     DEFAULT_MOTIONPATH_DURATION = 1;
@@ -647,7 +683,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(
@@ -683,6 +718,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);
 }
 function validateComposition(comp) {
@@ -718,6 +757,7 @@ var EASE_SET, FX_PROPS, BLEND_MODES, IMAGE_FITS, COMMON_PROPS, CAMERA_PROPS, PRO
 var init_validate = __esm({
   "../core/src/validate.ts"() {
     "use strict";
+    init_ir();
     init_interpolate();
     EASE_SET = new Set(EASE_NAMES);
     FX_PROPS = ["blur", "shadowColor", "shadowBlur", "shadowX", "shadowY", "blend"];
@@ -1395,7 +1435,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);
@@ -1438,12 +1482,46 @@ var init_audio = __esm({
   "../core/src/audio.ts"() {
     "use strict";
     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
     };
     FILE_CUE_DURATION = 0.4;
   }
@@ -1739,19 +1817,21 @@ function hash01(n, seed) {
   h = (h ^ h >>> 16) >>> 0;
   return h / 4294967295;
 }
+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 dur2 = 0.35;
   const { out, n } = buffer(dur2);
-  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 / dur2;
-    const center = 1200 * Math.pow(300 / 1200, u);
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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);
@@ -1760,103 +1840,527 @@ function whoosh(seed) {
   }
   return out;
 }
-function pop(seed) {
+function swish(seed, pitch) {
+  const dur2 = 0.32;
+  const { out, n } = buffer(dur2);
+  let lp = 0, lp2 = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 * dur2, dur2 * 0.85, 5);
+    out[i] = (lp - lp2) * env * 2.4;
+  }
+  return out;
+}
+function rise(_seed, pitch) {
+  const dur2 = 0.5;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.85;
+  const { out, n } = buffer(dur2);
+  let lp = 0, phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.5;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.03;
+  const { out, n } = buffer(dur2);
+  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, dur2, 8);
+  }
+  return out;
+}
+function click(seed, pitch) {
+  const dur2 = 0.05;
+  const { out, n } = buffer(dur2);
+  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, dur2, 11);
+  }
+  return out;
+}
+function blip(_seed, pitch) {
+  const dur2 = 0.1;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.12;
   const { out, n } = buffer(dur2);
   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, dur2, 6) * 0.8;
   }
   return out;
 }
-function tick(seed) {
-  const dur2 = 0.03;
+function select(_seed, pitch) {
+  const dur2 = 0.18;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.25;
   const { out, n } = buffer(dur2);
+  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, dur2, 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, dur2, 5);
+  }
+  return out;
+}
+function boom(seed, pitch) {
+  const dur2 = 0.6;
+  const { out, n } = buffer(dur2);
+  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, dur2, 3.2);
+  }
+  return out;
+}
+function knock(seed, pitch) {
+  const dur2 = 0.14;
+  const { out, n } = buffer(dur2);
+  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, dur2, 9);
   }
   return out;
 }
-function rise(seed) {
+function chime(seed, pitch) {
+  const dur2 = 0.7;
+  const { out, n } = buffer(dur2);
+  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, dur2, 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 dur2 = 0.5;
   const { out, n } = buffer(dur2);
-  let phase = 0;
+  const f0 = 1200 * pitch;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const u = t / dur2;
-    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, dur2, 4.5) * 0.6;
+  }
+  return out;
+}
+function coin(_seed, pitch) {
+  const dur2 = 0.3;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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), dur2, 3.5);
+    out[i] = square(phase) * env * 0.55;
   }
   return out;
 }
-function shimmer(seed) {
+function sparkle(seed, pitch) {
+  const dur2 = 0.6;
+  const { out, n } = buffer(dur2);
+  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 / dur2;
+    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 dur2 = 0.6;
+  const { out, n } = buffer(dur2);
+  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 / dur2;
+    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 dur2 = 0.9;
   const { out, n } = buffer(dur2);
   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 / dur2;
+    const t = i / SAMPLE_RATE, u = t / dur2;
     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 dur2 = 0.25;
+function zap(seed, pitch) {
+  const dur2 = 0.22;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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, dur2, 4.5) * 0.5;
+  }
+  return out;
+}
+function error(_seed, pitch) {
+  const dur2 = 0.4;
   const { out, n } = buffer(dur2);
   let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.35;
+  const { out, n } = buffer(dur2);
+  let lp = 0, lp2 = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.3;
+  const { out, n } = buffer(dur2);
+  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 / dur2;
+    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 dur2 = 0.18;
+  const { out, n } = buffer(dur2);
   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 / dur2;
+    lp += alpha * (noise(i, seed) - lp);
+    const env = Math.min(1, u * 30) * expDecay(t, dur2, 5);
+    out[i] = (noise(i, seed) - lp) * env * 1.4;
+  }
+  return out;
+}
+function scan(seed, pitch) {
+  const dur2 = 0.45;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.4;
+  const { out, n } = buffer(dur2);
+  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 / dur2;
+    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 dur2 = 0.5;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.7;
+  const { out, n } = buffer(dur2);
+  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, dur2, 5);
+    const click2 = t < 4e-3 ? noise(i, seed) * 0.4 : 0;
+    out[i] = (Math.sin(phase) + click2) * expDecay(t, dur2, 3) * 0.95;
+  }
+  return out;
+}
+function snare(seed, pitch) {
+  const dur2 = 0.18;
+  const { out, n } = buffer(dur2);
+  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, dur2, 16);
+    const rattle = noise(i, seed) * expDecay(t, dur2, 7);
+    out[i] = (body + rattle * 0.8) * 0.7;
+  }
+  return out;
+}
+function hat(seed, pitch) {
+  const dur2 = 0.05;
+  const { out, n } = buffer(dur2);
+  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, dur2, 14) * 0.9;
+  }
+  return out;
+}
+function bubble(seed, pitch) {
+  const dur2 = 0.16;
+  const { out, n } = buffer(dur2);
+  let phase = 0;
+  for (let i = 0; i < n; i++) {
+    const t = i / SAMPLE_RATE, u = t / dur2;
+    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 dur2 = 0.45;
+  const { out, n } = buffer(dur2);
+  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, dur2, 5);
+    const b = t > 0.09 ? Math.sin(TAU * f0 * 1.5 * t) * expDecay(t - 0.09, dur2, 4.5) : 0;
+    out[i] = (a * 0.55 + b * 0.6) * 0.55;
+  }
+  return out;
+}
+function camera(seed, pitch) {
+  const dur2 = 0.18;
+  const { out, n } = buffer(dur2);
+  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;
 }
 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;
 }
-var noise, TAU, expDecay, RECIPES;
+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 });
+}
+function synthBgm(name, duration, seed = 0) {
+  return BGM_RECIPES[name](duration, seed);
+}
+var noise, TAU, expDecay, square, PITCH_STEPS, RECIPES, BGM_RECIPES;
 var init_synth = __esm({
   "../render-cli/src/audio/synth.ts"() {
     "use strict";
@@ -1864,13 +2368,49 @@ var init_synth = __esm({
     noise = (n, seed) => hash01(n, seed) * 2 - 1;
     TAU = Math.PI * 2;
     expDecay = (t, dur2, k = 5) => Math.exp(-k * t / dur2);
+    square = (ph) => (Math.sin(ph) + 0.33 * Math.sin(3 * ph) + 0.2 * Math.sin(5 * ph)) / 1.4;
+    PITCH_STEPS = [0, 2, 4, 7, 9, 12, 5, -3, 16, -5];
     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
+    };
+    BGM_RECIPES = {
+      "ambient-pad": synthAmbientPad,
+      lofi: synthLofi,
+      pulse: synthPulse,
+      tension: synthTension,
+      uplift: synthUplift
     };
   }
 });
@@ -1925,7 +2465,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));
 }
 var ROOT, VENDORED, CACHE;
 var init_sfx = __esm({