fablecut 0.0.0-stage → 1.12.1

package/fx-worklet.js

@@ -0,0 +1,162 @@
+/* FableCut audio-effect processors the Web Audio API has no node for.
+   Loaded into the live AudioContext and into each export's
+   OfflineAudioContext, so preview and export run the same code.
+
+   fablecut-limiter — brickwall peak limiter: 5 ms lookahead, stereo-linked.
+     The audio is delayed by the lookahead; the gain needed for every sample
+     in that window is known before the sample plays, so peaks never pass the
+     ceiling. Gain recovers with an exponential release.
+   fablecut-pitch — pitch shift (semitones), two-tap delay line (below).
+   fablecut-gate — noise gate: opens (attack) when the input peak rises over
+     the threshold, stays open for `hold`, then closes (release) down to
+     `range` dB. */
+
+const dbToLin = (db) => Math.pow(10, db / 20);
+const coef = (ms) => (ms <= 0 ? 0 : Math.exp(-1 / (sampleRate * ms / 1000)));
+
+class FableCutLimiter extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      { name: "ceiling", defaultValue: -1, minValue: -24, maxValue: 0, automationRate: "k-rate" },
+      { name: "release", defaultValue: 80, minValue: 5, maxValue: 1000, automationRate: "k-rate" },
+    ];
+  }
+  constructor() {
+    super();
+    this.la = Math.max(1, Math.round(0.005 * sampleRate));
+    this.delay = [];                        // per-channel ring of delayed samples
+    this.need = new Float32Array(this.la).fill(1); // gain each sample in the window needs
+    this.pos = 0;
+    this.g = 1;
+  }
+  process(inputs, outputs, params) {
+    const inp = inputs[0], out = outputs[0];
+    if (!inp || !inp.length) return true;
+    const ceil = dbToLin(params.ceiling[0]);
+    const rel = coef(params.release[0]);
+    const nCh = Math.min(inp.length, out.length);
+    while (this.delay.length < nCh) this.delay.push(new Float32Array(this.la));
+    const n = inp[0].length;
+    for (let i = 0; i < n; i++) {
+      let pk = 0;
+      for (let c = 0; c < nCh; c++) { const a = Math.abs(inp[c][i]); if (a > pk) pk = a; }
+      this.need[this.pos] = pk > ceil ? ceil / pk : 1;
+      let lo = 1;
+      for (let k = 0; k < this.la; k++) if (this.need[k] < lo) lo = this.need[k];
+      // Fall instantly to what the window needs; recover smoothly.
+      this.g = lo < this.g ? lo : lo + (this.g - lo) * rel;
+      for (let c = 0; c < nCh; c++) {
+        const d = this.delay[c];
+        out[c][i] = d[this.pos] * this.g;
+        d[this.pos] = inp[c][i];
+      }
+      this.pos = (this.pos + 1) % this.la;
+    }
+    return true;
+  }
+}
+
+class FableCutGate extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    const k = "k-rate";
+    return [
+      { name: "threshold", defaultValue: -50, minValue: -80, maxValue: -10, automationRate: k },
+      { name: "range", defaultValue: -40, minValue: -80, maxValue: 0, automationRate: k },
+      { name: "attack", defaultValue: 2, minValue: 0, maxValue: 50, automationRate: k },
+      { name: "hold", defaultValue: 80, minValue: 0, maxValue: 500, automationRate: k },
+      { name: "release", defaultValue: 150, minValue: 5, maxValue: 1000, automationRate: k },
+    ];
+  }
+  constructor() {
+    super();
+    this.env = 0;      // peak follower
+    this.g = 1;        // applied gain
+    this.holdLeft = 0; // samples the gate stays open after the signal drops
+  }
+  process(inputs, outputs, params) {
+    const inp = inputs[0], out = outputs[0];
+    if (!inp || !inp.length) return true;
+    const thr = dbToLin(params.threshold[0]);
+    const floor = dbToLin(params.range[0]);
+    const att = coef(params.attack[0]), rel = coef(params.release[0]);
+    const holdN = Math.round(sampleRate * params.hold[0] / 1000);
+    const envRel = coef(10);
+    const nCh = Math.min(inp.length, out.length);
+    const n = inp[0].length;
+    for (let i = 0; i < n; i++) {
+      let pk = 0;
+      for (let c = 0; c < nCh; c++) { const a = Math.abs(inp[c][i]); if (a > pk) pk = a; }
+      this.env = pk > this.env ? pk : this.env * envRel;
+      if (this.env >= thr) this.holdLeft = holdN;
+      else if (this.holdLeft > 0) this.holdLeft--;
+      const target = this.env >= thr || this.holdLeft > 0 ? 1 : floor;
+      const k = target > this.g ? att : rel;
+      this.g = target + (this.g - target) * k;
+      for (let c = 0; c < nCh; c++) out[c][i] = inp[c][i] * this.g;
+    }
+    return true;
+  }
+}
+
+/* fablecut-pitch — pitch shift without changing speed. A delay line read by
+   two taps half a window apart: each tap's delay sweeps through the window
+   at (1 − ratio) samples per sample, so it plays the input back faster or
+   slower, and a sin² crossfade hides the jump when a tap wraps (the two
+   weights always sum to 1). Adds about half a window (~30 ms) of latency. */
+class FableCutPitch extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    const k = "k-rate";
+    return [
+      { name: "semitones", defaultValue: 0, minValue: -12, maxValue: 12, automationRate: k },
+      { name: "mix", defaultValue: 1, minValue: 0, maxValue: 1, automationRate: k },
+    ];
+  }
+  constructor() {
+    super();
+    this.W = Math.max(64, Math.round(0.06 * sampleRate)); // window, samples
+    this.N = this.W * 2 + 4;                              // ring length
+    this.buf = [];
+    this.w = 0;   // write index
+    this.d = 0;   // tap A's delay, 0…W
+  }
+  read(b, delay) {
+    let p = this.w - delay;
+    while (p < 0) p += this.N;
+    const i = Math.floor(p), f = p - i;
+    return b[i % this.N] * (1 - f) + b[(i + 1) % this.N] * f;
+  }
+  process(inputs, outputs, params) {
+    const inp = inputs[0], out = outputs[0];
+    if (!inp || !inp.length) return true;
+    const semi = params.semitones[0], mix = params.mix[0];
+    const nCh = Math.min(inp.length, out.length);
+    while (this.buf.length < nCh) this.buf.push(new Float32Array(this.N));
+    const n = inp[0].length;
+    if (Math.abs(semi) < 0.01 || mix <= 0) { // exact pass-through, keep the line warm
+      for (let i = 0; i < n; i++) {
+        for (let c = 0; c < nCh; c++) { this.buf[c][this.w] = inp[c][i]; out[c][i] = inp[c][i]; }
+        this.w = (this.w + 1) % this.N;
+      }
+      return true;
+    }
+    const step = 1 - Math.pow(2, semi / 12), W = this.W, half = W / 2;
+    for (let i = 0; i < n; i++) {
+      for (let c = 0; c < nCh; c++) this.buf[c][this.w] = inp[c][i];
+      this.d += step;
+      if (this.d >= W) this.d -= W; else if (this.d < 0) this.d += W;
+      const d2 = this.d >= half ? this.d - half : this.d + half;
+      const s = Math.sin(Math.PI * this.d / W), g1 = s * s, g2 = 1 - g1;
+      for (let c = 0; c < nCh; c++) {
+        const b = this.buf[c];
+        const wet = g1 * this.read(b, this.d) + g2 * this.read(b, d2);
+        out[c][i] = inp[c][i] * (1 - mix) + wet * mix;
+      }
+      this.w = (this.w + 1) % this.N;
+    }
+    return true;
+  }
+}
+
+registerProcessor("fablecut-limiter", FableCutLimiter);
+registerProcessor("fablecut-gate", FableCutGate);
+registerProcessor("fablecut-pitch", FableCutPitch);

package/import-url.js

@@ -0,0 +1,293 @@
+/* Download a remote HTTPS file into ./media with SSRF guards.
+   Used by POST /api/import-url and fablecut_import_media. The stored src is
+   always a local /media/… path — the URL is not kept as the playback source.
+   Remote SVG is refused (same-origin image/svg+xml would be a script sink).
+   allowLoopback is a test-only carve-out for HTTP(S) to 127.0.0.1. */
+"use strict";
+const http = require("http");
+const https = require("https");
+const dns = require("dns");
+const net = require("net");
+const fs = require("fs");
+const path = require("path");
+const { spawnSync, execFile } = require("child_process");
+
+const MAX_BYTES = 2 * 1024 * 1024 * 1024; // 2 GiB
+const TIMEOUT_MS = 180_000;
+const MAX_REDIRECTS = 5;
+
+const KIND_BY_EXT = {
+  ".mp4": "video", ".webm": "video", ".mov": "video", ".mkv": "video", ".m4v": "video", ".avi": "video",
+  ".mp3": "audio", ".wav": "audio", ".ogg": "audio", ".m4a": "audio", ".aac": "audio", ".flac": "audio",
+  ".png": "image", ".jpg": "image", ".jpeg": "image", ".gif": "image", ".webp": "image", ".svg": "svg",
+};
+const EXT_BY_MIME = {
+  "video/mp4": ".mp4", "video/webm": ".webm", "video/quicktime": ".mov",
+  "video/x-matroska": ".mkv", "video/x-m4v": ".m4v",
+  "audio/mpeg": ".mp3", "audio/mp3": ".mp3", "audio/wav": ".wav", "audio/x-wav": ".wav",
+  "audio/ogg": ".ogg", "audio/mp4": ".m4a", "audio/aac": ".aac", "audio/flac": ".flac",
+  "image/png": ".png", "image/jpeg": ".jpg", "image/gif": ".gif", "image/webp": ".webp",
+  "image/svg+xml": ".svg",
+};
+const FASTSTART_EXT = new Set([".mp4", ".mov", ".m4v"]);
+
+function safeName(name) {
+  return String(name).replace(/[^\w.\- ()\[\]]+/g, "_").slice(0, 120) || "file";
+}
+function kindFromName(name) {
+  return KIND_BY_EXT[path.extname(name).toLowerCase()] || null;
+}
+/** Create `name` under dir with exclusive `wx`. On EEXIST, try name_1, name_2, …
+ *  so two concurrent imports cannot both pick the same free path. */
+function openUniqueFile(dir, name) {
+  const ext = path.extname(name), base = path.basename(name, ext);
+  let i = 0;
+  for (;;) {
+    const file = i === 0 ? name : `${base}_${i}${ext}`;
+    i++;
+    const target = path.join(dir, file);
+    try { return { target, fd: fs.openSync(target, "wx") }; }
+    catch (e) { if (e.code === "EEXIST") continue; throw e; }
+  }
+}
+
+function isBlockedIp(ip) {
+  if (!ip) return true;
+  let addr = String(ip).toLowerCase();
+  if (addr.startsWith("::ffff:")) addr = addr.slice(7);
+  if (net.isIPv4(addr)) {
+    const p = addr.split(".").map(Number);
+    if (p[0] === 0 || p[0] === 10 || p[0] === 127) return true;
+    if (p[0] === 169 && p[1] === 254) return true;
+    if (p[0] === 172 && p[1] >= 16 && p[1] <= 31) return true;
+    if (p[0] === 192 && p[1] === 168) return true;
+    if (p[0] === 100 && p[1] >= 64 && p[1] <= 127) return true;
+    if (p[0] >= 224) return true;
+    return false;
+  }
+  if (net.isIPv6(addr)) {
+    if (addr === "::1" || addr === "::") return true;
+    if (addr.startsWith("fe8") || addr.startsWith("fe9") ||
+        addr.startsWith("fea") || addr.startsWith("feb")) return true;
+    if (addr.startsWith("fc") || addr.startsWith("fd")) return true;
+    if (addr.startsWith("ff")) return true;
+    return false;
+  }
+  return true;
+}
+
+function isBlockedHostname(host) {
+  const h = String(host || "").replace(/^\[|\]$/g, "").toLowerCase();
+  if (!h) return true;
+  if (h === "localhost" || h.endsWith(".localhost") || h === "0.0.0.0") return true;
+  if (h.endsWith(".local") || h.endsWith(".internal") || h.endsWith(".lan")) return true;
+  if (h === "metadata.google.internal") return true;
+  if (net.isIP(h)) return isBlockedIp(h);
+  return false;
+}
+
+/* Test hook: HTTP(S) to 127.0.0.1 only. Does not open LAN, CGNAT, metadata, or
+   other loopback addresses (127.0.0.2, ::1, localhost). */
+function isTestLoopback(host) {
+  return String(host || "").replace(/^\[|\]$/g, "").toLowerCase() === "127.0.0.1";
+}
+
+function parseImportUrl(raw, { allowLoopback = false } = {}) {
+  let u;
+  try { u = new URL(String(raw || "").trim()); } catch { throw new Error("invalid URL"); }
+  const loopback = allowLoopback && isTestLoopback(u.hostname);
+  if (loopback) {
+    if (u.protocol !== "https:" && u.protocol !== "http:")
+      throw new Error("URL must be http(s)");
+  } else if (u.protocol !== "https:") {
+    throw new Error("URL must be https");
+  }
+  if (u.username || u.password) throw new Error("URL must not include credentials");
+  if (!u.hostname) throw new Error("invalid URL");
+  if (!loopback && isBlockedHostname(u.hostname))
+    throw new Error("blocked: local or private host");
+  return u;
+}
+
+async function assertPublicTarget(u, { allowLoopback = false } = {}) {
+  const host = u.hostname.replace(/^\[|\]$/g, "");
+  if (allowLoopback && isTestLoopback(host)) return;
+  if (isBlockedHostname(u.hostname)) throw new Error("blocked: local or private host");
+  if (net.isIP(host)) {
+    if (isBlockedIp(host)) throw new Error("blocked: local or private address");
+    return;
+  }
+  let addrs;
+  try { addrs = await dns.promises.lookup(host, { all: true, verbatim: true }); }
+  catch { throw new Error("could not resolve host"); }
+  if (!addrs.length) throw new Error("could not resolve host");
+  for (const a of addrs) {
+    if (isBlockedIp(a.address)) throw new Error("blocked: host resolves to a private address");
+  }
+}
+
+function filenameFrom(u, headers) {
+  const cd = headers["content-disposition"] || "";
+  const star = /filename\*\s*=\s*(?:UTF-8''|utf-8'')([^;]+)/i.exec(cd);
+  if (star) {
+    try { return safeName(path.basename(decodeURIComponent(star[1].trim().replace(/^"+|"+$/g, "")))); }
+    catch { /* fall through */ }
+  }
+  const quoted = /filename\s*=\s*"((?:\\.|[^"])+)"/i.exec(cd);
+  if (quoted) return safeName(path.basename(quoted[1].replace(/\\"/g, '"')));
+  const bare = /filename\s*=\s*([^;]+)/i.exec(cd);
+  if (bare) return safeName(path.basename(bare[1].trim().replace(/^"+|"+$/g, "")));
+
+  let base = "";
+  try { base = path.basename(decodeURIComponent(u.pathname)); } catch { base = path.basename(u.pathname); }
+  if (base === "/" || base === "." || base === "..") base = "";
+  const mime = (headers["content-type"] || "").split(";")[0].trim().toLowerCase();
+  const mimeExt = EXT_BY_MIME[mime] || "";
+  if (!base) base = "download" + mimeExt;
+  else if (!path.extname(base) && mimeExt) base += mimeExt;
+  return safeName(base);
+}
+
+function requestOnce(u, { signal, timeoutMs }) {
+  const lib = u.protocol === "https:" ? https : http;
+  const host = u.hostname.replace(/^\[|\]$/g, "");
+  const opts = {
+    protocol: u.protocol,
+    hostname: host,
+    port: u.port || undefined,
+    path: u.pathname + u.search,
+    method: "GET",
+    headers: { "User-Agent": "FableCut", Accept: "*/*" },
+  };
+  if (u.protocol === "https:" && !net.isIP(host)) opts.servername = host;
+  return new Promise((resolve, reject) => {
+    const req = lib.request(opts, resolve);
+    const fail = (err) => { try { req.destroy(); } catch {} reject(err); };
+    req.on("error", fail);
+    req.setTimeout(timeoutMs, () => fail(new Error("download timed out")));
+    if (signal) {
+      if (signal.aborted) return fail(Object.assign(new Error("aborted"), { code: "ABORT_ERR" }));
+      const onAbort = () => fail(Object.assign(new Error("aborted"), { code: "ABORT_ERR" }));
+      signal.addEventListener("abort", onAbort, { once: true });
+      req.on("close", () => signal.removeEventListener("abort", onAbort));
+    }
+    req.end();
+  });
+}
+
+function saveResponse(res, u, destDir, { signal, maxBytes }) {
+  const mime = (res.headers["content-type"] || "").split(";")[0].trim().toLowerCase();
+  if (mime === "text/html" || mime === "application/json") {
+    res.resume();
+    return Promise.reject(new Error("URL did not return a media file"));
+  }
+  const name = filenameFrom(u, res.headers);
+  const kind = kindFromName(name);
+  // /media/*.svg is served same-origin as image/svg+xml. A remote file with
+  // <script> opened as a document would run on the editor origin.
+  if (kind === "svg" || mime === "image/svg+xml" || mime === "image/svg") {
+    res.resume();
+    return Promise.reject(new Error("unsupported media type (remote SVG is not imported)"));
+  }
+  if (!kind) {
+    res.resume();
+    return Promise.reject(new Error("unsupported media type (need a video, audio, or image URL)"));
+  }
+  const declared = parseInt(res.headers["content-length"], 10);
+  if (declared > maxBytes) {
+    res.resume();
+    return Promise.reject(new Error("file too large"));
+  }
+  fs.mkdirSync(destDir, { recursive: true });
+  let target, owned = false, out, fd;
+  try {
+    const opened = openUniqueFile(destDir, name);
+    target = opened.target;
+    fd = opened.fd;
+    owned = true;
+    out = fs.createWriteStream(target, { fd });
+  } catch (e) {
+    res.resume();
+    if (fd != null && !out) try { fs.closeSync(fd); } catch {}
+    if (owned) try { fs.rmSync(target, { force: true }); } catch {}
+    return Promise.reject(e);
+  }
+  return new Promise((resolve, reject) => {
+    let bytes = 0;
+    const cleanup = (err) => {
+      try { res.destroy(); } catch {}
+      try { out.destroy(); } catch {}
+      if (owned) try { fs.rmSync(target, { force: true }); } catch {}
+      reject(err);
+    };
+    if (signal) {
+      if (signal.aborted) return cleanup(Object.assign(new Error("aborted"), { code: "ABORT_ERR" }));
+      signal.addEventListener("abort", () => cleanup(Object.assign(new Error("aborted"), { code: "ABORT_ERR" })), { once: true });
+    }
+    res.on("data", (chunk) => {
+      bytes += chunk.length;
+      if (bytes > maxBytes) cleanup(new Error("file too large"));
+    });
+    res.on("error", cleanup);
+    out.on("error", cleanup);
+    res.pipe(out);
+    out.on("finish", () => {
+      owned = false; // complete file belongs to the caller now
+      resolve({ target, name: path.basename(target) });
+    });
+  });
+}
+
+async function downloadImportUrl(raw, destDir, opts = {}) {
+  const allowLoopback = !!opts.allowLoopback;
+  const maxBytes = opts.maxBytes || MAX_BYTES;
+  const timeoutMs = opts.timeoutMs || TIMEOUT_MS;
+  const signal = opts.signal;
+  let current = parseImportUrl(raw, { allowLoopback });
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    if (signal?.aborted) throw Object.assign(new Error("aborted"), { code: "ABORT_ERR" });
+    await assertPublicTarget(current, { allowLoopback });
+    const res = await requestOnce(current, { signal, timeoutMs });
+    if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+      res.resume();
+      let next;
+      try { next = new URL(res.headers.location, current); }
+      catch { throw new Error("invalid redirect"); }
+      current = parseImportUrl(next.href, { allowLoopback });
+      continue;
+    }
+    if (res.statusCode !== 200) {
+      res.resume();
+      throw new Error("download failed: HTTP " + res.statusCode);
+    }
+    return saveResponse(res, current, destDir, { signal, maxBytes });
+  }
+  throw new Error("too many redirects");
+}
+
+let hasFfmpeg = null;
+function ffmpegAvailable() {
+  if (hasFfmpeg == null) {
+    try { hasFfmpeg = spawnSync("ffmpeg", ["-version"], { stdio: "ignore" }).status === 0; }
+    catch { hasFfmpeg = false; }
+  }
+  return hasFfmpeg;
+}
+function maybeFaststart(file) {
+  if (!ffmpegAvailable() || !FASTSTART_EXT.has(path.extname(file).toLowerCase()))
+    return Promise.resolve();
+  const tmp = file + ".fs" + path.extname(file);
+  return new Promise((resolve) => {
+    execFile("ffmpeg", ["-y", "-i", file, "-c", "copy", "-movflags", "+faststart", tmp],
+      { maxBuffer: 1 << 24 }, (err) => {
+        if (err) { try { fs.rmSync(tmp, { force: true }); } catch {} return resolve(); }
+        try { fs.rmSync(file); fs.renameSync(tmp, file); } catch { try { fs.rmSync(tmp, { force: true }); } catch {} }
+        resolve();
+      });
+  });
+}
+
+module.exports = {
+  downloadImportUrl, parseImportUrl, isBlockedIp, isBlockedHostname,
+  filenameFrom, kindFromName, KIND_BY_EXT, maybeFaststart, MAX_BYTES,
+};