@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/beat-analyzer.global.js

@@ -0,0 +1,338 @@
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // ../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/detect.js
+  var require_detect = __commonJS({
+    "../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/detect.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {
+        value: true
+      });
+      exports.default = detect;
+      var OfflineContext = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+      function detect(buffer) {
+        var source = getLowPassSource(buffer);
+        source.start(0);
+        return [findPeaks, identifyIntervals, groupByTempo(buffer.sampleRate), getTopCandidate].reduce(function(state, fn) {
+          return fn(state);
+        }, source.buffer.getChannelData(0));
+      }
+      function getTopCandidate(candidates) {
+        return candidates.sort(function(a, b) {
+          return b.count - a.count;
+        }).splice(0, 5)[0].tempo;
+      }
+      function getLowPassSource(buffer) {
+        var length = buffer.length, numberOfChannels = buffer.numberOfChannels, sampleRate = buffer.sampleRate;
+        var context = new OfflineContext(numberOfChannels, length, sampleRate);
+        var source = context.createBufferSource();
+        source.buffer = buffer;
+        var filter = context.createBiquadFilter();
+        filter.type = "lowpass";
+        source.connect(filter);
+        filter.connect(context.destination);
+        return source;
+      }
+      function findPeaks(data) {
+        var peaks = [];
+        var threshold = 0.9;
+        var minThresold = 0.3;
+        var minPeaks = 15;
+        while (peaks.length < minPeaks && threshold >= minThresold) {
+          peaks = findPeaksAtThreshold(data, threshold);
+          threshold -= 0.05;
+        }
+        if (peaks.length < minPeaks) {
+          throw new Error("Could not find enough samples for a reliable detection.");
+        }
+        return peaks;
+      }
+      function findPeaksAtThreshold(data, threshold) {
+        var peaks = [];
+        for (var i = 0, l = data.length; i < l; i += 1) {
+          if (data[i] > threshold) {
+            peaks.push(i);
+            i += 1e4;
+          }
+        }
+        return peaks;
+      }
+      function identifyIntervals(peaks) {
+        var intervals = [];
+        peaks.forEach(function(peak, index) {
+          var _loop = function _loop2(i2) {
+            var interval = peaks[index + i2] - peak;
+            var foundInterval = intervals.some(function(intervalCount) {
+              if (intervalCount.interval === interval) {
+                return intervalCount.count += 1;
+              }
+            });
+            if (!foundInterval) {
+              intervals.push({
+                interval,
+                count: 1
+              });
+            }
+          };
+          for (var i = 0; i < 10; i += 1) {
+            _loop(i);
+          }
+        });
+        return intervals;
+      }
+      function groupByTempo(sampleRate) {
+        return function(intervalCounts) {
+          var tempoCounts = [];
+          intervalCounts.forEach(function(intervalCount) {
+            if (intervalCount.interval !== 0) {
+              var theoreticalTempo = 60 / (intervalCount.interval / sampleRate);
+              while (theoreticalTempo < 90) {
+                theoreticalTempo *= 2;
+              }
+              while (theoreticalTempo > 180) {
+                theoreticalTempo /= 2;
+              }
+              theoreticalTempo = Math.round(theoreticalTempo);
+              var foundTempo = tempoCounts.some(function(tempoCount) {
+                if (tempoCount.tempo === theoreticalTempo) {
+                  return tempoCount.count += intervalCount.count;
+                }
+              });
+              if (!foundTempo) {
+                tempoCounts.push({
+                  tempo: theoreticalTempo,
+                  count: intervalCount.count
+                });
+              }
+            }
+          });
+          return tempoCounts;
+        };
+      }
+    }
+  });
+
+  // ../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/index.js
+  var require_lib = __commonJS({
+    "../../node_modules/.bun/bpm-detective@2.0.5/node_modules/bpm-detective/lib/index.js"(exports, module) {
+      module.exports = require_detect().default;
+    }
+  });
+
+  // ../core/src/beats/beatDetection.ts
+  var bpmDetectivePromise = null;
+  var defaultBpmDetectiveImport = () => (
+    // @ts-ignore -- no type declarations for bpm-detective
+    Promise.resolve().then(() => __toESM(require_lib(), 1))
+  );
+  function loadBpmDetective(importFn = defaultBpmDetectiveImport) {
+    const useCache = importFn === defaultBpmDetectiveImport;
+    if (useCache && bpmDetectivePromise) {
+      return bpmDetectivePromise;
+    }
+    const promise = importFn().then((m) => (m.default ?? m) || null).catch(() => {
+      if (useCache) bpmDetectivePromise = null;
+      return null;
+    });
+    if (useCache) {
+      bpmDetectivePromise = promise;
+    }
+    return promise;
+  }
+  var WINDOW_SIZE = 1024;
+  var HOP_SIZE = 512;
+  var STRENGTH_WINDOW_S = 0.05;
+  function computeRmsAt(channelData, sampleRate, time) {
+    const halfWindow = Math.floor(sampleRate * STRENGTH_WINDOW_S);
+    const center = Math.floor(time * sampleRate);
+    const start = Math.max(0, center - halfWindow);
+    const end = Math.min(channelData.length, center + halfWindow);
+    let sum = 0;
+    for (let i = start; i < end; i++) {
+      const s = channelData[i] ?? 0;
+      sum += s * s;
+    }
+    return Math.sqrt(sum / Math.max(end - start, 1));
+  }
+  async function detectBeats(audioBuffer) {
+    const channelData = audioBuffer.getChannelData(0);
+    const sampleRate = audioBuffer.sampleRate;
+    const energies = [];
+    for (let i = 0; i < channelData.length - WINDOW_SIZE; i += HOP_SIZE) {
+      let sum = 0;
+      for (let j = 0; j < WINDOW_SIZE; j++) {
+        const sample = channelData[i + j];
+        sum += sample * sample;
+      }
+      energies.push(sum / WINDOW_SIZE);
+    }
+    const beats = [];
+    const localWindowSize = 20;
+    for (let i = localWindowSize; i < energies.length - localWindowSize; i++) {
+      let localMean = 0;
+      for (let j = i - localWindowSize; j < i + localWindowSize; j++) {
+        localMean += energies[j];
+      }
+      localMean /= localWindowSize * 2;
+      const threshold = localMean * 1.5;
+      const current = energies[i];
+      if (current > threshold && current > (energies[i - 1] ?? 0) && current > (energies[i + 1] ?? 0)) {
+        const timeInSeconds = i * HOP_SIZE / sampleRate;
+        if (beats.length === 0 || timeInSeconds - beats[beats.length - 1] > 0.1) {
+          beats.push(Math.round(timeInSeconds * 1e3) / 1e3);
+        }
+      }
+    }
+    return beats;
+  }
+  function computeBpmFromBeats(beatTimes) {
+    if (beatTimes.length < 4) return null;
+    const iois = [];
+    for (let i = 1; i < beatTimes.length; i++) {
+      iois.push(beatTimes[i] - beatTimes[i - 1]);
+    }
+    const sorted = [...iois].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    const medianIoi = sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+    if (medianIoi <= 0) return null;
+    return Math.round(60 / medianIoi * 10) / 10;
+  }
+  function canonicalizeBpm(bpm) {
+    let b = bpm;
+    while (b > 120) b /= 2;
+    while (b < 60) b *= 2;
+    return b;
+  }
+  function octaveAlignBpm(bpm, reference) {
+    const candidates = [bpm / 2, bpm, bpm * 2];
+    let best = bpm;
+    let bestDist = Number.POSITIVE_INFINITY;
+    for (const c of candidates) {
+      if (c <= 0) continue;
+      const dist = Math.abs(c - reference);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = c;
+      }
+    }
+    return best;
+  }
+  function regularizeBeats(rawBeats, bpm, duration) {
+    if (rawBeats.length === 0 || bpm <= 0 || duration <= 0) return rawBeats;
+    const beatInterval = 60 / bpm;
+    if (beatInterval < 0.125) return rawBeats;
+    const threshold = beatInterval * 0.25;
+    let bestOffset = 0;
+    let bestScore = -1;
+    for (const anchor of rawBeats.slice(0, 10)) {
+      const offset = (anchor % beatInterval + beatInterval) % beatInterval;
+      let score = 0;
+      for (const rb of rawBeats) {
+        const phase = (rb % beatInterval + beatInterval) % beatInterval;
+        const dist = Math.min(Math.abs(phase - offset), beatInterval - Math.abs(phase - offset));
+        if (dist < threshold) score++;
+      }
+      if (score > bestScore) {
+        bestScore = score;
+        bestOffset = offset;
+      }
+    }
+    const beats = [];
+    for (let t = bestOffset; t <= duration + 1e-3; t += beatInterval) {
+      beats.push(Math.round(t * 1e3) / 1e3);
+    }
+    return beats;
+  }
+  function gateBeatsBySilence(beats, channelData, sampleRate) {
+    if (beats.length === 0) return { times: beats, strengths: [], peak: 1e-6 };
+    const energies = beats.map((t) => computeRmsAt(channelData, sampleRate, t));
+    const peak = Math.max(...energies, 1e-6);
+    const threshold = peak * 0.12;
+    const times = [];
+    const strengths = [];
+    for (let i = 0; i < beats.length; i++) {
+      if (energies[i] >= threshold) {
+        times.push(beats[i]);
+        strengths.push(Math.min(1, energies[i] / peak));
+      }
+    }
+    return { times, strengths, peak };
+  }
+  async function analyzeMusicFromBuffer(audioBuffer) {
+    const channelData = audioBuffer.getChannelData(0);
+    const sampleRate = audioBuffer.sampleRate;
+    const duration = audioBuffer.duration;
+    const rawBeats = await detectBeats(audioBuffer);
+    const onsetBpm = computeBpmFromBeats(rawBeats);
+    let detectiveBpm = null;
+    try {
+      const detect = await loadBpmDetective();
+      if (detect) detectiveBpm = detect(audioBuffer);
+    } catch {
+    }
+    let bpm = onsetBpm;
+    let confidence = "uncertain";
+    let regularizeBpm = null;
+    if (onsetBpm !== null && detectiveBpm !== null) {
+      const pctDiff = Math.abs(canonicalizeBpm(onsetBpm) - canonicalizeBpm(detectiveBpm)) / canonicalizeBpm(detectiveBpm);
+      if (pctDiff < 0.05) {
+        bpm = octaveAlignBpm(detectiveBpm, onsetBpm);
+        confidence = "high";
+        regularizeBpm = bpm;
+      } else if (pctDiff < 0.1) {
+        bpm = Math.round((onsetBpm + detectiveBpm) / 2);
+        confidence = "low";
+        regularizeBpm = bpm;
+      } else {
+        bpm = onsetBpm;
+        confidence = "uncertain";
+      }
+    } else if (onsetBpm !== null) {
+      bpm = onsetBpm;
+      confidence = "low";
+      regularizeBpm = onsetBpm;
+    } else if (detectiveBpm !== null) {
+      bpm = detectiveBpm;
+      confidence = "low";
+      regularizeBpm = detectiveBpm;
+    }
+    const gridBeats = regularizeBpm !== null ? regularizeBeats(rawBeats, regularizeBpm, duration) : rawBeats;
+    const gated = gateBeatsBySilence(gridBeats, channelData, sampleRate);
+    return {
+      beatTimes: gated.times,
+      beatStrengths: gated.strengths,
+      bpm,
+      bpmConfidence: confidence,
+      channelData,
+      sampleRate,
+      peak: gated.peak
+    };
+  }
+
+  // <stdin>
+  globalThis.__hfAnalyze = analyzeMusicFromBuffer;
+})();

package/vendor/hyperframes/dist/beats-Y2EOP72P.js

@@ -0,0 +1,309 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  launchManagedBrowser
+} from "./chunk-7HG4BFIN.js";
+import {
+  resolveProject
+} from "./chunk-S3D6GE5W.js";
+import "./chunk-IHFUKJOR.js";
+import "./chunk-XS4EJSKU.js";
+import "./chunk-JTHMTOMQ.js";
+import "./chunk-EISRN4E6.js";
+import "./chunk-VWG7OQKU.js";
+import {
+  c
+} from "./chunk-ZTZA4UWZ.js";
+import "./chunk-IUZFXWSV.js";
+import "./chunk-AMKC3AXA.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import {
+  failCommand
+} from "./chunk-PBN6GBJE.js";
+import "./chunk-K2FTXJYH.js";
+import "./chunk-2YN64IN5.js";
+import "./chunk-AVUUN2XD.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-Z6B37SNM.js";
+import "./chunk-HWKCIWQT.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-TWWSYAKJ.js";
+import "./chunk-ZJUKFZ2P.js";
+import "./chunk-HBBJFK6I.js";
+import "./chunk-PJ3HDUCY.js";
+import "./chunk-TQFG7HTI.js";
+import "./chunk-GK4AIFIH.js";
+import "./chunk-2PSPARWP.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-FLWXXDNS.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-PMRBLBUP.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/beats.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, mkdirSync, writeFileSync } from "fs";
+import { resolve, join as join2, dirname as dirname2 } from "path";
+
+// ../core/dist/beats/beatFile.js
+function audioRelPathForSrc(src) {
+  if (!src)
+    return null;
+  if (/^(blob:|data:)/i.test(src))
+    return null;
+  let rel = null;
+  const PREVIEW = "/preview/";
+  const previewIdx = src.indexOf(PREVIEW);
+  if (previewIdx !== -1) {
+    let after = src.slice(previewIdx + PREVIEW.length);
+    const queryOrHash = after.search(/[?#]/);
+    if (queryOrHash !== -1)
+      after = after.slice(0, queryOrHash);
+    if (after.startsWith("comp/"))
+      after = after.slice("comp/".length);
+    rel = after ? decodeURIComponent(after) : null;
+  }
+  if (!rel) {
+    try {
+      rel = decodeURIComponent(new URL(src, "http://_").pathname);
+    } catch {
+      rel = src;
+    }
+  }
+  if (!rel)
+    return null;
+  rel = rel.replace(/^\/+/, "");
+  return rel || null;
+}
+function serializeBeats(times, strengths, audio) {
+  const beats = times.map((t, i) => ({
+    time: Math.round(t * 1e3) / 1e3,
+    strength: Math.round((strengths[i] ?? 0.5) * 1e3) / 1e3
+  }));
+  const data = { version: 1, audio, beats };
+  return `${JSON.stringify(data, null, 2)}
+`;
+}
+var MUSIC_ID_RE = /\b(music|bgm|soundtrack|background[-_]?music)\b/i;
+function attr(tag, name) {
+  const m = tag.match(new RegExp(`\\b${name}\\s*=\\s*["']([^"']*)["']`, "i"));
+  return m ? m[1] : null;
+}
+function isSoundingVideoTag(tag) {
+  const unquoted = tag.replace(/"[^"]*"|'[^']*'/g, '""');
+  return attr(tag, "data-has-audio") === "true" && !/\smuted(?=[\s/>=])/i.test(unquoted);
+}
+function findMusicAudioSrc(html) {
+  const tags = html.match(/<(?:audio|video)\b[^>]*>/gi) ?? [];
+  for (const tag of tags) {
+    if (/^<video/i.test(tag) && !isSoundingVideoTag(tag))
+      continue;
+    const src = attr(tag, "src");
+    if (!src)
+      continue;
+    const role = attr(tag, "data-timeline-role");
+    if (role) {
+      if (role === "music")
+        return src;
+      continue;
+    }
+    const id = attr(tag, "id");
+    if (id && MUSIC_ID_RE.test(id))
+      return src;
+  }
+  return null;
+}
+
+// src/beats/headlessAnalyzer.ts
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+var bundlePromise = null;
+function findPrebuiltBundle() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(here, "beat-analyzer.global.js"),
+    // dist root (tsup-bundled cli)
+    join(here, "../beat-analyzer.global.js"),
+    // dist/beats → dist
+    join(here, "../dist/beat-analyzer.global.js")
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+async function buildFromCoreSource() {
+  const esbuild = await import("esbuild");
+  const coreRoot = dirname(require2.resolve("@hyperframes/core/package.json"));
+  const entry = join(coreRoot, "src/beats/beatDetection.ts");
+  const result = await esbuild.build({
+    stdin: {
+      contents: `import { analyzeMusicFromBuffer } from ${JSON.stringify(entry)};
+globalThis.__hfAnalyze = analyzeMusicFromBuffer;`,
+      resolveDir: coreRoot,
+      loader: "ts"
+    },
+    bundle: true,
+    format: "iife",
+    platform: "browser",
+    target: "es2020",
+    write: false
+  });
+  const out = result.outputFiles?.[0];
+  if (!out) throw new Error("Failed to bundle beat analyzer");
+  return out.text;
+}
+function buildAnalyzerBundle() {
+  if (bundlePromise) return bundlePromise;
+  bundlePromise = (async () => {
+    const prebuilt = findPrebuiltBundle();
+    if (prebuilt) return readFileSync(prebuilt, "utf8");
+    return buildFromCoreSource();
+  })().catch((err) => {
+    bundlePromise = null;
+    throw err;
+  });
+  return bundlePromise;
+}
+var MAX_AUDIO_BYTES = 80 * 1024 * 1024;
+function inPageAnalyze(data) {
+  const bin = atob(data);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  const win = window;
+  if (typeof win.__hfAnalyze !== "function") throw new Error("beat analyzer not loaded");
+  const ctx = new (win.AudioContext || win.webkitAudioContext)();
+  return ctx.decodeAudioData(bytes.buffer).then((buf) => win.__hfAnalyze(buf)).then((r) => ({
+    beatTimes: r.beatTimes,
+    beatStrengths: r.beatStrengths,
+    bpm: r.bpm,
+    bpmConfidence: r.bpmConfidence
+  })).finally(() => ctx.close());
+}
+async function detectOnPage(page, bundle, b64) {
+  const pageErrors = [];
+  page.on("pageerror", (e) => {
+    pageErrors.push(e.message);
+  });
+  page.on("console", (m) => {
+    if (m.type() === "error") pageErrors.push(m.text());
+  });
+  await page.setContent("<!doctype html><html><body></body></html>");
+  await page.addScriptTag({ content: bundle });
+  try {
+    return await page.evaluate(inPageAnalyze, b64);
+  } catch (err) {
+    const detail = pageErrors.length ? ` (${pageErrors.join("; ")})` : "";
+    throw new Error(`${err instanceof Error ? err.message : String(err)}${detail}`);
+  }
+}
+async function analyzeBeatsHeadless(audioBytes) {
+  if (audioBytes.length > MAX_AUDIO_BYTES) {
+    const mb = Math.round(audioBytes.length / 1e6);
+    throw new Error(
+      `Audio file too large for headless analysis (${mb}MB > ${MAX_AUDIO_BYTES / 1e6}MB).`
+    );
+  }
+  const bundle = await buildAnalyzerBundle();
+  const { ensureBrowser } = await import("./manager-CT3D67CG.js");
+  const puppeteer = await import("puppeteer-core");
+  const browser = await ensureBrowser();
+  const chrome = await launchManagedBrowser(puppeteer.default, {
+    headless: true,
+    executablePath: browser.executablePath,
+    args: ["--no-sandbox", "--disable-dev-shm-usage", "--autoplay-policy=no-user-gesture-required"]
+  });
+  try {
+    const page = await chrome.newPage();
+    return await detectOnPage(page, bundle, audioBytes.toString("base64"));
+  } finally {
+    await chrome.close();
+  }
+}
+
+// src/commands/beats.ts
+var examples = [
+  ["Generate the beat file for the current project", "hyperframes beats"],
+  ["Generate for a specific directory", "hyperframes beats ./my-video"]
+];
+function fail(message) {
+  console.error(c.error(message));
+  failCommand();
+}
+function resolveMusicTarget(project) {
+  const src = findMusicAudioSrc(readFileSync2(project.indexPath, "utf-8"));
+  if (!src) {
+    fail(
+      'No music track found. Add data-timeline-role="music" to the <audio> element, or to a <video data-has-audio="true"> whose own sound is the music (or give it an id like music/bgm/soundtrack).'
+    );
+  }
+  const rel = audioRelPathForSrc(src);
+  if (!rel) fail(`Cannot derive a beat-file path for music src: ${src}`);
+  const audioPath = resolve(project.dir, rel);
+  if (!existsSync2(audioPath)) fail(`Audio file not found: ${rel}`);
+  return { rel, audioPath };
+}
+async function detect(audioPath) {
+  try {
+    return await analyzeBeatsHeadless(readFileSync2(audioPath));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const hint = /chrome|executable|browser|ENOENT/i.test(msg) ? "\nRun: npx hyperframes browser ensure" : "";
+    fail(`Beat detection failed: ${msg}${hint}`);
+  }
+}
+function report(file, result, json) {
+  if (json) {
+    console.log(
+      JSON.stringify({ ok: true, file, count: result.beatTimes.length, bpm: result.bpm }, null, 2)
+    );
+    return;
+  }
+  console.log(
+    c.success(
+      `\u2713 Wrote ${result.beatTimes.length} beats \u2192 ${file} (bpm ${result.bpm ?? "?"}, ${result.bpmConfidence})`
+    )
+  );
+}
+var beats_default = defineCommand({
+  meta: {
+    name: "beats",
+    description: "Detect beats in the music track (headless) and write beats/<audio>.json"
+  },
+  args: {
+    dir: { type: "positional", description: "Project directory", required: false },
+    json: { type: "boolean", description: "Output result as JSON", default: false }
+  },
+  async run({ args }) {
+    const project = resolveProject(args.dir);
+    const { rel, audioPath } = resolveMusicTarget(project);
+    if (!args.json) console.log(c.dim(`Analyzing ${rel} in headless Chrome\u2026`));
+    const result = await detect(audioPath);
+    if (result.beatTimes.length === 0) {
+      fail(`No beats detected in ${rel} \u2014 nothing written. (Track may be silent/ambient.)`);
+    }
+    const outPath = join2(project.dir, "beats", `${rel}.json`);
+    mkdirSync(dirname2(outPath), { recursive: true });
+    writeFileSync(outPath, serializeBeats(result.beatTimes, result.beatStrengths, rel));
+    report(`beats/${rel}.json`, result, Boolean(args.json));
+  }
+});
+export {
+  beats_default as default,
+  examples
+};