@vfrey/vfrey 0.0.1 → 1.0.0-beta.0

package/vendor/framey/dist/batchRender-3HPICDCT.js

@@ -0,0 +1,366 @@
+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 {
+  loadProjectVariableSchema,
+  reportVariableIssues,
+  validateVariablesAgainstSchema
+} from "./chunk-EAMLBAHA.js";
+import {
+  errorBox
+} from "./chunk-P5ZBLXJ6.js";
+import "./chunk-442JNXRM.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-DLA44CMS.js";
+import "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import {
+  normalizeErrorMessage
+} from "./chunk-T2EUWCJE.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/batchRender.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join, resolve, sep } from "path";
+var BatchRenderInputError = class extends Error {
+  title;
+  hint;
+  constructor(title, message, hint) {
+    super(message);
+    this.name = "BatchRenderInputError";
+    this.title = title;
+    this.hint = hint;
+  }
+};
+var PLACEHOLDER_RE = /\{([A-Za-z0-9_.-]+)\}/g;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseJson(raw, source) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new BatchRenderInputError("Invalid JSON in --batch", `${source}: ${normalizeErrorMessage(error)}`);
+  }
+}
+function parseBatchRows(raw, source) {
+  const parsed = parseJson(raw, source);
+  const rows = Array.isArray(parsed) ? parsed : isRecord(parsed) ? parsed.rows : void 0;
+  if (!Array.isArray(rows)) {
+    throw new BatchRenderInputError(
+      "Invalid batch payload",
+      '--batch must be a JSON array of objects, or an object with a "rows" array.'
+    );
+  }
+  if (rows.length === 0) {
+    throw new BatchRenderInputError("Empty batch", `${source} contains zero rows.`);
+  }
+  return rows.map((row, index) => {
+    if (!isRecord(row)) {
+      throw new BatchRenderInputError(
+        "Invalid batch row",
+        `Row ${index} must be a JSON object of variable values.`
+      );
+    }
+    return row;
+  });
+}
+function placeholderValue(row, key, index) {
+  if (key === "index") return String(index);
+  if (!Object.hasOwn(row, key)) {
+    throw new BatchRenderInputError(
+      "Invalid output template",
+      `Missing value for placeholder {${key}} in row ${index}.`
+    );
+  }
+  const value = row[key];
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  throw new BatchRenderInputError(
+    "Invalid output template",
+    `Placeholder {${key}} in row ${index} must resolve to a string, number, or boolean.`
+  );
+}
+function resolveOutputTemplate(template, row, index) {
+  return template.replace(
+    PLACEHOLDER_RE,
+    (_match, key) => placeholderValue(row, key, index)
+  );
+}
+function isSameOrChildPath(path, parent) {
+  return path === parent || path.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+}
+function commonOutputDirectory(outputPaths) {
+  const firstPath = outputPaths[0];
+  if (!firstPath) return resolve("renders");
+  let common = dirname(firstPath);
+  for (const outputPath of outputPaths.slice(1)) {
+    const dir = dirname(outputPath);
+    while (!isSameOrChildPath(dir, common)) {
+      const parent = dirname(common);
+      if (parent === common) return common;
+      common = parent;
+    }
+  }
+  return common;
+}
+function checkOutputCollisions(rows, manifestPath) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const previous = seen.get(row.outputPath);
+    if (previous !== void 0) {
+      throw new BatchRenderInputError(
+        "Batch output collision",
+        `Rows ${previous} and ${row.index} both resolve to ${row.outputPath}.`,
+        "Use placeholders such as {index} or a unique row key in --output."
+      );
+    }
+    if (row.outputPath === manifestPath) {
+      throw new BatchRenderInputError(
+        "Batch output collision",
+        `Row ${row.index} resolves to the manifest path: ${manifestPath}.`
+      );
+    }
+    seen.set(row.outputPath, row.index);
+  }
+}
+function validateBatchVariables(rows, indexPath, strictVariables, quiet, json) {
+  const schema = loadProjectVariableSchema(indexPath);
+  let issueCount = 0;
+  const strictRows = [];
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    if (!row || Object.keys(row).length === 0) continue;
+    const rowIssueCount = reportBatchVariableIssues(row, index, schema, quiet, json);
+    if (rowIssueCount === 0) continue;
+    issueCount += rowIssueCount;
+    if (strictVariables) strictRows.push(index);
+  }
+  if (strictRows.length > 0) {
+    throw new BatchRenderInputError(
+      "Variable validation failed",
+      `Aborting batch due to variable issues in row ${strictRows.join(", ")} (--strict-variables mode).`
+    );
+  }
+  return issueCount;
+}
+function reportBatchVariableIssues(row, index, schema, quiet, json) {
+  const issues = validateVariablesAgainstSchema(row, schema);
+  if (issues.length === 0) return 0;
+  if (!quiet && !json) {
+    console.log("");
+    console.log(c.dim(`Batch row ${index}:`));
+  }
+  reportVariableIssues(issues, { strict: false, quiet: quiet || json });
+  return issues.length;
+}
+function prepareBatchRender(options) {
+  const batchPath = resolve(options.batchPath);
+  const read = options.readFile ?? ((path) => readFileSync(path, "utf8"));
+  let raw;
+  try {
+    raw = read(batchPath);
+  } catch (error) {
+    throw new BatchRenderInputError(
+      "Could not read --batch",
+      `${batchPath}: ${normalizeErrorMessage(error)}`
+    );
+  }
+  const variableRows = parseBatchRows(raw, batchPath);
+  const rows = variableRows.map((variables, index) => ({
+    index,
+    variables,
+    outputPath: resolve(resolveOutputTemplate(options.outputTemplate, variables, index))
+  }));
+  const manifestPath = join(
+    commonOutputDirectory(rows.map((row) => row.outputPath)),
+    "manifest.json"
+  );
+  if (manifestPath === batchPath) {
+    throw new BatchRenderInputError(
+      "Batch manifest collision",
+      `The generated manifest would overwrite the batch input: ${batchPath}.`,
+      "Use a separate output directory in --output, such as renders/{index}.mp4."
+    );
+  }
+  checkOutputCollisions(rows, manifestPath);
+  const variableIssueCount = validateBatchVariables(
+    variableRows,
+    options.indexPath,
+    options.strictVariables,
+    options.quiet,
+    options.json
+  );
+  return {
+    batchPath,
+    manifestPath,
+    variableIssueCount,
+    rows
+  };
+}
+function makeInitialManifest(prepared) {
+  return {
+    version: 1,
+    batchPath: prepared.batchPath,
+    manifestPath: prepared.manifestPath,
+    total: prepared.rows.length,
+    completed: 0,
+    failed: 0,
+    skipped: 0,
+    rows: prepared.rows.map((row) => ({
+      index: row.index,
+      outputPath: row.outputPath,
+      status: "pending",
+      durationMs: null,
+      renderTimeMs: null,
+      error: null,
+      startedAt: null,
+      completedAt: null,
+      variables: row.variables
+    }))
+  };
+}
+function summarizeManifest(manifest) {
+  manifest.completed = manifest.rows.filter((row) => row.status === "completed").length;
+  manifest.failed = manifest.rows.filter((row) => row.status === "failed").length;
+  manifest.skipped = manifest.rows.filter((row) => row.status === "skipped").length;
+}
+function writeManifest(manifest) {
+  summarizeManifest(manifest);
+  mkdirSync(dirname(manifest.manifestPath), { recursive: true });
+  writeFileSync(manifest.manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+}
+async function renderBatchRow(row, manifest, options) {
+  const manifestRow = manifest.rows[row.index];
+  if (!manifestRow) {
+    throw new Error(`Batch manifest is missing row ${row.index}`);
+  }
+  manifestRow.status = "running";
+  manifestRow.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeManifest(manifest);
+  if (!options.quiet && !options.json) {
+    console.log(c.dim(`Batch row ${row.index}: ${row.outputPath}`));
+  }
+  try {
+    mkdirSync(dirname(row.outputPath), { recursive: true });
+    const result = await options.renderOne(row);
+    manifestRow.status = "completed";
+    manifestRow.durationMs = result.durationMs ?? null;
+    manifestRow.renderTimeMs = result.renderTimeMs;
+    manifestRow.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeManifest(manifest);
+    return true;
+  } catch (error) {
+    manifestRow.status = "failed";
+    manifestRow.error = normalizeErrorMessage(error);
+    manifestRow.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeManifest(manifest);
+    if (!options.quiet && !options.json) {
+      console.log(c.error(`  Row ${row.index} failed: ${manifestRow.error}`));
+    }
+    return false;
+  }
+}
+function markUnstartedRowsSkipped(manifest) {
+  for (const row of manifest.rows) {
+    if (row.status !== "pending") continue;
+    row.status = "skipped";
+    row.error = "Skipped after --batch-fail-fast.";
+    row.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+}
+async function runBatchRender(options) {
+  if (options.concurrency < 1) {
+    throw new BatchRenderInputError(
+      "Invalid batch-concurrency",
+      `Got "${options.concurrency}". Must be a positive integer.`
+    );
+  }
+  const manifest = makeInitialManifest(options.prepared);
+  writeManifest(manifest);
+  if (!options.quiet && !options.json) {
+    console.log("");
+    console.log(
+      c.accent("\u25C6") + `  Batch rendering ${options.prepared.rows.length} rows` + c.dim(` \u2192 ${options.prepared.manifestPath}`)
+    );
+    console.log(c.dim(`   batch concurrency: ${options.concurrency}`));
+    console.log("");
+  }
+  let cursor = 0;
+  let stopLaunching = false;
+  const workerCount = Math.min(options.concurrency, options.prepared.rows.length);
+  await Promise.all(
+    Array.from({ length: workerCount }, async () => {
+      while (!stopLaunching) {
+        const row = options.prepared.rows[cursor];
+        if (!row) return;
+        cursor++;
+        const ok = await renderBatchRow(row, manifest, options);
+        if (!ok && options.failFast) {
+          stopLaunching = true;
+        }
+      }
+    })
+  );
+  if (stopLaunching) markUnstartedRowsSkipped(manifest);
+  writeManifest(manifest);
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        type: "batch-complete",
+        manifestPath: manifest.manifestPath,
+        total: manifest.total,
+        completed: manifest.completed,
+        failed: manifest.failed,
+        skipped: manifest.skipped,
+        rows: manifest.rows
+      })
+    );
+  }
+  if (!options.quiet && !options.json) {
+    console.log("");
+    console.log(
+      manifest.failed > 0 ? c.warn(
+        `Batch complete: ${manifest.completed} completed, ${manifest.failed} failed, ${manifest.skipped} skipped.`
+      ) : c.success(`Batch complete: ${manifest.completed} completed.`)
+    );
+    console.log(c.dim(`Manifest: ${manifest.manifestPath}`));
+  }
+  return manifest;
+}
+function exitBatchRenderInputError(error) {
+  if (error instanceof BatchRenderInputError) {
+    errorBox(error.title, error.message, error.hint);
+    failCommand();
+  }
+  throw error;
+}
+export {
+  BatchRenderInputError,
+  exitBatchRenderInputError,
+  parseBatchRows,
+  prepareBatchRender,
+  resolveOutputTemplate,
+  runBatchRender
+};

package/vendor/framey/dist/beats-HL2BDUZI.js

@@ -0,0 +1,273 @@
+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 {
+  bandFramesOf,
+  decodeAudio,
+  energyMix,
+  rhythm,
+  tempoOf
+} from "./chunk-GGZAM5VH.js";
+import {
+  resolveProject
+} from "./chunk-O7BGSQ5F.js";
+import "./chunk-P5ZBLXJ6.js";
+import "./chunk-GNEFDLFB.js";
+import "./chunk-2UZQHDM7.js";
+import "./chunk-NYEXNSHM.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import "./chunk-ISN5GRYI.js";
+import {
+  c
+} from "./chunk-VORQIH64.js";
+import {
+  failCommand
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-RNV3DM4S.js";
+import "./chunk-DLA44CMS.js";
+import {
+  parseHTMLContent
+} from "./chunk-UJZREAV6.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-X7HBSTCZ.js";
+import {
+  decodeAuthoredAttribute,
+  decodedUrlPath,
+  scanHtmlOpeningTags,
+  walkCompositionDescendants
+} from "./chunk-B7RJV74O.js";
+import "./chunk-DPVXBVLL.js";
+import {
+  isSafePath,
+  resolveWithinProject
+} from "./chunk-OFQWTKPW.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-AHX34EFP.js";
+import "./chunk-T2EUWCJE.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-4P7NX5BM.js";
+import "./chunk-VAS6HQX3.js";
+import "./chunk-6BNTGNGD.js";
+import "./chunk-CZGHFATT.js";
+import "./chunk-PKZ7RK5N.js";
+import "./chunk-W2LGJSEN.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-RXATE6FZ.js";
+import "./chunk-3422KMTD.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/beats.ts
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+
+// ../core/dist/beats/beatDetection.js
+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));
+}
+var HIGH_CONFIDENCE = 0.35;
+function beatStrengths(beats, levels, sampleRate) {
+  const energies = beats.map((t) => computeRmsAt(levels, sampleRate, t));
+  const peak = Math.max(...energies, 1e-6);
+  return { strengths: energies.map((e) => Math.min(1, e / peak)), peak };
+}
+async function analyzeMusicFromSignal(signal, { pause } = {}) {
+  await pause?.();
+  bandFramesOf(signal);
+  await pause?.();
+  const { beats } = rhythm(signal);
+  await pause?.();
+  const channelData = energyMix(signal);
+  const confidence = beats.confidence ?? 0;
+  const times = beats.times;
+  const { strengths, peak } = beatStrengths(times, channelData, signal.sampleRate);
+  const bpm = tempoOf(times).value;
+  return {
+    beatTimes: times,
+    beatStrengths: strengths,
+    bpm,
+    bpmConfidence: bpm === null ? "uncertain" : confidence >= HIGH_CONFIDENCE ? "high" : "low",
+    channelData,
+    sampleRate: signal.sampleRate,
+    peak
+  };
+}
+
+// ../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 ? decodedUrlPath(after) : null;
+  }
+  if (!rel) {
+    try {
+      rel = decodedUrlPath(new URL(src, "http://_").pathname);
+    } catch {
+      rel = decodedUrlPath(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 attribute = tag.attributes.find((value) => value.name === name);
+  return attribute?.kind === "value" ? decodeAuthoredAttribute(attribute.value) : null;
+}
+function isSoundingVideoTag(tag) {
+  return attr(tag, "data-has-audio") === "true" && !tag.attributes.some((attribute) => attribute.name === "muted");
+}
+function isMusicSourceTag(tag) {
+  return tag.closed && (tag.name === "audio" || tag.name === "video" && isSoundingVideoTag(tag));
+}
+function findMusicAudioSrc(html) {
+  for (const tag of scanHtmlOpeningTags(html)) {
+    if (!isMusicSourceTag(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/commands/beats.ts
+var examples = [
+  ["Generate the beat file for the current project", "framey beats"],
+  ["Generate for a specific directory", "framey beats ./my-video"]
+];
+function fail(message) {
+  console.error(c.error(message));
+  failCommand();
+}
+function mediaSrc(element) {
+  return Array.from(element.attributes).find((attribute) => attribute.name.toLowerCase() === "src")?.value ?? null;
+}
+function findMusicSrc(html) {
+  const document = parseHTMLContent(html);
+  walkCompositionDescendants(document, (element) => {
+    const tag = element.tagName.toLowerCase();
+    if (tag !== "audio" && tag !== "video" || mediaSrc(element)) return;
+    const sources = Array.from(element.querySelectorAll("source")).map(mediaSrc).filter((src2) => Boolean(src2));
+    const src = sources.find((value) => !/^https?:\/\//i.test(value)) ?? sources[0];
+    if (src) element.setAttribute("src", src);
+  });
+  return findMusicAudioSrc(document.toString());
+}
+function resolveMusicTarget(project) {
+  const src = findMusicSrc(readFileSync(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 = resolveWithinProject(project.dir, rel);
+  if (!audioPath) fail(`Music src resolves outside the project: ${src}`);
+  if (!existsSync(audioPath)) fail(`Audio file not found: ${rel}`);
+  return { rel, audioPath };
+}
+async function decode(audioPath) {
+  try {
+    const decoded = await decodeAudio(audioPath);
+    if (decoded) return decoded.signal;
+  } catch (err) {
+    fail(`Beat detection failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  fail(`Beat detection failed: ${audioPath} has no audio stream`);
+}
+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 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}\u2026`));
+    const result = await analyzeMusicFromSignal(await decode(audioPath));
+    if (result.beatTimes.length === 0) {
+      fail(`No beats detected in ${rel} \u2014 nothing written. (Track may be silent/ambient.)`);
+    }
+    const outPath = join(project.dir, "beats", `${rel}.json`);
+    if (!isSafePath(project.dir, outPath))
+      fail(`Beat file path resolves outside the project: ${rel}`);
+    mkdirSync(dirname(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
+};