reframe-video 0.6.32 → 0.6.34

package/dist/bin.js

@@ -409,7 +409,119 @@ function easeOutBounce(u) {
   if (u < 2.5 / d1) return n1 * (u -= 2.25 / d1) * u + 0.9375;
   return n1 * (u -= 2.625 / d1) * u + 0.984375;
 }
-var BACK_C1, BACK_C2, BACK_C3, ELASTIC_C4, ELASTIC_C5, EASE_TABLE, EASE_NAMES;
+function resolveEase(ease) {
+  if (ease === void 0) return EASE_TABLE.linear;
+  if (typeof ease === "string") {
+    const fn = EASE_TABLE[ease];
+    if (!fn) throw new Error(`unknown ease "${ease}" \u2014 valid: ${Object.keys(EASE_TABLE).join(", ")}`);
+    return fn;
+  }
+  if ("spring" in ease) {
+    const { stiffness = 100, damping = 10, velocity = 0 } = ease.spring;
+    return springEase(stiffness, damping, velocity);
+  }
+  return cubicBezierEase(...ease.cubicBezier);
+}
+function cubicBezierEase(x1, y1, x2, y2) {
+  const bez = (a, b) => (t) => 3 * a * t * (1 - t) ** 2 + 3 * b * t * t * (1 - t) + t ** 3;
+  const bx = bez(x1, x2);
+  const by = bez(y1, y2);
+  const dbx = (t) => 3 * x1 * (1 - t) * (1 - 3 * t) + 3 * x2 * t * (2 - 3 * t) + 3 * t * t;
+  return (u) => {
+    if (u <= 0) return 0;
+    if (u >= 1) return 1;
+    let t = u;
+    for (let i = 0; i < 8; i++) {
+      const err = bx(t) - u;
+      if (Math.abs(err) < 1e-6) return by(t);
+      const d = dbx(t);
+      if (Math.abs(d) < 1e-6) break;
+      t -= err / d;
+    }
+    let lo = 0;
+    let hi = 1;
+    t = u;
+    while (hi - lo > 1e-6) {
+      if (bx(t) < u) lo = t;
+      else hi = t;
+      t = (lo + hi) / 2;
+    }
+    return by(t);
+  };
+}
+function isColor(v) {
+  return typeof v === "string" && HEX_COLOR.test(v);
+}
+function parseColor(hex) {
+  let h = hex.slice(1);
+  if (h.length <= 4) h = [...h].map((c) => c + c).join("");
+  const n = parseInt(h.padEnd(8, "f"), 16);
+  return [n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255];
+}
+function formatColor([r, g, b, a]) {
+  const hex = (v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0");
+  return a >= 255 ? `#${hex(r)}${hex(g)}${hex(b)}` : `#${hex(r)}${hex(g)}${hex(b)}${hex(a)}`;
+}
+function lerpValue(from, to, u) {
+  if (typeof from === "number" && typeof to === "number") {
+    return from + (to - from) * u;
+  }
+  if (isColor(from) && isColor(to)) {
+    const a = parseColor(from);
+    const b = parseColor(to);
+    return formatColor([
+      a[0] + (b[0] - a[0]) * u,
+      a[1] + (b[1] - a[1]) * u,
+      a[2] + (b[2] - a[2]) * u,
+      a[3] + (b[3] - a[3]) * u
+    ]);
+  }
+  if (looksLikePath(from) && looksLikePath(to)) {
+    const a = tokenizePath(from);
+    const b = tokenizePath(to);
+    if (a && b && morphCompatible(a, b)) return morphPath(a, b, u);
+    return u < 0.5 ? from : to;
+  }
+  return to;
+}
+function looksLikePath(v) {
+  return typeof v === "string" && /^\s*[Mm]/.test(v) && PATH_BODY.test(v);
+}
+function tokenizePath(d) {
+  const out = [];
+  let cur = null;
+  let m;
+  PATH_TOKEN.lastIndex = 0;
+  while (m = PATH_TOKEN.exec(d)) {
+    if (m[1]) out.push(cur = { cmd: m[1], nums: [] });
+    else if (m[2]) {
+      if (!cur) return null;
+      cur.nums.push(parseFloat(m[2]));
+    }
+  }
+  return out.length ? out : null;
+}
+function morphCompatible(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ca = a[i];
+    const cb = b[i];
+    if (ca.cmd !== cb.cmd || ca.nums.length !== cb.nums.length) return false;
+    if (ca.cmd === "A" || ca.cmd === "a") return false;
+  }
+  return true;
+}
+function morphPath(a, b, u) {
+  let s = "";
+  for (let i = 0; i < a.length; i++) {
+    const an = a[i].nums;
+    const bn = b[i].nums;
+    s += (i ? " " : "") + a[i].cmd;
+    for (let j = 0; j < an.length; j++) s += " " + fmtNum(an[j] + (bn[j] - an[j]) * u);
+  }
+  return s;
+}
+var BACK_C1, BACK_C2, BACK_C3, ELASTIC_C4, ELASTIC_C5, EASE_TABLE, EASE_NAMES, HEX_COLOR, PATH_BODY, PATH_TOKEN, fmtNum;
 var init_interpolate = __esm({
   "../core/src/interpolate.ts"() {
     "use strict";
@@ -451,6 +563,13 @@ var init_interpolate = __esm({
       springStiff: springEase(210, 26, 0)
     };
     EASE_NAMES = Object.keys(EASE_TABLE);
+    HEX_COLOR = /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+    PATH_BODY = /^[\sMmLlHhVvCcSsQqTtAaZz0-9.,eE+-]+$/;
+    PATH_TOKEN = /([MmLlHhVvCcSsQqTtAaZz])|(-?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?)/g;
+    fmtNum = (v) => {
+      const r = Number(v.toFixed(3));
+      return Object.is(r, -0) ? "0" : String(r);
+    };
   }
 });
 
@@ -1102,6 +1221,40 @@ var init_camera = __esm({
   }
 });
 
+// ../core/src/behaviors.ts
+function sampleBehavior(b, t) {
+  switch (b.name) {
+    case "oscillate": {
+      const { amplitude, frequency, phase = 0 } = b.params;
+      return amplitude * Math.sin(2 * Math.PI * frequency * t + phase);
+    }
+    case "wiggle": {
+      const { amplitude, frequency, seed } = b.params;
+      return amplitude * valueNoise(t * frequency, seed);
+    }
+  }
+}
+function valueNoise(x, seed) {
+  const i = Math.floor(x);
+  const f = x - i;
+  const u = f * f * (3 - 2 * f);
+  const a = hash01(i, seed) * 2 - 1;
+  const b = hash01(i + 1, seed) * 2 - 1;
+  return a + (b - a) * u;
+}
+function hash01(n, seed) {
+  let h = n * 374761393 + seed * 668265263 | 0;
+  h = h ^ h >>> 13 | 0;
+  h = Math.imul(h, 1274126177);
+  h = (h ^ h >>> 16) >>> 0;
+  return h / 4294967295;
+}
+var init_behaviors = __esm({
+  "../core/src/behaviors.ts"() {
+    "use strict";
+  }
+});
+
 // ../core/src/gradient.ts
 var init_gradient = __esm({
   "../core/src/gradient.ts"() {
@@ -1109,6 +1262,247 @@ var init_gradient = __esm({
   }
 });
 
+// ../core/src/evaluate.ts
+function multiply(m, n) {
+  return [
+    m[0] * n[0] + m[2] * n[1],
+    m[1] * n[0] + m[3] * n[1],
+    m[0] * n[2] + m[2] * n[3],
+    m[1] * n[2] + m[3] * n[3],
+    m[0] * n[4] + m[2] * n[5] + m[4],
+    m[1] * n[4] + m[3] * n[5] + m[5]
+  ];
+}
+function localMatrix(x, y, rotationDeg, scale, scaleX = 1, scaleY = 1, skewXDeg = 0, skewYDeg = 0) {
+  const r = rotationDeg * Math.PI / 180;
+  if (scaleX === 1 && scaleY === 1 && skewXDeg === 0 && skewYDeg === 0) {
+    const cos = Math.cos(r) * scale;
+    const sin = Math.sin(r) * scale;
+    return [cos, sin, -sin, cos, x, y];
+  }
+  const c = Math.cos(r);
+  const s = Math.sin(r);
+  const tx = Math.tan(skewXDeg * Math.PI / 180);
+  const ty = Math.tan(skewYDeg * Math.PI / 180);
+  const R = [c, s, -s, c, 0, 0];
+  const K = [1, ty, tx, 1, 0, 0];
+  const S = [scale * scaleX, 0, 0, scale * scaleY, 0, 0];
+  const m = multiply(R, multiply(K, S));
+  return [m[0], m[1], m[2], m[3], x, y];
+}
+function behaviorEnvelope(b, t) {
+  const from = b.from ?? Number.NEGATIVE_INFINITY;
+  const until = b.until ?? Number.POSITIVE_INFINITY;
+  if (t < from || t > until) return 0;
+  const ramp = b.ramp ?? 0.2;
+  let envelope = 1;
+  if (Number.isFinite(from) && ramp > 0) envelope = Math.min(envelope, (t - from) / ramp);
+  if (Number.isFinite(until) && ramp > 0) envelope = Math.min(envelope, (until - t) / ramp);
+  return Math.max(0, Math.min(1, envelope));
+}
+function sampleProp(compiled, t, target, prop, fallback) {
+  let value = compiled.initialValues.get(`${target}.${prop}`) ?? fallback;
+  let segStart = Number.NEGATIVE_INFINITY;
+  const segs = compiled.segments.get(`${target}.${prop}`);
+  if (segs) {
+    let active;
+    for (const seg of segs) {
+      if (seg.t0 <= t) active = seg;
+      else break;
+    }
+    if (active) {
+      segStart = active.t0;
+      if (t >= active.t1) {
+        value = active.to;
+      } else {
+        const u = resolveEase(active.ease)((t - active.t0) / (active.t1 - active.t0));
+        value = lerpValue(active.from, active.to, u);
+      }
+    }
+  }
+  if (prop === "x" || prop === "y" || prop === "rotation") {
+    const drivers = compiled.motionPaths.get(target);
+    if (drivers) {
+      let active;
+      for (const d of drivers) {
+        if (d.t0 <= t) active = d;
+        else break;
+      }
+      if (active && active.t0 >= segStart && (prop !== "rotation" || active.autoRotate) && active.points.length > 0) {
+        const span = active.t1 - active.t0;
+        const u = span <= 0 ? 1 : resolveEase(active.ease)(Math.max(0, Math.min(1, (t - active.t0) / span)));
+        if (prop === "x") value = pathPoint(active.points, active.closed, u, active.curviness)[0];
+        else if (prop === "y") value = pathPoint(active.points, active.closed, u, active.curviness)[1];
+        else value = pathTangentAngle(active.points, active.closed, u, active.curviness) + active.rotateOffset;
+      }
+    }
+  }
+  for (const b of compiled.ir.behaviors ?? []) {
+    if (b.target === target && b.prop === prop && typeof value === "number") {
+      const envelope = behaviorEnvelope(b, t);
+      if (envelope > 0) value = value + envelope * sampleBehavior(b.behavior, t);
+    }
+  }
+  return value;
+}
+function nodeParentMatrix(compiled, id, t) {
+  const num2 = (target, prop, fallback) => {
+    const v = sampleProp(compiled, t, target, prop, fallback);
+    return typeof v === "number" ? v : fallback;
+  };
+  let result = null;
+  const walk = (node, parent) => {
+    if (node.id === id) {
+      result = parent;
+      return true;
+    }
+    if (node.type === "group") {
+      const m = multiply(
+        parent,
+        localMatrix(
+          num2(node.id, "x", node.props.x),
+          num2(node.id, "y", node.props.y),
+          num2(node.id, "rotation", node.props.rotation ?? 0),
+          num2(node.id, "scale", node.props.scale ?? 1),
+          num2(node.id, "scaleX", node.props.scaleX ?? 1),
+          num2(node.id, "scaleY", node.props.scaleY ?? 1),
+          num2(node.id, "skewX", node.props.skewX ?? 0),
+          num2(node.id, "skewY", node.props.skewY ?? 0)
+        )
+      );
+      for (const child of node.children) if (walk(child, m)) return true;
+    }
+    return false;
+  };
+  for (const node of compiled.ir.nodes) if (walk(node, IDENTITY)) break;
+  return result;
+}
+var IDENTITY, DEG;
+var init_evaluate = __esm({
+  "../core/src/evaluate.ts"() {
+    "use strict";
+    init_behaviors();
+    init_camera();
+    init_gradient();
+    init_interpolate();
+    init_path();
+    IDENTITY = [1, 0, 0, 1, 0, 0];
+    DEG = Math.PI / 180;
+  }
+});
+
+// ../core/src/autoFoley.ts
+function nodeSize(node) {
+  const p = node.props;
+  return Math.max(p.width ?? 0, p.height ?? 0, (p.radius ?? 0) * 2, p.fontSize ?? 0, 0);
+}
+function autoFoley(compiled, opts = {}) {
+  const master = opts.gain ?? 0.5;
+  const sens = opts.sensitivity ?? 1;
+  const wantWhoosh = opts.whoosh !== false;
+  const wantImpact = opts.impact !== false;
+  const wantPop = opts.pop !== false;
+  const wantPan = opts.pan !== false;
+  const vMin = V_MIN / sens, vStop = V_STOP, vDecel = V_DECEL / sens;
+  const fps = compiled.ir.fps ?? 30;
+  const N = Math.max(1, Math.ceil(compiled.duration * fps));
+  const W = compiled.ir.size.width || 1920;
+  const ids = opts.nodes ?? [...compiled.nodeById.keys()];
+  const cands = [];
+  const panOf = (x) => wantPan ? Math.max(-1, Math.min(1, x / W * 2 - 1)) : 0;
+  const loud = (v) => Math.max(0.2, Math.min(1, (v - vMin) / (V_MAX - vMin)));
+  for (const id of ids) {
+    const node = compiled.nodeById.get(id);
+    if (!node || node.type === "line") continue;
+    const size = nodeSize(node);
+    const xs = [], ys = [], ss = [], os = [];
+    for (let i2 = 0; i2 <= N; i2++) {
+      const t = i2 / fps;
+      xs.push(num(compiled, t, id, "x", node.props.x ?? 0));
+      ys.push(num(compiled, t, id, "y", node.props.y ?? 0));
+      ss.push(num(compiled, t, id, "scale", node.props.scale ?? 1));
+      os.push(num(compiled, t, id, "opacity", node.props.opacity ?? 1));
+    }
+    const speed = (i2) => i2 <= 0 ? 0 : Math.hypot(xs[i2] - xs[i2 - 1], ys[i2] - ys[i2 - 1]) * fps;
+    const worldX = (frame) => {
+      const m = nodeParentMatrix(compiled, id, frame / fps);
+      return m ? m[0] * xs[frame] + m[2] * ys[frame] + m[4] : xs[frame];
+    };
+    let i = 1;
+    while (i <= N) {
+      if (speed(i) <= vMin) {
+        i++;
+        continue;
+      }
+      const a = i;
+      let peak = i, peakV = speed(i);
+      while (i <= N && speed(i) > vStop) {
+        const s = speed(i);
+        if (s > peakV) {
+          peakV = s;
+          peak = i;
+        }
+        i++;
+      }
+      const b = i - 1;
+      const durS = (b - a + 1) / fps;
+      const visible = os[peak] > 0.1;
+      if (peakV > vMin && durS >= MIN_DUR && visible) {
+        if (wantWhoosh) {
+          const quickFlick = durS < 0.25;
+          cands.push({ t: peak / fps, sfx: quickFlick ? "swish" : "whoosh", gain: master * loud(peakV), pan: panOf(worldX(peak)), rank: peakV });
+        }
+        const stopped = b >= N || speed(b + 1) < vStop && speed(Math.min(N, b + 2)) < vStop;
+        const wxb = worldX(b);
+        const landsOnScreen = wxb >= 0 && wxb <= W && os[b] > 0.1;
+        if (wantImpact && peakV > vDecel && stopped && landsOnScreen && b < N) {
+          cands.push({ t: (b + 1) / fps, sfx: size > 220 ? "thud" : "knock", gain: master * loud(peakV), pan: panOf(worldX(b)), rank: peakV * 1.1 });
+        }
+      }
+    }
+    if (wantPop && ss[0] < 0.25) {
+      for (let k = 1; k <= N; k++) {
+        if (ss[k - 1] < 0.5 && ss[k] >= 0.5 && os[k] > 0.05) {
+          cands.push({ t: k / fps, sfx: "pop", gain: master * 0.7, pan: panOf(worldX(k)), rank: 600 });
+          break;
+        }
+      }
+    }
+  }
+  cands.sort((p, q) => q.rank - p.rank);
+  const kept = [];
+  for (const c of cands) {
+    const fam = FAMILY[c.sfx] ?? c.sfx;
+    if (kept.some((k) => (FAMILY[k.sfx] ?? k.sfx) === fam && Math.abs(k.t - c.t) < DEDUP_DT)) continue;
+    kept.push(c);
+  }
+  const max = opts.maxCues ?? 32;
+  return kept.slice(0, max).map((c) => ({
+    at: Number(c.t.toFixed(3)),
+    sfx: c.sfx,
+    gain: Number(c.gain.toFixed(3)),
+    ...c.pan !== 0 ? { pan: Number(c.pan.toFixed(3)) } : {}
+  }));
+}
+var V_MIN, V_STOP, V_DECEL, V_MAX, MIN_DUR, num, FAMILY, DEDUP_DT;
+var init_autoFoley = __esm({
+  "../core/src/autoFoley.ts"() {
+    "use strict";
+    init_evaluate();
+    V_MIN = 360;
+    V_STOP = 60;
+    V_DECEL = 520;
+    V_MAX = 2600;
+    MIN_DUR = 0.1;
+    num = (c, t, id, prop, fb) => {
+      const v = sampleProp(c, t, id, prop, fb);
+      return typeof v === "number" ? v : fb;
+    };
+    FAMILY = { whoosh: "move", swish: "move", thud: "hit", knock: "hit", pop: "pop" };
+    DEDUP_DT = 0.09;
+  }
+});
+
 // ../core/src/effects.ts
 var init_effects = __esm({
   "../core/src/effects.ts"() {
@@ -1403,11 +1797,13 @@ function resolveAudioPlan(compiled) {
   const warnings = [];
   const duration = compiled.duration;
   const clipAudio = collectClipAudio(compiled.ir, duration, warnings);
-  if (!audio || !audio.bgm && (audio.cues ?? []).length === 0) {
+  const autoCues = audio?.autoFoley ? autoFoley(compiled, audio.autoFoley === true ? {} : audio.autoFoley) : [];
+  const manualCues = [...audio?.cues ?? [], ...autoCues];
+  if (!audio || !audio.bgm && manualCues.length === 0) {
     return clipAudio.length === 0 ? null : { duration, bgm: null, cues: [], duckWindows: [], clipAudio, warnings };
   }
   const cues = [];
-  for (const [index, cue] of (audio.cues ?? []).entries()) {
+  for (const [index, cue] of manualCues.entries()) {
     let anchor;
     if (typeof cue.at === "number") {
       anchor = cue.at;
@@ -1481,6 +1877,7 @@ var SFX_DURATION, FILE_CUE_DURATION;
 var init_audio = __esm({
   "../core/src/audio.ts"() {
     "use strict";
+    init_autoFoley();
     SFX_DURATION = {
       // transition
       whoosh: 0.35,
@@ -1527,27 +1924,6 @@ var init_audio = __esm({
   }
 });
 
-// ../core/src/behaviors.ts
-var init_behaviors = __esm({
-  "../core/src/behaviors.ts"() {
-    "use strict";
-  }
-});
-
-// ../core/src/evaluate.ts
-var DEG;
-var init_evaluate = __esm({
-  "../core/src/evaluate.ts"() {
-    "use strict";
-    init_behaviors();
-    init_camera();
-    init_gradient();
-    init_interpolate();
-    init_path();
-    DEG = Math.PI / 180;
-  }
-});
-
 // ../core/src/assets.ts
 function collectSrcs(ir, type) {
   const srcs = /* @__PURE__ */ new Set();
@@ -1611,6 +1987,7 @@ var init_src = __esm({
     init_compile();
     init_path();
     init_camera();
+    init_autoFoley();
     init_gradient();
     init_effects();
     init_layout();
@@ -1810,7 +2187,7 @@ var init_wav = __esm({
 });
 
 // ../render-cli/src/audio/synth.ts
-function hash01(n, seed) {
+function hash012(n, seed) {
   let h = n * 374761393 + seed * 668265263 | 0;
   h = h ^ h >>> 13 | 0;
   h = Math.imul(h, 1274126177);
@@ -2056,7 +2433,7 @@ function sparkle(seed, pitch) {
       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;
+        s += Math.sin(TAU * base * steps[g] * t + hash012(g, seed) * TAU) * ge;
       }
     }
     out[i] = s / 2.4 * Math.sin(Math.PI * u) ** 0.5 * 0.5;
@@ -2083,9 +2460,9 @@ 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) * pitch,
-    am: 0.5 + hash01(p, seed + 8) * 1.5,
-    phase: hash01(p, seed + 9) * TAU
+    freq: (2e3 + hash012(p, seed + 7) * 2e3) * pitch,
+    am: 0.5 + hash012(p, seed + 8) * 1.5,
+    phase: hash012(p, seed + 9) * TAU
   }));
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE, u = t / dur2;
@@ -2146,8 +2523,8 @@ function glitch(seed, pitch) {
   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));
+    const on = hash012(c, seed) > 0.4 ? 1 : 0;
+    const freq = 400 * pitch * (1 + Math.floor(hash012(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;
@@ -2306,8 +2683,8 @@ function synthSfx(name, params = {}) {
 function pad(freqs, duration, seed, opts) {
   const { out, n } = buffer(duration);
   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 }
+    { freq: f * (1 + (hash012(v, seed + 3) - 0.5) * 4e-3), am: opts.amBase + hash012(v, seed + 4) * 0.08, phase: hash012(v, seed + 5) * TAU },
+    { freq: f * (1 - (hash012(v, seed + 6) - 0.5) * 4e-3), am: opts.amBase + hash012(v, seed + 7) * 0.08, phase: hash012(v, seed + 8) * TAU }
   ]);
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
@@ -2346,8 +2723,8 @@ function synthTension(duration, seed = 0) {
     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 f = base[v] * drift * (1 + (hash012(v, seed) - 0.5) * 6e-3);
+      s += Math.sin(TAU * f * t + hash012(v, seed + 1) * TAU);
     }
     const swell = 0.6 + 0.4 * Math.sin(TAU * 0.08 * t);
     out[i] = s / base.length * swell * 0.6;
@@ -2365,7 +2742,7 @@ var init_synth = __esm({
   "../render-cli/src/audio/synth.ts"() {
     "use strict";
     init_wav();
-    noise = (n, seed) => hash01(n, seed) * 2 - 1;
+    noise = (n, seed) => hash012(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;
@@ -3616,15 +3993,15 @@ ${USAGE}`);
       preflightFfmpeg();
       const { tmpdir: tmpdir6 } = await import("node:os");
       const { resolveLogo: resolveLogo2, buildLogoSting: buildLogoSting2 } = await Promise.resolve().then(() => (init_logoSting(), logoSting_exports));
-      const num = (k) => flags[k] !== void 0 ? Number(flags[k]) : void 0;
+      const num2 = (k) => flags[k] !== void 0 ? Number(flags[k]) : void 0;
       console.log(`loading logo: ${arg} \u2026`);
       const { data, slug } = await resolveLogo2(arg, positional[1], {
         motion: flags.motion,
-        energy: num("energy"),
-        speed: num("speed"),
-        intensity: num("intensity"),
+        energy: num2("energy"),
+        speed: num2("speed"),
+        intensity: num2("intensity"),
         from: flags.from,
-        seed: num("seed")
+        seed: num2("seed")
       });
       const sceneIR = buildLogoSting2(data);
       const tmp = join9(tmpdir6(), `reframe-logo-${slug}-${process.pid}.json`);

package/dist/browserEntry.js

@@ -549,14 +549,6 @@
     return [a, b, c, d, W / 2 - a * x - c * y, H / 2 - b * x - d * y];
   }
 
-  // ../core/src/gradient.ts
-  function isGradient(p) {
-    return typeof p === "object" && p !== null && (p.kind === "linear" || p.kind === "radial" || p.kind === "conic");
-  }
-
-  // ../core/src/presets.ts
-  var SET = 1 / 120;
-
   // ../core/src/behaviors.ts
   function sampleBehavior(b, t) {
     switch (b.name) {
@@ -586,6 +578,11 @@
     return h / 4294967295;
   }
 
+  // ../core/src/gradient.ts
+  function isGradient(p) {
+    return typeof p === "object" && p !== null && (p.kind === "linear" || p.kind === "radial" || p.kind === "conic");
+  }
+
   // ../core/src/evaluate.ts
   var IDENTITY = [1, 0, 0, 1, 0, 0];
   function multiply(m, n) {
@@ -986,6 +983,9 @@
     return ops;
   }
 
+  // ../core/src/presets.ts
+  var SET = 1 / 120;
+
   // ../renderer-canvas/src/index.ts
   function resolvePaint(ctx2, paint, box) {
     if (typeof paint === "string") return paint;