fablecut 0.0.0-stage → 1.12.1

package/meter-worklet.js

@@ -0,0 +1,229 @@
+/* FableCut per-track meter worklet + stereo program sum pass-through.
+   Inputs 0…nAudio−1 = A-track buses; input nAudio = video/other spill on master.
+   Pass-through sum → stereo out. Per-track RMS/LUFS/Peak via port; master L/R
+   RMS/Peak is metered on the main thread (AnalyserNodes on the worklet output),
+   while master LUFS is computed here on the true summed program output. */
+function shelfCoeffs(fs) {
+  const f0 = 1681.974450955533;
+  const G = 3.999843853973347;
+  const Q = 0.7071752369554196;
+  const K = Math.tan(Math.PI * f0 / fs);
+  const Vh = Math.pow(10, G / 20);
+  const Vb = Math.pow(Vh, 0.5);
+  const a0 = 1 + K / Q + K * K;
+  return {
+    b0: (Vh + Vb * K / Q + K * K) / a0,
+    b1: 2 * (K * K - Vh) / a0,
+    b2: (Vh - Vb * K / Q + K * K) / a0,
+    a1: 2 * (K * K - 1) / a0,
+    a2: (1 - K / Q + K * K) / a0,
+  };
+}
+function hpfCoeffs(fs) {
+  const f0 = 38.13547087613982;
+  const Q = 0.5003270373238773;
+  const K = Math.tan(Math.PI * f0 / fs);
+  const a0 = 1 + K / Q + K * K;
+  return {
+    b0: 1 / a0,
+    b1: -2 / a0,
+    b2: 1 / a0,
+    a1: 2 * (K * K - 1) / a0,
+    a2: (1 - K / Q + K * K) / a0,
+  };
+}
+function makeBiquad(c) {
+  return { b0: c.b0, b1: c.b1, b2: c.b2, a1: c.a1, a2: c.a2, z1: 0, z2: 0 };
+}
+function biquadStep(f, x) {
+  const y = f.b0 * x + f.z1;
+  f.z1 = f.b1 * x - f.a1 * y + f.z2;
+  f.z2 = f.b2 * x - f.a2 * y;
+  return y;
+}
+
+class FableCutMeterProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const opts = (options && options.processorOptions) || {};
+    this._hopBlocks = Math.max(1, opts.hopBlocks || 8);
+    this._nTracks = Math.max(1, opts.nTracks || 1);
+    this._nAudio = Math.max(0, opts.nAudioTracks ?? opts.nTracks ?? 1);
+    // When set, that input is the finished program: only it reaches the
+    // output (and the master LUFS); the others are metering taps. Unset =
+    // every input is summed (the original layout).
+    this._program = Number.isInteger(opts.programInput) ? opts.programInput : -1;
+    this._block = 0;
+    this._sumSqL = new Float64Array(this._nTracks);
+    this._sumSqR = new Float64Array(this._nTracks);
+    this._peak = new Float64Array(this._nTracks);
+    this._sumSqK = new Float64Array(this._nTracks);
+    this._frames = 0;
+
+    const shelf = shelfCoeffs(sampleRate);
+    const hpf = hpfCoeffs(sampleRate);
+    this._shelfL = [];
+    this._hpfL = [];
+    this._shelfR = [];
+    this._hpfR = [];
+    for (let t = 0; t < this._nTracks; t++) {
+      this._shelfL.push(makeBiquad(shelf));
+      this._hpfL.push(makeBiquad(hpf));
+      this._shelfR.push(makeBiquad(shelf));
+      this._hpfR.push(makeBiquad(hpf));
+    }
+
+    // Filters for the summed program output so the master LUFS is the true
+    // post-mix reading, not an approximation from per-track values.
+    this._shelfOutL = makeBiquad(shelf);
+    this._hpfOutL = makeBiquad(hpf);
+    this._shelfOutR = makeBiquad(shelf);
+    this._hpfOutR = makeBiquad(hpf);
+    this._sumSqKOut = 0;
+
+    // Momentary = 400 ms of block mean-squares (BS.1770) — per A-track + program.
+    const hopFrames = 128 * this._hopBlocks;
+    this._lufsLen = Math.max(1, Math.round(0.4 * sampleRate / hopFrames));
+    this._lufsRing = [];
+    this._lufsIdx = [];
+    this._lufsFilled = [];
+    for (let t = 0; t < this._nTracks; t++) {
+      this._lufsRing.push(new Float64Array(this._lufsLen));
+      this._lufsIdx.push(0);
+      this._lufsFilled.push(0);
+    }
+    this._lufsRingOut = new Float64Array(this._lufsLen);
+    this._lufsIdxOut = 0;
+    this._lufsFilledOut = 0;
+  }
+
+  process(inputs, outputs) {
+    const output = outputs[0];
+    const outL = output && output[0];
+    const outR = output && output[1];
+    if (outL) outL.fill(0);
+    if (outR) outR.fill(0);
+
+    let frames = 0;
+    for (let t = 0; t < this._nTracks; t++) {
+      const chans = inputs[t];
+      const has = chans && chans[0];
+      const L = has ? chans[0] : null;
+      // Never mirror L→R: post-pan buses are stereo; mono input = one channel only.
+      const hasR = has && chans.length > 1 && chans[1];
+      const R = hasR ? chans[1] : null;
+      const n = L ? L.length : (outL ? outL.length : 128);
+      frames = n;
+
+      let sumL = this._sumSqL[t];
+      let sumR = this._sumSqR[t];
+      let peak = this._peak[t];
+      let sumK = this._sumSqK[t];
+      const sL = this._shelfL[t], hL = this._hpfL[t];
+      const sR = this._shelfR[t], hR = this._hpfR[t];
+
+      for (let i = 0; i < n; i++) {
+        const l = L ? L[i] : 0;
+        const r = R ? R[i] : 0;
+        sumL += l * l;
+        sumR += r * r;
+        const aL = l >= 0 ? l : -l;
+        const aR = r >= 0 ? r : -r;
+        if (aL > peak) peak = aL;
+        if (aR > peak) peak = aR;
+
+        const fl = biquadStep(hL, biquadStep(sL, l));
+        const fr = biquadStep(hR, biquadStep(sR, r));
+        sumK += fl * fl + fr * fr;
+
+        if (this._program < 0 || t === this._program) {
+          if (outL) outL[i] += l;
+          if (outR) outR[i] += r;
+        }
+      }
+      this._sumSqL[t] = sumL;
+      this._sumSqR[t] = sumR;
+      this._peak[t] = peak;
+      this._sumSqK[t] = sumK;
+    }
+
+    // Filter the summed program output for a true master LUFS reading.
+    if (outL && outR && frames > 0) {
+      const sL = this._shelfOutL, hL = this._hpfOutL;
+      const sR = this._shelfOutR, hR = this._hpfOutR;
+      let sumK = this._sumSqKOut;
+      for (let i = 0; i < frames; i++) {
+        const fl = biquadStep(hL, biquadStep(sL, outL[i]));
+        const fr = biquadStep(hR, biquadStep(sR, outR[i]));
+        sumK += fl * fl + fr * fr;
+      }
+      this._sumSqKOut = sumK;
+    }
+
+    if (frames) this._frames += frames;
+    this._block++;
+
+    if (this._block >= this._hopBlocks) {
+      const n = Math.max(1, this._frames);
+      const rms = new Array(this._nAudio);
+      const peak = new Array(this._nAudio);
+      const lufs = new Array(this._nAudio);
+      for (let t = 0; t < this._nAudio; t++) {
+        // Track bar follows the louder channel so a mono stem panned hard L/R
+        // (or any stereo track) stays in sync with the per-channel master meters.
+        const rmsL = Math.sqrt(this._sumSqL[t] / n);
+        const rmsR = Math.sqrt(this._sumSqR[t] / n);
+        rms[t] = Math.max(rmsL, rmsR);
+        peak[t] = this._peak[t];
+
+        // Channel-weighted mean square for this hop (L+R, G=1 each)
+        const blockMs = this._sumSqK[t] / n;
+        const ring = this._lufsRing[t];
+        const idx = this._lufsIdx[t];
+        ring[idx] = blockMs;
+        this._lufsIdx[t] = (idx + 1) % this._lufsLen;
+        if (this._lufsFilled[t] < this._lufsLen) this._lufsFilled[t]++;
+        let acc = 0;
+        const filled = this._lufsFilled[t];
+        for (let i = 0; i < filled; i++) acc += ring[i];
+        const meanMs = acc / Math.max(1, filled);
+        lufs[t] = meanMs > 1e-12 ? -0.691 + 10 * Math.log10(meanMs) : -70;
+
+        this._sumSqL[t] = 0;
+        this._sumSqR[t] = 0;
+        this._peak[t] = 0;
+        this._sumSqK[t] = 0;
+      }
+
+      // Program LUFS from the actual summed output (includes video spill).
+      let masterLufs = -70;
+      if (outL && outR) {
+        const blockMs = this._sumSqKOut / n;
+        const ring = this._lufsRingOut;
+        const idx = this._lufsIdxOut;
+        ring[idx] = blockMs;
+        this._lufsIdxOut = (idx + 1) % this._lufsLen;
+        if (this._lufsFilledOut < this._lufsLen) this._lufsFilledOut++;
+        let acc = 0;
+        for (let i = 0; i < this._lufsFilledOut; i++) acc += ring[i];
+        const meanMs = acc / Math.max(1, this._lufsFilledOut);
+        masterLufs = meanMs > 1e-12 ? -0.691 + 10 * Math.log10(meanMs) : -70;
+        this._sumSqKOut = 0;
+      }
+
+      this.port.postMessage({
+        type: "meter",
+        rms,
+        peak,
+        lufs,
+        masterLufs,
+        frames: n,
+      });
+      this._block = 0;
+      this._frames = 0;
+    }
+    return true;
+  }
+}
+
+registerProcessor("fablecut-meter", FableCutMeterProcessor);

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "fablecut",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.12.1",
+  "description": "Zero-dependency browser video editor that AI agents can drive — JSON timeline, MCP server, REST API, live-reloading UI.",
+  "main": "server.js",
+  "bin": {
+    "fablecut": "cli.js"
+  },
+  "files": [
+    "*.js",
+    "index.html",
+    "style.css",
+    "favicon.svg",
+    "icons/",
+    "encoding-profiles.json",
+    "CLAUDE.md",
+    "library/README.md",
+    "library/elements/",
+    "library/fonts/",
+    "library/svg/",
+    "library/sfx/README.md"
+  ],
+  "scripts": {
+    "start": "node server.js",
+    "test": "node --test"
+  },
+  "keywords": [
+    "video-editor",
+    "nle",
+    "timeline",
+    "canvas",
+    "mcp",
+    "claude",
+    "ai-agent",
+    "ffmpeg"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ronak-create/FableCut.git"
+  },
+  "homepage": "https://fablecut.space",
+  "mcpName": "io.github.ronak-create/fablecut",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/paths.js

@@ -0,0 +1,106 @@
+/* ═══════════════════════════════════════════════════════════════════════════
+   Where things live.
+
+   Two roots, because they have different lifetimes:
+
+     APP_DIR   the checked-out code and the assets that ship with it. Read-only
+               in practice. When FableCut is installed as a Claude Code plugin
+               this directory is pinned to a commit and REPLACED on every update.
+
+     DATA_DIR  the user's work — project.json, imported media, exports, cached
+               analysis. Must outlive an update.
+
+   Standalone (`node server.js`) they are the same directory, which is exactly
+   how FableCut has always behaved. Set FABLECUT_DATA_DIR to split them; the
+   plugin sets it to ${CLAUDE_PLUGIN_DATA}. Installed from npm (the code sits
+   under node_modules, e.g. the npx cache) the default is ~/FableCut.
+   ═══════════════════════════════════════════════════════════════════════════ */
+"use strict";
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const APP_DIR = __dirname;
+const FROM_NPM = APP_DIR.split(path.sep).includes("node_modules");
+const DATA_DIR = process.env.FABLECUT_DATA_DIR
+  ? path.resolve(process.env.FABLECUT_DATA_DIR)
+  : FROM_NPM ? path.join(os.homedir(), "FableCut") : APP_DIR;
+const SPLIT = DATA_DIR !== APP_DIR;
+
+const MEDIA_DIR = path.join(DATA_DIR, "media");
+const EXPORTS_DIR = path.join(DATA_DIR, "exports");
+const ANALYSIS_DIR = path.join(DATA_DIR, "analysis");
+const LIBRARY_DIR = path.join(DATA_DIR, "library");
+const PROJECT_FILE = path.join(DATA_DIR, "project.json");
+const LIBRARY_SUBDIRS = ["sfx", "elements", "svg", "fonts"];
+
+/* The asset library ships with the repo but users also drop their own files in
+   (library/sfx is gitignored precisely for that). When the data dir is split
+   off, copy the shipped assets across once so the library is populated, then
+   leave it alone — a later update re-copies only what the user deleted or has
+   never seen, and never clobbers a file they put there. */
+function seedLibrary() {
+  if (!SPLIT) return;
+  const src = path.join(APP_DIR, "library");
+  if (!fs.existsSync(src)) return;
+  const walk = (from, to) => {
+    fs.mkdirSync(to, { recursive: true });
+    for (const e of fs.readdirSync(from, { withFileTypes: true })) {
+      const a = path.join(from, e.name), b = path.join(to, e.name);
+      if (e.isDirectory()) walk(a, b);
+      else if (!fs.existsSync(b) || superseded(path.relative(src, a), b)) fs.copyFileSync(a, b);
+    }
+  };
+  walk(src, LIBRARY_DIR);
+}
+
+/* Shipped files that a later release replaced. Seeding never overwrites, so
+   an old copy has to be recognised to be swapped out: one still byte-identical
+   to what we shipped (sha256, first 16 hex) was never edited by the user.
+   The fonts in 1.0-1.9.0 were the wrong Unicode subset, with no basic Latin. */
+const SUPERSEDED = {
+  "fonts/Abril Fatface.woff2": "c7cc6ab22643e87e",
+  "fonts/Anton.woff2": "82cc85bd416dc825",
+  "fonts/Archivo Black.woff2": "a69dfe4ff8ea7fd2",
+  "fonts/Bangers.woff2": "3275f18f37839309",
+  "fonts/Barlow.woff2": "d9bb523921d15e2b",
+  "fonts/Bebas Neue.woff2": "16c95ce45a2922f5",
+  "fonts/Bungee.woff2": "73d615497987a45a",
+  "fonts/Caveat.woff2": "f225d05db8fd2872",
+  "fonts/DM Sans.woff2": "6406eb05e2eb5077",
+  "fonts/Inter.woff2": "1c2db92d3cd9b237",
+  "fonts/Lato.woff2": "3a5797f440bc67b5",
+  "fonts/Montserrat.woff2": "5cdc3c54c076ef8c",
+  "fonts/Oswald.woff2": "cbcfd4dce7316ca4",
+  "fonts/Pacifico.woff2": "566fd7603618daf7",
+  "fonts/Playfair Display.woff2": "cfbfb0e36791f824",
+  "fonts/Poppins.woff2": "58dba357cb1e89bf",
+  "fonts/Righteous.woff2": "5cdd7df84db547c5",
+  "fonts/Roboto.woff2": "a99e7e70a8225591",
+  "fonts/Rubik.woff2": "f60c6ef1b75cff9c",
+  "fonts/Teko.woff2": "facad9bed4914ede",
+};
+function superseded(rel, file) {
+  const old = SUPERSEDED[rel.split(path.sep).join("/")];
+  if (!old) return false;
+  try {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex").startsWith(old);
+  } catch { return false; }
+}
+
+/* Create the writable tree. Safe to call from both servers; whoever runs first
+   wins and the other no-ops. */
+function ensureDirs() {
+  for (const d of [DATA_DIR, MEDIA_DIR, EXPORTS_DIR, ANALYSIS_DIR])
+    fs.mkdirSync(d, { recursive: true });
+  for (const d of LIBRARY_SUBDIRS)
+    fs.mkdirSync(path.join(LIBRARY_DIR, d), { recursive: true });
+  seedLibrary();
+}
+
+module.exports = {
+  APP_DIR, DATA_DIR, SPLIT,
+  MEDIA_DIR, EXPORTS_DIR, ANALYSIS_DIR, LIBRARY_DIR, PROJECT_FILE,
+  LIBRARY_SUBDIRS, ensureDirs,
+};

package/ruler-worker.js

@@ -0,0 +1,120 @@
+/* FableCut timeline-ruler worker.
+   Draws the ruler canvas (ticks, time labels, IN/OUT flags, beat markers,
+   playhead) off the main thread via a transferred OffscreenCanvas. This is a
+   clean Worker candidate — unlike the program-monitor compositor (app.js
+   drawFrame/drawClip), the ruler never touches <video>/<audio> elements or
+   any other main-thread-only DOM state, only the small set of numbers/arrays
+   sent in each "draw" message. Keep this in sync with app.js's drawRuler()
+   fallback (used when OffscreenCanvas/transferControlToOffscreen isn't
+   available) if the look changes. */
+let cv = null, g = null;
+
+function fmt(t, fps) {
+  t = Math.max(0, t);
+  const m = Math.floor(t / 60), s = Math.floor(t % 60),
+    f = Math.floor((t % 1) * (fps > 0 ? fps : 1));
+  const p = (n) => String(n).padStart(2, "0");
+  return `${p(m)}:${p(s)}:${p(f)}`;
+}
+
+function draw(msg) {
+  if (!g) return;
+  const { w, h, dpr, sl, pps, markers, markerColors, inPoint, outPoint, time, fps } = msg;
+  const bw = Math.round(w * dpr), bh = Math.round(h * dpr);
+  if (cv.width !== bw || cv.height !== bh) { cv.width = bw; cv.height = bh; }
+  g.setTransform(dpr, 0, 0, dpr, 0, 0);
+  g.clearRect(0, 0, w, h);
+  const steps = [0.1, 0.25, 0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300];
+  const step = steps.find((s) => s * pps >= 70) || 600;
+  const minor = step / 5;
+  const i0 = Math.max(0, Math.floor(sl / pps / minor));
+  // ticks + time labels first so IN/OUT can difference-blend over them
+  g.strokeStyle = "#4a4a55";
+  g.fillStyle = "#9a9aa6";
+  g.font = "10px Consolas, monospace";
+  g.beginPath();
+  for (let i = i0; i * minor * pps < sl + w; i++) {
+    const t = i * minor;
+    const x = Math.round(t * pps - sl) + 0.5;
+    const isMajor = i % 5 === 0;
+    g.moveTo(x, isMajor ? 8 : 17); g.lineTo(x, h);
+    if (isMajor) g.fillText(fmt(Math.round(t * 1000) / 1000, fps).slice(0, 5), x + 4, 12);
+  }
+  g.stroke();
+  // dim timeline outside the IN–OUT work area
+  if (inPoint != null && outPoint != null && outPoint > inPoint) {
+    const x0 = inPoint * pps - sl, x1 = outPoint * pps - sl;
+    g.fillStyle = "#00000055";
+    if (x0 > 0) g.fillRect(0, 0, Math.min(w, x0), h);
+    if (x1 < w) g.fillRect(Math.max(0, x1), 0, w - Math.max(0, x1), h);
+  }
+  // beat/cue markers — coloured diamonds, name to the right (clipped at the next marker)
+  const mks = markers || [];
+  for (let i = 0; i < mks.length; i++) {
+    const mk = mks[i], x = mk.t * pps - sl;
+    if (x < -6 || x > w + 6) {
+      if (!mk.label || x > w) continue;
+    }
+    const col = (markerColors && markerColors[mk.color]) || "#ffd166";
+    g.fillStyle = col;
+    g.beginPath();
+    g.moveTo(x, h - 9); g.lineTo(x + 4, h - 5); g.lineTo(x, h - 1); g.lineTo(x - 4, h - 5);
+    g.closePath(); g.fill();
+    if (mk.label) {
+      const next = mks[i + 1] ? mks[i + 1].t * pps - sl : w;
+      const room = Math.min(next - x - 10, 160);
+      if (room > 14) {
+        g.save();
+        g.beginPath(); g.rect(x + 6, h - 12, room, 12); g.clip();
+        g.font = "9px system-ui, sans-serif";
+        const tw = g.measureText(mk.label).width;
+        g.fillStyle = "#101014cc";
+        g.fillRect(x + 6, h - 11, Math.min(tw + 6, room), 10);
+        g.fillStyle = col;
+        g.fillText(mk.label, x + 9, h - 3);
+        g.restore();
+      }
+    }
+  }
+  // IN / OUT — bottom-aligned; `difference` keeps time glyphs readable where they overlap
+  const mkH = (h - 4) * 0.75, bot = h - 1, top = bot - mkH, mid = (top + bot) / 2;
+  g.globalCompositeOperation = "difference";
+  if (inPoint != null) {
+    const x = inPoint * pps - sl;
+    if (x >= -10 && x <= w + 10) {
+      g.fillStyle = "#5eead4";
+      g.beginPath();
+      g.moveTo(x, top); g.lineTo(x, bot); g.lineTo(x + 8, mid);
+      g.closePath(); g.fill();
+    }
+  }
+  if (outPoint != null) {
+    const x = outPoint * pps - sl;
+    if (x >= -10 && x <= w + 10) {
+      g.fillStyle = "#fb923c";
+      g.beginPath();
+      g.moveTo(x, top); g.lineTo(x, bot); g.lineTo(x - 8, mid);
+      g.closePath(); g.fill();
+    }
+  }
+  g.globalCompositeOperation = "source-over";
+  // playhead marker on ruler
+  const px = time * pps - sl;
+  if (px >= -8 && px <= w + 8) {
+    g.fillStyle = "#ff4d6a";
+    g.beginPath();
+    g.moveTo(px - 6, 12); g.lineTo(px + 6, 12); g.lineTo(px + 6, 19); g.lineTo(px, 25); g.lineTo(px - 6, 19);
+    g.closePath(); g.fill();
+  }
+}
+
+self.onmessage = (ev) => {
+  const msg = ev.data;
+  if (!msg) return;
+  if (msg.type === "init") {
+    cv = msg.canvas;
+    g = cv.getContext("2d");
+  } else if (msg.type === "draw") {
+    draw(msg);
+  }
+};