@spark-apps/quickpeek 1.1.1 → 1.1.3

package/dist/index.mjs

@@ -0,0 +1,1857 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/utils.ts
+function getLanguageName(lang) {
+  if (!lang || lang === "en") return null;
+  return LANGUAGE_NAMES[lang] || lang.toUpperCase();
+}
+function hexToASS(hex, alpha = 0) {
+  const clean = hex.replace("#", "");
+  const r = clean.slice(0, 2);
+  const g = clean.slice(2, 4);
+  const b = clean.slice(4, 6);
+  const a = alpha.toString(16).padStart(2, "0").toUpperCase();
+  return `&H${a}${b}${g}${r}`.toUpperCase();
+}
+function rgbaToHex(color) {
+  if (color.startsWith("#")) return color;
+  const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (!match) return "#000000";
+  const r = parseInt(match[1], 10).toString(16).padStart(2, "0");
+  const g = parseInt(match[2], 10).toString(16).padStart(2, "0");
+  const b = parseInt(match[3], 10).toString(16).padStart(2, "0");
+  return `#${r}${g}${b}`.toUpperCase();
+}
+function windowsPathToWSL(path) {
+  const driveMatch = /^([A-Z]):[/\\]/i.exec(path);
+  if (!driveMatch) return null;
+  const drive = driveMatch[1].toLowerCase();
+  return `/mnt/${drive}/${path.slice(3).replace(/\\/g, "/")}`;
+}
+function parsePartial(partial) {
+  if (!partial) return {};
+  const parts = partial.split("-");
+  if (parts.length !== 2) return {};
+  const ts = parts[0] ? parseFloat(parts[0]) : NaN;
+  const te = parts[1] ? parseFloat(parts[1]) : NaN;
+  const result = {};
+  if (!Number.isNaN(ts)) result.trimStart = ts;
+  if (!Number.isNaN(te)) result.trimEnd = te;
+  return result;
+}
+function getErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function toTitleCase(text) {
+  return text.replace(/\w+/g, (word, index) => {
+    if (index === 0) {
+      return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    }
+    if (LOWERCASE_WORDS.has(word.toLowerCase())) {
+      return word.toLowerCase();
+    }
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+  });
+}
+var LANGUAGE_NAMES, LOWERCASE_WORDS;
+var init_utils = __esm({
+  "src/lib/utils.ts"() {
+    "use strict";
+    LANGUAGE_NAMES = {
+      ar: "Arabic",
+      es: "Spanish",
+      fr: "French",
+      de: "German",
+      zh: "Chinese",
+      ja: "Japanese",
+      ko: "Korean",
+      pt: "Portuguese",
+      ru: "Russian",
+      hi: "Hindi",
+      tr: "Turkish",
+      it: "Italian"
+    };
+    LOWERCASE_WORDS = /* @__PURE__ */ new Set([
+      "a",
+      "an",
+      "the",
+      "and",
+      "but",
+      "or",
+      "nor",
+      "for",
+      "yet",
+      "so",
+      "at",
+      "by",
+      "in",
+      "of",
+      "on",
+      "to",
+      "up",
+      "as",
+      "if",
+      "off",
+      "per",
+      "via",
+      "from",
+      "into",
+      "onto",
+      "upon",
+      "with",
+      "over",
+      "under",
+      "than"
+    ]);
+  }
+});
+
+// src/lib/watermark.ts
+function buildWatermarkFilters(opts) {
+  const { tier, videoDuration } = opts;
+  if (tier === "pro") {
+    return "";
+  }
+  if (videoDuration <= WATERMARK_THRESHOLD_SECONDS) {
+    return "";
+  }
+  const filters = [];
+  filters.push(`drawtext=text='qp':fontsize=24:fontcolor=white@0.3:x=w-tw-20:y=h-th-20`);
+  const endTextStart = Math.max(0, videoDuration - END_TEXT_DURATION);
+  const fadeEndTime = endTextStart + END_TEXT_FADE_IN;
+  const alphaExpr = `if(lt(t,${endTextStart}),0,if(lt(t,${fadeEndTime}),(t-${endTextStart})*0.6,0.6))`;
+  filters.push(
+    `drawtext=text='Video made with QuickPeek':fontsize=32:fontcolor=white:x=(w-tw)/2:y=h-80:alpha='${alphaExpr}'`
+  );
+  return filters.join(",");
+}
+var WATERMARK_THRESHOLD_SECONDS, END_TEXT_DURATION, END_TEXT_FADE_IN;
+var init_watermark = __esm({
+  "src/lib/watermark.ts"() {
+    "use strict";
+    WATERMARK_THRESHOLD_SECONDS = 20;
+    END_TEXT_DURATION = 3;
+    END_TEXT_FADE_IN = 1;
+  }
+});
+
+// src/lib/ffmpeg/spawn.ts
+import { spawn } from "child_process";
+function toWSLPath(path) {
+  if (!isWindowsRuntime) return path;
+  return windowsPathToWSL(path) ?? path.replace(/\\/g, "/");
+}
+function convertArgToWSL(arg) {
+  const wslPath = windowsPathToWSL(arg);
+  if (wslPath) return wslPath;
+  if (arg.includes("\\")) return arg.replace(/\\/g, "/");
+  return arg;
+}
+function spawnFFmpeg(cmd, args) {
+  if (isWindowsRuntime) {
+    const wslArgs = args.map(convertArgToWSL);
+    return spawn("wsl", ["-e", cmd, ...wslArgs]);
+  }
+  return spawn(cmd, args);
+}
+function runFFmpeg(args, errorLabel) {
+  return new Promise((resolve3, reject) => {
+    const proc = spawnFFmpeg("ffmpeg", args);
+    let stderr = "";
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) reject(new Error(`${errorLabel}: ${stderr.slice(-500)}`));
+      else resolve3();
+    });
+    proc.on("error", reject);
+  });
+}
+var isWindowsRuntime;
+var init_spawn = __esm({
+  "src/lib/ffmpeg/spawn.ts"() {
+    "use strict";
+    init_utils();
+    isWindowsRuntime = process.platform === "win32";
+  }
+});
+
+// src/lib/ffmpeg/compose.ts
+function composeVideo(opts) {
+  return new Promise((resolve3, reject) => {
+    const {
+      videoPath,
+      assPath,
+      outputPath,
+      voiceoverPath,
+      musicPath,
+      musicVolume = 0.3,
+      musicFadeIn = 2,
+      musicFadeOut = 2,
+      width,
+      height,
+      fps,
+      preset,
+      quality,
+      fadeIn,
+      fadeOut,
+      videoDuration,
+      audioBitrate = "192k",
+      contrast = 0,
+      trimStart = 0,
+      userTier = "free"
+    } = opts;
+    const args = ["-y"];
+    if (trimStart > 0) {
+      args.push("-ss", String(trimStart));
+    }
+    args.push("-i", videoPath);
+    const effectiveDuration = videoDuration - trimStart;
+    const voiceoverDuration = opts.mainContentDuration ?? effectiveDuration;
+    if (voiceoverPath) args.push("-i", voiceoverPath);
+    if (musicPath) args.push("-i", musicPath);
+    const vf = [`scale=${width}:${height}`, `fps=${fps}`];
+    if (contrast > 0) {
+      const ffmpegContrast = 1 + contrast;
+      vf.push(`eq=contrast=${ffmpegContrast.toFixed(2)}`);
+    }
+    const watermarkFilters = buildWatermarkFilters({ tier: userTier, videoDuration: effectiveDuration });
+    if (watermarkFilters) {
+      vf.push(watermarkFilters);
+    }
+    const assPathForFilter = toWSLPath(assPath).replace(/:/g, "\\:");
+    vf.push(`ass=${assPathForFilter}`);
+    if (fadeIn > 0) vf.push(`fade=t=in:st=0:d=${fadeIn}:c=black`);
+    if (fadeOut > 0) {
+      const videoFadeOutStart = Math.max(0, effectiveDuration - fadeOut);
+      vf.push(`fade=t=out:st=${videoFadeOutStart}:d=${fadeOut}:c=black`);
+    }
+    const crf = Math.round(28 - quality * 10);
+    const hasVoiceover = !!voiceoverPath;
+    const hasMusic = !!musicPath;
+    const musicFadeOutStart = Math.max(0, effectiveDuration - musicFadeOut);
+    const vfStr = vf.join(",");
+    if (hasVoiceover && hasMusic) {
+      const complexFilter = [
+        // Voiceover: fade in only (no fade out - stays clear until end)
+        `[1:a]apad=whole_dur=${voiceoverDuration},afade=t=in:st=0:d=${fadeIn}[voice]`,
+        // Music: fade in and fade out
+        `[2:a]aloop=loop=-1:size=2e+09,atrim=0:${effectiveDuration},volume=${musicVolume},afade=t=in:st=0:d=${musicFadeIn},afade=t=out:st=${musicFadeOutStart}:d=${musicFadeOut}[music]`,
+        `[voice][music]amix=inputs=2:duration=longest[aout]`
+      ].join(";");
+      args.push("-vf", vfStr);
+      args.push("-filter_complex", complexFilter, "-map", "0:v", "-map", "[aout]");
+      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
+      args.push("-c:a", "aac", "-b:a", audioBitrate);
+    } else if (hasVoiceover) {
+      const af = `apad=whole_dur=${voiceoverDuration},afade=t=in:st=0:d=${fadeIn}`;
+      args.push("-vf", vfStr);
+      args.push("-map", "0:v", "-map", "1:a", "-af", af);
+      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
+      args.push("-c:a", "aac", "-b:a", audioBitrate);
+    } else if (hasMusic) {
+      const musicFilter = `aloop=loop=-1:size=2e+09,atrim=0:${effectiveDuration},volume=${musicVolume},afade=t=in:st=0:d=${musicFadeIn},afade=t=out:st=${musicFadeOutStart}:d=${musicFadeOut}`;
+      args.push("-vf", vfStr);
+      args.push("-map", "0:v", "-map", "1:a", "-af", musicFilter);
+      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
+      args.push("-c:a", "aac", "-b:a", "192k");
+    } else {
+      args.push("-vf", vfStr);
+      args.push("-c:v", "libx264", "-preset", preset, "-crf", String(crf), "-pix_fmt", "yuv420p");
+    }
+    args.push(outputPath);
+    runFFmpeg(args, "ffmpeg compose failed").then(resolve3, reject);
+  });
+}
+var init_compose = __esm({
+  "src/lib/ffmpeg/compose.ts"() {
+    "use strict";
+    init_watermark();
+    init_spawn();
+  }
+});
+
+// src/lib/ffmpeg/compress.ts
+function buildKeepSegments(eventTimestampsSeconds, totalDurationSeconds, preWindow = 0.5, postWindow = 1.2) {
+  if (!eventTimestampsSeconds.length) {
+    return [{ start: 0, end: totalDurationSeconds }];
+  }
+  const windows = eventTimestampsSeconds.map((t) => ({
+    start: Math.max(0, t - preWindow),
+    end: Math.min(totalDurationSeconds, t + postWindow)
+  }));
+  windows.sort((a, b) => a.start - b.start);
+  const merged = [windows[0]];
+  for (let i = 1; i < windows.length; i++) {
+    const last = merged[merged.length - 1];
+    const curr = windows[i];
+    if (curr.start <= last.end) {
+      last.end = Math.max(last.end, curr.end);
+    } else {
+      merged.push(curr);
+    }
+  }
+  return merged;
+}
+function mapTimestampsAfterCompression(originalTimestampsSeconds, segments) {
+  return originalTimestampsSeconds.map((t) => {
+    let offset = 0;
+    for (const seg of segments) {
+      if (t >= seg.start && t <= seg.end) {
+        return offset + (t - seg.start);
+      }
+      if (t > seg.end) {
+        offset += seg.end - seg.start;
+      }
+    }
+    return offset;
+  });
+}
+var init_compress = __esm({
+  "src/lib/ffmpeg/compress.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/ffmpeg/media.ts
+function getMediaDuration(filePath) {
+  return new Promise((resolve3, reject) => {
+    const args = [
+      "-v",
+      "error",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "default=noprint_wrappers=1:nokey=1",
+      filePath
+    ];
+    const proc = spawnFFmpeg("ffprobe", args);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data;
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data;
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`ffprobe failed: ${stderr}`));
+        return;
+      }
+      const duration = parseFloat(stdout.trim());
+      resolve3(Math.ceil(duration * 1e3));
+    });
+    proc.on("error", reject);
+  });
+}
+function concatMedia(listPath, output) {
+  return runFFmpeg(["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", output], "ffmpeg concat failed");
+}
+function generateSilence(outputPath, durationMs) {
+  return runFFmpeg(
+    [
+      "-y",
+      "-f",
+      "lavfi",
+      "-i",
+      "anullsrc=r=24000:cl=mono",
+      "-t",
+      String(durationMs / 1e3),
+      "-c:a",
+      "libmp3lame",
+      "-b:a",
+      "96k",
+      outputPath
+    ],
+    "ffmpeg silence generation failed"
+  );
+}
+function speedUpVideo(opts) {
+  const { inputPath, outputPath, factor, preset } = opts;
+  const videoFilter = `setpts=${(1 / factor).toFixed(3)}*PTS`;
+  const audioFilters = [];
+  let remaining = factor;
+  while (remaining > 1) {
+    const tempo = Math.min(remaining, 2);
+    audioFilters.push(`atempo=${tempo.toFixed(2)}`);
+    remaining /= tempo;
+  }
+  return runFFmpeg(
+    ["-y", "-i", inputPath, "-vf", videoFilter, "-af", audioFilters.join(","), "-preset", preset, outputPath],
+    "ffmpeg speedup failed"
+  );
+}
+function buildOutroFilterComplex(width, height) {
+  const outroWidth = Math.round(width * 0.6);
+  const yPos = Math.round(height * 0.2);
+  return [
+    "[0:v]copy[v0]",
+    `[1:v]scale=${outroWidth}:-1[scaled]`,
+    `color=black:${width}x${height}:d=5[bg]`,
+    `[bg][scaled]overlay=(${width}-${outroWidth})/2:${yPos}[v1]`,
+    "[v0][v1]concat=n=2:v=1:a=0[outv]"
+  ].join(";");
+}
+function concatVideoWithOutro(opts) {
+  const { inputPath, outroPath, outputPath, width, height, preset } = opts;
+  const filterComplex = buildOutroFilterComplex(width, height);
+  return runFFmpeg(
+    [
+      "-y",
+      "-i",
+      inputPath,
+      "-i",
+      outroPath,
+      "-filter_complex",
+      filterComplex,
+      "-map",
+      "[outv]",
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset,
+      "-crf",
+      "18",
+      "-pix_fmt",
+      "yuv420p",
+      "-an",
+      outputPath
+    ],
+    "ffmpeg concat video failed"
+  );
+}
+var init_media = __esm({
+  "src/lib/ffmpeg/media.ts"() {
+    "use strict";
+    init_spawn();
+  }
+});
+
+// src/lib/ffmpeg/splice.ts
+function spliceVideos(opts) {
+  return new Promise((resolve3, reject) => {
+    const { inputPath, outputPath, overlays, width, height, preset } = opts;
+    if (overlays.length === 0) {
+      runFFmpeg(["-y", "-i", inputPath, "-c", "copy", outputPath], "ffmpeg copy failed").then(resolve3, reject);
+      return;
+    }
+    const args = ["-y", "-i", inputPath];
+    for (const overlay of overlays) {
+      args.push("-i", overlay.path);
+    }
+    const filterParts = [];
+    let currentStream = "0:v";
+    for (let i = 0; i < overlays.length; i++) {
+      const overlay = overlays[i];
+      const inputIdx = i + 1;
+      const endTime = overlay.startTime + overlay.duration;
+      const filters = [];
+      if (overlay.trimStart !== void 0 || overlay.trimEnd !== void 0) {
+        const trimStart = overlay.trimStart ?? 0;
+        const trimEnd = overlay.trimEnd;
+        if (trimEnd !== void 0) {
+          filters.push(`trim=start=${trimStart}:end=${trimEnd}`);
+        } else {
+          filters.push(`trim=start=${trimStart}`);
+        }
+      }
+      if (overlay.mode === "stretch") {
+        filters.push(`scale=${width}:${height}:force_original_aspect_ratio=increase`);
+        filters.push(`crop=${width}:${height}`);
+      } else {
+        filters.push(`scale=${width}:${height}:force_original_aspect_ratio=decrease`);
+        filters.push(`pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:color=#1a1a2e`);
+      }
+      filters.push("setpts=PTS-STARTPTS");
+      filterParts.push(`[${inputIdx}:v]${filters.join(",")}[v${inputIdx}]`);
+      const nextStream = i === overlays.length - 1 ? "outv" : `tmp${i}`;
+      filterParts.push(
+        `[${currentStream}][v${inputIdx}]overlay=0:0:enable='between(t,${overlay.startTime.toFixed(3)},${endTime.toFixed(3)})'[${nextStream}]`
+      );
+      currentStream = nextStream;
+    }
+    args.push("-filter_complex", filterParts.join(";"));
+    args.push("-map", "[outv]");
+    args.push("-map", "0:a?");
+    args.push("-c:v", "libx264", "-preset", preset, "-crf", "18", "-pix_fmt", "yuv420p");
+    args.push("-c:a", "copy");
+    args.push(outputPath);
+    runFFmpeg(args, "ffmpeg splice failed").then(resolve3, reject);
+  });
+}
+var init_splice = __esm({
+  "src/lib/ffmpeg/splice.ts"() {
+    "use strict";
+    init_spawn();
+  }
+});
+
+// src/lib/ffmpeg/transitions.ts
+function buildStepTransitions(steps, stepDurations, defaultTransition) {
+  const transitions = [];
+  let cumulativeTime = 0;
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const durationMs = stepDurations[i] ?? 0;
+    const transitionType = step.transition ?? (defaultTransition !== "none" ? defaultTransition : void 0);
+    if (i > 0 && transitionType) {
+      transitions.push({
+        timestamp: cumulativeTime / 1e3,
+        type: transitionType
+      });
+    }
+    cumulativeTime += durationMs;
+  }
+  return transitions;
+}
+function applyTransitions(opts) {
+  return new Promise((resolve3, reject) => {
+    const { inputVideo, outputVideo, transitions, videoDuration, preset = "fast" } = opts;
+    if (transitions.length === 0) {
+      runFFmpeg(["-y", "-i", inputVideo, "-c", "copy", outputVideo], "FFmpeg copy failed").then(resolve3, reject);
+      return;
+    }
+    const sorted = [...transitions].sort((a, b) => a.timestamp - b.timestamp);
+    const boundaries = [0, ...sorted.map((t) => t.timestamp), videoDuration];
+    const filterParts = [];
+    const numSegments = boundaries.length - 1;
+    for (let i = 0; i < numSegments; i++) {
+      const start = boundaries[i];
+      const end = boundaries[i + 1];
+      filterParts.push(`[0:v]trim=start=${start.toFixed(3)}:end=${end.toFixed(3)},setpts=PTS-STARTPTS[v${i}]`);
+    }
+    let currentV = "v0";
+    for (let i = 0; i < sorted.length; i++) {
+      const trans = sorted[i];
+      const duration = trans.duration ?? 0.3;
+      const nextIdx = i + 1;
+      const segStart = boundaries[i];
+      const segEnd = boundaries[i + 1];
+      const segDuration = segEnd - segStart;
+      const offset = Math.max(0, segDuration - duration);
+      const xfadeType = trans.type === "fade" ? "fadeblack" : "fade";
+      const outV = i === sorted.length - 1 ? "outv" : `xv${i}`;
+      filterParts.push(
+        `[${currentV}][v${nextIdx}]xfade=transition=${xfadeType}:duration=${duration.toFixed(3)}:offset=${offset.toFixed(3)}[${outV}]`
+      );
+      currentV = outV;
+    }
+    const filterComplex = filterParts.join(";");
+    const args = [
+      "-y",
+      "-i",
+      inputVideo,
+      "-filter_complex",
+      filterComplex,
+      "-map",
+      "[outv]",
+      "-an",
+      // No audio - voiceover is added in compose step
+      "-c:v",
+      "libx264",
+      "-preset",
+      preset,
+      "-crf",
+      "23",
+      "-pix_fmt",
+      "yuv420p",
+      outputVideo
+    ];
+    runFFmpeg(args, "FFmpeg transitions failed").then(resolve3, reject);
+  });
+}
+var init_transitions = __esm({
+  "src/lib/ffmpeg/transitions.ts"() {
+    "use strict";
+    init_spawn();
+  }
+});
+
+// src/lib/ffmpeg/types.ts
+var init_types = __esm({
+  "src/lib/ffmpeg/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/ffmpeg/index.ts
+var init_ffmpeg = __esm({
+  "src/lib/ffmpeg/index.ts"() {
+    "use strict";
+    init_compose();
+    init_compress();
+    init_media();
+    init_splice();
+    init_transitions();
+    init_types();
+  }
+});
+
+// src/lib/ffmpeg.ts
+var init_ffmpeg2 = __esm({
+  "src/lib/ffmpeg.ts"() {
+    "use strict";
+    init_ffmpeg();
+  }
+});
+
+// src/lib/tts/helpers.ts
+import { existsSync } from "fs";
+import { readFile, unlink, writeFile } from "fs/promises";
+import { isAbsolute, join, resolve } from "path";
+function toWSLPathForTTS(path) {
+  return windowsPathToWSL(path) ?? path;
+}
+function estimateActionDuration(step) {
+  if (step.action === "drag" && step.value === "around") {
+    return 3e3;
+  }
+  if (step.action === "drag") {
+    return 2e3;
+  }
+  if (step.action === "scroll") {
+    return 1500;
+  }
+  return 1e3;
+}
+function getCaptionsHash(steps) {
+  const captions = steps.map((s) => s.caption || "").join("|");
+  let hash = 0;
+  for (let i = 0; i < captions.length; i++) {
+    hash = (hash << 5) - hash + captions.charCodeAt(i) | 0;
+  }
+  return hash.toString(16);
+}
+async function getMediaStepDuration(step, baseDir) {
+  if (step.action !== "video" && step.action !== "media" || !step.value) {
+    return 0;
+  }
+  const ext = step.value.split(".").pop()?.toLowerCase() || "";
+  if (!["mp4", "webm", "mov"].includes(ext)) {
+    return 0;
+  }
+  const mediaPath = isAbsolute(step.value) ? step.value : resolve(baseDir, step.value);
+  if (!existsSync(mediaPath)) {
+    return 0;
+  }
+  try {
+    if (step.partial) {
+      const { trimStart, trimEnd } = parsePartial(step.partial);
+      if (trimStart !== void 0 && trimEnd !== void 0) {
+        return (trimEnd - trimStart) * 1e3;
+      }
+      const fullDuration = await getMediaDuration(mediaPath);
+      const start = (trimStart ?? 0) * 1e3;
+      const end = trimEnd !== void 0 ? trimEnd * 1e3 : fullDuration;
+      return end - start;
+    }
+    return await getMediaDuration(mediaPath);
+  } catch {
+    return 0;
+  }
+}
+async function loadVoiceoverMeta(outputDir) {
+  const metaPath = join(outputDir, "voiceover.json");
+  try {
+    if (!existsSync(metaPath)) return null;
+    const content = await readFile(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function saveVoiceoverMeta(outputDir, meta) {
+  const metaPath = join(outputDir, "voiceover.json");
+  await writeFile(metaPath, JSON.stringify(meta, null, 2));
+}
+async function concatenateAudio(inputs, output, workDir) {
+  const formatPath = (f) => {
+    const resolved = resolve(f);
+    return isWindows ? windowsPathToWSL(resolved) ?? resolved : resolved;
+  };
+  const listContent = inputs.map((f) => `file '${formatPath(f)}'`).join("\n");
+  const listPath = join(workDir, "concat.txt");
+  await writeFile(listPath, listContent);
+  await concatMedia(listPath, output);
+  await unlink(listPath).catch(() => {
+  });
+}
+var isWindows;
+var init_helpers = __esm({
+  "src/lib/tts/helpers.ts"() {
+    "use strict";
+    init_ffmpeg2();
+    init_utils();
+    isWindows = process.platform === "win32";
+  }
+});
+
+// src/lib/tts/timing.ts
+var timing_exports = {};
+__export(timing_exports, {
+  alignVoiceoverToRecording: () => alignVoiceoverToRecording,
+  estimateWordTimings: () => estimateWordTimings
+});
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function estimateWordTimings(caption, duration) {
+  const words = caption.split(/\s+/).filter((w) => w.length > 0);
+  const wordDuration = duration / words.length;
+  return words.map((word, i) => ({
+    word,
+    start: Math.round(i * wordDuration),
+    end: Math.round((i + 1) * wordDuration)
+  }));
+}
+async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, workDir, outputDir) {
+  let needsRealignment = false;
+  for (let i = 0; i < actualRecordingDurations.length; i++) {
+    const stepNum = i + 1;
+    const voiceDuration = stepAudio.get(stepNum)?.duration ?? 0;
+    const recordingDuration = actualRecordingDurations[i] ?? 0;
+    if (recordingDuration > voiceDuration) {
+      needsRealignment = true;
+      break;
+    }
+  }
+  if (!needsRealignment) {
+    return stepAudio;
+  }
+  const audioDir = join2(workDir, "audio");
+  const segments = [];
+  const alignedStepAudio = /* @__PURE__ */ new Map();
+  for (let i = 0; i < actualRecordingDurations.length; i++) {
+    const stepNum = i + 1;
+    const voiceData = stepAudio.get(stepNum);
+    const voiceDuration = voiceData?.duration ?? 0;
+    const recordingDuration = actualRecordingDurations[i] ?? 0;
+    const targetDuration = Math.max(voiceDuration, recordingDuration);
+    const audioPath = join2(audioDir, `step-${stepNum}.mp3`);
+    const originalPaddingPath = join2(audioDir, `step-${stepNum}-padding.mp3`);
+    const silencePath = join2(audioDir, `step-${stepNum}-silence.mp3`);
+    if (existsSync2(audioPath)) {
+      segments.push(audioPath);
+      if (existsSync2(originalPaddingPath)) {
+        segments.push(originalPaddingPath);
+      }
+      if (recordingDuration > voiceDuration) {
+        const alignPaddingPath = join2(audioDir, `step-${stepNum}-align-padding.mp3`);
+        await generateSilence(alignPaddingPath, recordingDuration - voiceDuration);
+        segments.push(alignPaddingPath);
+      }
+    } else if (existsSync2(silencePath)) {
+      if (targetDuration !== voiceDuration) {
+        await generateSilence(silencePath, targetDuration);
+      }
+      segments.push(silencePath);
+    }
+    alignedStepAudio.set(stepNum, {
+      duration: targetDuration,
+      words: voiceData?.words ?? []
+    });
+  }
+  if (segments.length > 0) {
+    const voiceoverPath = join2(outputDir, "voiceover.wav");
+    await concatenateAudio(segments, voiceoverPath, workDir);
+  }
+  const existingMeta = await loadVoiceoverMeta(outputDir);
+  if (existingMeta) {
+    existingMeta.stepDurations = Object.fromEntries(
+      Array.from(alignedStepAudio.entries()).map(([k, v]) => [k, v.duration])
+    );
+    await saveVoiceoverMeta(outputDir, existingMeta);
+  }
+  return alignedStepAudio;
+}
+var init_timing = __esm({
+  "src/lib/tts/timing.ts"() {
+    "use strict";
+    init_ffmpeg2();
+    init_helpers();
+  }
+});
+
+// src/lib/api-client.ts
+init_utils();
+var SPARK_AI_BASE = "https://sparkbrain.app";
+var SPARK_AI_CHAT = `${SPARK_AI_BASE}/api/chat`;
+var SPARK_AI_TOKEN = `${SPARK_AI_BASE}/api/models/token`;
+var API_KEY = process.env.SPARK_AI_KEY || "";
+var cachedToken = null;
+async function getOrRefreshToken() {
+  const now = Date.now();
+  if (cachedToken && cachedToken.expiresAt > now + 3e5) {
+    return cachedToken.token;
+  }
+  try {
+    const response = await fetch(SPARK_AI_TOKEN, {
+      method: "POST",
+      headers: { "X-Api-Key": API_KEY }
+    });
+    const data = await response.json();
+    if (!response.ok || !data.success || !data.token) {
+      throw new Error(data.error || `Token exchange failed: ${response.status}`);
+    }
+    cachedToken = {
+      token: data.token,
+      expiresAt: data.expiresAt || now + 36e5
+    };
+    return data.token;
+  } catch (err) {
+    throw new Error(`Failed to get Spark AI token: ${getErrorMessage(err)}`);
+  }
+}
+async function callAI(systemPrompt, userPrompt, tier = "free") {
+  if (!API_KEY) {
+    return {
+      success: false,
+      error: "AI service is not configured. Please report this issue.",
+      isAuthError: true
+    };
+  }
+  try {
+    const token = await getOrRefreshToken();
+    let lastRateLimitError = null;
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        const response = await fetch(SPARK_AI_CHAT, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify({
+            messages: [
+              { role: "system", content: systemPrompt },
+              { role: "user", content: userPrompt }
+            ]
+          })
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          const error = data.error || `Spark AI error: ${response.status}`;
+          if (response.status === 429 && attempt < 3) {
+            const retryAfter = response.headers.get("Retry-After");
+            const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3 * Math.pow(2, attempt - 1);
+            lastRateLimitError = {
+              success: false,
+              error,
+              isRateLimit: true,
+              ...retryAfter ? { retryAfterSeconds: parseInt(retryAfter, 10) } : {}
+            };
+            await new Promise((resolve3) => setTimeout(resolve3, Math.min(delayMs, 3e4)));
+            continue;
+          }
+          return {
+            success: false,
+            error,
+            isRateLimit: response.status === 429,
+            isAuthError: response.status === 401 || response.status === 403
+          };
+        }
+        if (!data.success || !data.response) {
+          return {
+            success: false,
+            error: data.error || "No response from Spark AI"
+          };
+        }
+        return {
+          success: true,
+          content: data.response,
+          limits: {
+            used: data.limits?.used ?? 0,
+            limit: data.limits?.limit ?? 100,
+            tier,
+            ...data.limits?.resetAt ? { resetAt: data.limits.resetAt } : {}
+          }
+        };
+      } catch (err) {
+        if (attempt === 3) throw err;
+        const delayMs = 1e3 * Math.pow(2, attempt - 1);
+        await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+      }
+    }
+    return lastRateLimitError || { success: false, error: "Request failed after retries" };
+  } catch (err) {
+    return { success: false, error: `Spark AI error: ${getErrorMessage(err)}` };
+  }
+}
+function parseAIPlanResponse(content) {
+  try {
+    let processedContent = content;
+    const codeBlockMatch = processedContent.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (codeBlockMatch?.[1]) {
+      processedContent = codeBlockMatch[1].trim();
+    }
+    const jsonMatch = processedContent.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return { success: false, error: "No valid JSON found in AI response" };
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    return { success: true, plan: parsed };
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to parse AI response: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function normalizeUrl(input) {
+  let url = input.trim();
+  url = url.replace(/^(https?:\/\/)?(www\.)?/i, "");
+  return `https://${url}`;
+}
+
+// src/lib/SparkStripe-feature-gating.ts
+var APP_ID = process.env.SPARK_APP_ID ?? "quickpeek";
+var BASE = "https://sparkstripe.com";
+var TIERS = {
+  "price_1TADnPEf9opkuWid9NtqOYON": "pro",
+  "price_1TADnPEf9opkuWidgbvvX9ma": "pro",
+  "price_1TADm7Ef9opkuWid3I9tquIB": "pro",
+  "price_1TADm8Ef9opkuWid1RSA2wCa": "pro",
+  "price_1TCREmEf9opkuWidvhuqzqDM": "pro",
+  "price_1TCREmEf9opkuWidacf1tiC7": "pro"
+};
+var RANK = {
+  "free": 0,
+  "pro": 1
+};
+var FEATURES = { "free": [], "pro": [
+  "Everything in Free",
+  "No watermark",
+  "Full video composition (voiceover + captions + music + transitions)",
+  "Unlimited videos",
+  "Priority support"
+] };
+async function _fetch(email, init) {
+  const r = await fetch(`${BASE}/api/public/subscription/status-public?email=${encodeURIComponent(email)}&app_id=${APP_ID}`, init);
+  if (!r.ok) throw new Error(`spark-stripe: ${r.status}`);
+  return r.json();
+}
+var getStatus = (email) => _fetch(email);
+var _cache = /* @__PURE__ */ new Map();
+async function getStatusCached(email) {
+  const k = email.toLowerCase(), hit = _cache.get(k);
+  if (hit && Date.now() < hit.exp) return hit.data;
+  const data = await getStatus(email);
+  _cache.set(k, { data, exp: Date.now() + 6e4 });
+  return data;
+}
+function getTier(d) {
+  if (!d.subscription || !d.registered) return "free";
+  if (d.subscription.status === "canceled" || d.subscription.status === "past_due") return "free";
+  return TIERS[d.subscription.price_id] ?? "free";
+}
+var isPaid = (d) => getTier(d) !== "free";
+var hasAccess = (d, min) => (RANK[getTier(d)] ?? 0) >= (RANK[min] ?? 0);
+var hasTrialRemaining = (d) => isPaid(d) || !!d.trial && !d.trial.is_expired && d.trial.uses_remaining > 0;
+var showPaywall = (d) => !isPaid(d) && !hasTrialRemaining(d);
+var isCanceling = (d) => !!d.subscription && d.subscription.cancel_at_period_end && d.subscription.status !== "canceled";
+async function getTierByEmail(email) {
+  try {
+    return getTier(await getStatusCached(email));
+  } catch {
+    return "free";
+  }
+}
+async function isVerified(email) {
+  try {
+    return (await getStatusCached(email)).verified;
+  } catch {
+    return false;
+  }
+}
+function pricingUrl(opts) {
+  const u = new URL(`${BASE}/pricing/${APP_ID}`);
+  if (opts?.email) u.searchParams.set("email", opts.email);
+  if (opts?.returnUrl) u.searchParams.set("return_url", opts.returnUrl);
+  return u.toString();
+}
+
+// src/lib/billing.ts
+function shouldWatermark(tier, videoDurationSeconds) {
+  return tier === "free" && videoDurationSeconds > 20;
+}
+function getUpgradeUrl(userEmail) {
+  return pricingUrl(userEmail ? { email: userEmail } : void 0);
+}
+
+// src/lib/config.ts
+var VERSION = "1.1.1";
+var CONFIG_FILE = "quickpeek.config.json";
+var DEFAULT_CONFIG = {
+  plan: { maxSteps: 8 },
+  video: {
+    width: 1080,
+    height: 1920,
+    format: "mp4",
+    preset: "fast",
+    quality: 0.5,
+    fps: 30,
+    cursor: true,
+    highlight: "outline",
+    fadeIn: 1500,
+    // ms
+    fadeOut: 1500,
+    // ms
+    transitions: "none",
+    contrast: 0.25,
+    tempo: 1,
+    stepDelay: 200
+    // ms delay between steps
+  },
+  audio: { format: "mp3", bitrate: "192k" },
+  timing: { minStepDuration: 1500 },
+  output: { dir: "./demo" }
+};
+var DEFAULT_CAPTIONS = {
+  font: "Arial",
+  outline: "#000000",
+  outlineWidth: 3,
+  shadow: 2,
+  marginBottom: 80,
+  regular: {
+    color: "#FFFFFF",
+    size: 56,
+    bold: true
+  },
+  highlight: {
+    color: "#FFFF00",
+    size: 64,
+    bold: true
+  }
+};
+
+// src/lib/crawl.ts
+import { chromium } from "playwright";
+
+// src/lib/scraping.ts
+var EXCLUDED_LINK_PATTERNS = [
+  // Legal & Policy
+  "privacy",
+  "terms",
+  "cookie",
+  "legal",
+  "policy",
+  "disclaimer",
+  "copyright",
+  "gdpr",
+  // Auth & Account
+  "login",
+  "signin",
+  "sign in",
+  "signup",
+  "sign up",
+  "register",
+  "logout",
+  "sign out",
+  "my account",
+  "profile",
+  "settings",
+  // Support
+  "contact",
+  "about",
+  "help",
+  "support",
+  "faq",
+  // Social Media
+  "facebook",
+  "twitter",
+  "linkedin",
+  "instagram",
+  "youtube",
+  "tiktok",
+  "github",
+  // Company
+  "blog",
+  "news",
+  "press",
+  "careers",
+  "jobs",
+  "team",
+  // Developer
+  "docs",
+  "documentation",
+  "api",
+  "developers",
+  // Commerce
+  "pricing",
+  "plans",
+  "subscribe",
+  "newsletter",
+  "upgrade",
+  "buy",
+  "purchase",
+  // Misc
+  "accessibility",
+  "sitemap",
+  "rss",
+  "feed",
+  "home"
+];
+var INTERACTIVE_SELECTORS = [
+  "button",
+  "input",
+  "select",
+  "textarea",
+  "a[href]",
+  '[role="button"]',
+  '[role="checkbox"]',
+  '[role="radio"]',
+  '[role="switch"]',
+  '[role="slider"]',
+  '[role="combobox"]',
+  '[role="menuitem"]',
+  '[type="submit"]',
+  "[onclick]"
+];
+function isExcludedLink(text, href = "") {
+  const lowerText = text.toLowerCase();
+  const lowerHref = href.toLowerCase();
+  return EXCLUDED_LINK_PATTERNS.some((p) => lowerText.includes(p) || lowerHref.includes(p));
+}
+function shouldSkipLink(text, href, currentPath) {
+  if (!href || href === "#") return true;
+  try {
+    const linkPath = new URL(href).pathname;
+    if (linkPath === "/" || linkPath === currentPath) return true;
+  } catch {
+    return true;
+  }
+  return isExcludedLink(text, href);
+}
+
+// src/lib/crawl.ts
+function getActionForType(type) {
+  switch (type) {
+    case "button":
+    case "link":
+      return "click";
+    case "file":
+      return "upload";
+    case "range":
+      return "drag";
+    case "select":
+      return "select";
+    case "checkbox":
+      return "check";
+    default:
+      return "type";
+  }
+}
+var noopTask = () => ({ succeed: () => {
+} });
+async function crawlPage(url, task = noopTask) {
+  const browserTask = task("Launching browser");
+  const browser = await chromium.launch({ headless: true });
+  const page = await browser.newPage();
+  browserTask.succeed("Browser launched");
+  const crawlTask = task("Crawling page");
+  await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
+  const title = await page.title();
+  const rawElements = await page.evaluate(`
+    (() => {
+      const items = [];
+
+      // Helper to get parent context
+      const getCtx = (el) => {
+        let p = el.parentElement;
+        while (p && p !== document.body) {
+          if (p.id) return '#' + p.id;
+          const cls = Array.from(p.classList).find(c =>
+            /toolbar|header|footer|sidebar|panel|modal|dialog|nav|menu|controls|actions/i.test(c)
+          );
+          if (cls) return '.' + cls;
+          if (['header', 'footer', 'nav', 'main', 'aside', 'form'].includes(p.tagName.toLowerCase())) {
+            return p.tagName.toLowerCase();
+          }
+          p = p.parentElement;
+        }
+        return '';
+      };
+
+      // Buttons (use textContent to catch hidden elements too)
+      document.querySelectorAll('button, [role="button"]').forEach(el => {
+        const text = (el.textContent || el.innerText || '').trim().replace(/\\s+/g, ' ').slice(0, 40);
+        const testId = el.getAttribute('data-testid');
+        const ariaLabel = el.getAttribute('aria-label');
+        if (!text && !testId && !ariaLabel) return;
+        items.push({ type: 'button', text: text || ariaLabel || testId, testId, ctx: getCtx(el) });
+      });
+
+      // Inputs (including file inputs, range sliders, checkboxes, selects)
+      document.querySelectorAll('input, textarea, select').forEach(el => {
+        if (el.type === 'hidden') return;
+        const testId = el.getAttribute('data-testid');
+        const inputType = el.type || 'text';
+
+        // Get label text for any input type
+        let labelText = '';
+        if (el.labels?.[0]) {
+          labelText = el.labels[0].textContent?.trim() || '';
+        } else if (el.id) {
+          const label = document.querySelector('label[for="' + el.id + '"]');
+          if (label) labelText = label.textContent?.trim() || '';
+        }
+
+        const text = labelText || el.placeholder || el.name || el.id || '';
+
+        // Include file, range, and checkbox inputs even without text
+        const alwaysInclude = ['file', 'range', 'checkbox'].includes(inputType);
+        if (!text && !testId && !alwaysInclude) return;
+
+        items.push({
+          type: inputType,
+          text: text || (inputType === 'file' ? 'file upload' : inputType === 'range' ? 'slider' : inputType === 'checkbox' ? 'checkbox' : testId),
+          testId,
+          id: el.id,
+          name: el.name,
+          placeholder: el.placeholder,
+          isFile: inputType === 'file'
+        });
+      });
+
+      // Links (use textContent to catch hidden elements too)
+      document.querySelectorAll('a[href]').forEach(el => {
+        const text = (el.textContent || el.innerText || '').trim().replace(/\\s+/g, ' ').slice(0, 40);
+        if (text && text.length >= 2) items.push({ type: 'link', text });
+      });
+
+      return items.slice(0, 40);
+    })()
+  `);
+  const filteredElements = rawElements.filter((el) => {
+    if (!el.text) return true;
+    const text = el.text.toLowerCase().trim();
+    return !EXCLUDED_LINK_PATTERNS.some((pattern) => text.includes(pattern));
+  });
+  const btnTexts = {};
+  for (const el of filteredElements) {
+    if (el.type === "button" && el.text) {
+      btnTexts[el.text] = (btnTexts[el.text] || 0) + 1;
+    }
+  }
+  const elements = filteredElements.map((el) => {
+    let selector;
+    if (el.testId) {
+      selector = `[data-testid="${el.testId}"]`;
+    } else if (el.isFile || el.type === "file") {
+      selector = 'input[type="file"]';
+    } else if (el.type === "range") {
+      selector = el.id ? `#${el.id}` : 'input[type="range"]';
+    } else if (el.type === "checkbox") {
+      selector = el.id ? `#${el.id}` : 'input[type="checkbox"]';
+    } else if (el.type === "button") {
+      if (btnTexts[el.text] === 1) {
+        selector = `text="${el.text}"`;
+      } else {
+        selector = el.ctx ? `${el.ctx} >> text="${el.text}"` : `button:has-text("${el.text}")`;
+      }
+    } else if (el.type === "link") {
+      selector = `text="${el.text}"`;
+    } else if (el.id) {
+      selector = `#${el.id}`;
+    } else if (el.name) {
+      selector = `[name="${el.name}"]`;
+    } else if (el.placeholder) {
+      selector = `[placeholder="${el.placeholder}"]`;
+    } else {
+      selector = `text="${el.text}"`;
+    }
+    let normalizedType;
+    if (el.isFile || el.type === "file") {
+      normalizedType = "file";
+    } else if (el.type === "range") {
+      normalizedType = "range";
+    } else if (el.type === "checkbox") {
+      normalizedType = "checkbox";
+    } else if (el.type === "select" || el.type === "select-one" || el.type === "select-multiple") {
+      normalizedType = "select";
+    } else if (el.type === "button" || el.type === "link") {
+      normalizedType = el.type;
+    } else {
+      normalizedType = "input";
+    }
+    const action = getActionForType(normalizedType);
+    const target = normalizedType === "file" ? selector : (el.text || "").toLowerCase();
+    return { type: normalizedType, text: el.text, selector, action, target };
+  });
+  await browser.close();
+  crawlTask.succeed(`Found ${elements.length} interactive elements`);
+  return { title, elements };
+}
+
+// src/lib/cursor.ts
+var CURSOR_PNG = "data:image/png;base64,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";
+
+// src/lib/index.ts
+init_ffmpeg2();
+
+// src/lib/prompts.ts
+init_utils();
+function buildSystemPrompt(maxSteps) {
+  let scope;
+  if (maxSteps <= 5) {
+    scope = `SCOPE: Minimal demo (${maxSteps} steps max) - ONE complete user journey only`;
+  } else if (maxSteps <= 8) {
+    scope = `SCOPE: Standard demo (${maxSteps} steps max) - One journey with 1-2 options`;
+  } else {
+    scope = `SCOPE: Extended demo (${maxSteps} steps max) - Journey plus key settings`;
+  }
+  return `You create demo video scripts for web apps.
+
+${scope}
+
+CORE FLOW (always follow this structure):
+1. wait - Intro (what does this app do?)
+2. Actions - Complete ONE user journey (upload\u2192process\u2192result)
+3. wait - Outro (what was accomplished?)
+
+TARGET SYNTAX (simplified):
+\u2022 Buttons/Links: Use plain text like "extract frame", "download" (case insensitive, partial match OK)
+\u2022 File inputs: input[type="file"] - ALWAYS use this exact selector
+\u2022 Sliders/Range: input[type="range"] - ALWAYS use this for sliders
+\u2022 Select: select or select[name="..."]
+\u2022 Text inputs: input[type="text"], input[name="..."], or #id
+
+SKIP THESE ELEMENTS (never include in demo):
+\u2022 Navigation: Home, About, Contact, Help, Support, FAQ
+\u2022 Auth: Login, Sign In, Sign Up, Register, My Account
+\u2022 Business: Pricing, Plans, Subscribe, Buy, Upgrade
+\u2022 Footer: Privacy, Terms, Blog, Careers, Social media
+
+FORBIDDEN:
+\u2022 Repeating same action multiple times (e.g., multiple clicks on same button)
+\u2022 Clicking downloaded files or result images
+\u2022 Vague targets like "slider", "animation", "options" - use CSS selectors instead
+\u2022 More steps than maxSteps allows
+
+ACTION FORMATS (STRICT - follow exactly):
+\u2022 click: { "action": "click", "target": "extract frame" } - use simplified button text
+\u2022 type: { "action": "type", "target": "input[name=\\"field\\"]", "value": "text to type" }
+\u2022 upload: { "action": "upload", "target": "input[type=\\"file\\"]", "value": "[file]" }
+\u2022 wait: { "action": "wait" } - for intro/outro captions
+\u2022 scroll: { "action": "scroll", "value": "-80" } - negative=zoom out, positive=zoom in
+\u2022 drag: { "action": "drag", "target": "input[type=\\"range\\"]", "value": "50" }
+\u2022 select: { "action": "select", "target": "select[name=\\"..\\"]", "value": "option" }
+\u2022 check: { "action": "check", "target": "input[type=\\"checkbox\\"]" }
+
+EXAMPLES:
+\u2022 Click button: "target": "extract frame" or "target": "download"
+\u2022 File upload: "target": "input[type=\\"file\\"]"
+\u2022 Slider: "target": "input[type=\\"range\\"]"`;
+}
+function buildUserPrompt(url, title, elements, langName, description, maxSteps) {
+  const lang = langName ? `
+Language: Write ALL captions in ${langName}.` : "";
+  const purpose = description ? `
+Purpose: ${description}` : "";
+  const minSteps = Math.max(3, Math.floor(maxSteps * 0.6));
+  const clickables = elements.filter((e) => e.action === "click");
+  const uploadables = elements.filter((e) => e.action === "upload");
+  const typables = elements.filter((e) => e.action === "type");
+  const draggables = elements.filter((e) => e.action === "drag");
+  const selectables = elements.filter((e) => e.action === "select");
+  const checkables = elements.filter((e) => e.action === "check");
+  const elementDict = [];
+  if (clickables.length > 0) {
+    elementDict.push(`CLICK targets (use simplified text):
+${clickables.map((e) => `\u2022 "${e.target || e.text.toLowerCase()}"`).join("\n")}`);
+  }
+  if (uploadables.length > 0) {
+    elementDict.push(`UPLOAD targets (use selector):
+${uploadables.map((e) => `\u2022 ${e.selector}`).join("\n")}`);
+  }
+  if (typables.length > 0) {
+    elementDict.push(`TYPE targets (use selector):
+${typables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`);
+  }
+  if (draggables.length > 0) {
+    elementDict.push(`DRAG targets (use selector):
+${draggables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`);
+  }
+  if (selectables.length > 0) {
+    elementDict.push(`SELECT targets (use selector):
+${selectables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`);
+  }
+  if (checkables.length > 0) {
+    elementDict.push(`CHECK targets (use selector):
+${checkables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`);
+  }
+  const elementSummary = elementDict.length > 0 ? elementDict.join("\n\n") : "(no interactive elements found)";
+  return `URL: ${url}
+Title: ${title}${purpose}
+
+AVAILABLE ELEMENTS (grouped by action):
+${elementSummary}
+
+REQUIREMENTS:
+\u2022 ${minSteps}-${maxSteps} steps total (start with wait intro, end with wait outro)
+\u2022 Complete ONE user journey: input \u2192 process \u2192 output
+\u2022 For CLICK: use simplified text target like "extract frame" or "download"
+\u2022 For UPLOAD/DRAG/TYPE: use the CSS selector shown above
+\u2022 For buttons that appear after actions: use partial text like "extract" or "download"${lang}
+
+Return JSON:
+{
+  "url": "${url}",
+  "title": "Short demo title",
+  "description": "What this app does",
+  "steps": [
+    { "id": 1, "action": "wait", "caption": "Welcome! This app..." },
+    { "id": 2, "action": "upload", "target": "input[type=\\"file\\"]", "caption": "Upload your file...", "value": "[file]" },
+    { "id": 3, "action": "drag", "target": "input[type=\\"range\\"]", "caption": "Adjust the slider...", "value": "50" },
+    { "id": 4, "action": "click", "target": "process", "caption": "Click to process..." },
+    { "id": 5, "action": "click", "target": "download", "caption": "Download your result..." },
+    { "id": 6, "action": "wait", "caption": "Done! Your file is ready." }
+  ]
+}
+
+TARGET SYNTAX:
+\u2022 Buttons/Links: Plain text like "extract frame", "download" (case insensitive)
+\u2022 File inputs: input[type="file"]
+\u2022 Sliders: input[type="range"]
+\u2022 Text inputs: Use selector from list above`;
+}
+
+// src/lib/styles.ts
+var CURSOR_MOVE_DURATION = 800;
+var CURSOR_CSS = `
+  #qp-cursor {
+    position: fixed;
+    width: 32px;
+    height: 38px;
+    background: url("${CURSOR_PNG}") no-repeat;
+    background-size: contain;
+    pointer-events: none;
+    z-index: 2147483647;
+    transform: translate(-3px, -3px);
+    transition: left ${CURSOR_MOVE_DURATION}ms ease-out, top ${CURSOR_MOVE_DURATION}ms ease-out, transform 0.08s ease-out;
+    filter: drop-shadow(1px 1px 2px rgba(0,0,0,0.3));
+  }
+  #qp-cursor.clicking {
+    transform: translate(-3px, -3px) scale(0.9);
+  }
+`;
+var CURSOR_SCRIPT = `
+  (function() {
+    if (document.getElementById('qp-cursor')) return;
+    const cursor = document.createElement('div');
+    cursor.id = 'qp-cursor';
+    document.body.appendChild(cursor);
+
+    document.addEventListener('mousemove', (e) => {
+      cursor.style.left = e.clientX + 'px';
+      cursor.style.top = e.clientY + 'px';
+    });
+
+    document.addEventListener('mousedown', () => cursor.classList.add('clicking'));
+    document.addEventListener('mouseup', () => cursor.classList.remove('clicking'));
+
+    // Start at center
+    cursor.style.left = window.innerWidth / 2 + 'px';
+    cursor.style.top = window.innerHeight / 2 + 'px';
+  })();
+`;
+function generateASSHeader(width, height, font, size, primaryColor, secondaryColor, outlineColor, backColor, bold, outlineWidth, shadow, marginBottom) {
+  return `[Script Info]
+Title: QuickPeek Demo
+ScriptType: v4.00+
+PlayResX: ${width}
+PlayResY: ${height}
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Karaoke,${font},${size},${primaryColor},${secondaryColor},${outlineColor},${backColor},${bold ? 1 : 0},0,0,0,100,100,0,0,1,${outlineWidth},${shadow},2,40,40,${marginBottom},1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+}
+
+// src/lib/subscription-client.ts
+async function registerFreeUser(email) {
+  const APP_ID2 = process.env.SPARK_APP_ID ?? "quickpeek";
+  try {
+    const response = await fetch(`https://sparkstripe.com/api/register-free`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email, app_id: APP_ID2, app_name: "QuickPeek" })
+    });
+    const text = await response.text();
+    let data = {};
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        if (!response.ok) {
+          return { success: false, error: `Server error: ${response.status} ${response.statusText}` };
+        }
+      }
+    }
+    if (!response.ok) {
+      return { success: false, error: data.error || `Registration failed: ${response.status}` };
+    }
+    return {
+      success: true,
+      pendingVerification: data.pendingVerification ?? true,
+      alreadyVerified: data.alreadyVerified ?? false
+    };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : "Network error" };
+  }
+}
+
+// src/lib/tts/cache.ts
+init_helpers();
+import { join as join3 } from "path";
+function canReuseVoiceover(steps, voice, existingMeta) {
+  if (!existingMeta) {
+    return { canReuse: false, reason: "No existing voiceover found" };
+  }
+  if (existingMeta.voice !== voice) {
+    return { canReuse: false, reason: `Voice changed (${existingMeta.voice} \u2192 ${voice})` };
+  }
+  if (existingMeta.stepCount !== steps.length) {
+    return { canReuse: false, reason: `Step count changed (${existingMeta.stepCount} \u2192 ${steps.length})` };
+  }
+  const currentHash = getCaptionsHash(steps);
+  if (existingMeta.captionsHash === currentHash) {
+    return { canReuse: true };
+  }
+  const currentLength = steps.reduce((sum, s) => sum + (s.caption?.length || 0), 0);
+  const lengthDiff = Math.abs(currentLength - existingMeta.totalCaptionLength);
+  const threshold = existingMeta.totalCaptionLength * 0.1;
+  if (lengthDiff <= threshold) {
+    return { canReuse: true, reason: "Captions similar enough" };
+  }
+  return { canReuse: false, reason: "Captions changed significantly" };
+}
+async function loadExistingVoiceover(steps, outputDir, meta, config) {
+  const { estimateWordTimings: estimateWordTimings2 } = await Promise.resolve().then(() => (init_timing(), timing_exports));
+  const voiceoverPath = join3(outputDir, "voiceover.wav");
+  const stepAudio = /* @__PURE__ */ new Map();
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const stepNum = i + 1;
+    const duration = meta.stepDurations[stepNum] || config.timing.minStepDuration;
+    stepAudio.set(stepNum, {
+      duration,
+      words: estimateWordTimings2(step.caption || "", duration)
+    });
+  }
+  return { voiceoverPath, stepAudio };
+}
+
+// src/lib/tts/generate.ts
+init_ffmpeg2();
+import { mkdir } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/lib/voices.ts
+var LANGUAGE_VOICES = {
+  en: "en-GB-SoniaNeural",
+  ar: "ar-LB-LaylaNeural",
+  es: "es-ES-ElviraNeural",
+  fr: "fr-FR-DeniseNeural",
+  de: "de-DE-KatjaNeural",
+  it: "it-IT-ElsaNeural",
+  pt: "pt-BR-FranciscaNeural",
+  ru: "ru-RU-SvetlanaNeural",
+  zh: "zh-CN-XiaoxiaoNeural",
+  ja: "ja-JP-NanamiNeural",
+  ko: "ko-KR-SunHiNeural",
+  hi: "hi-IN-SwaraNeural",
+  tr: "tr-TR-EmelNeural",
+  nl: "nl-NL-ColetteNeural",
+  pl: "pl-PL-AgnieszkaNeural",
+  sv: "sv-SE-SofieNeural",
+  he: "he-IL-HilaNeural",
+  th: "th-TH-PremwadeeNeural",
+  vi: "vi-VN-HoaiMyNeural",
+  id: "id-ID-GadisNeural",
+  ms: "ms-MY-YasminNeural",
+  fil: "fil-PH-BlessicaNeural",
+  uk: "uk-UA-PolinaNeural",
+  cs: "cs-CZ-VlastaNeural",
+  el: "el-GR-AthinaNeural",
+  ro: "ro-RO-AlinaNeural",
+  hu: "hu-HU-NoemiNeural",
+  da: "da-DK-ChristelNeural",
+  fi: "fi-FI-NooraNeural",
+  no: "nb-NO-PernilleNeural",
+  sk: "sk-SK-ViktoriaNeural",
+  bg: "bg-BG-KalinaNeural",
+  hr: "hr-HR-GabrijelaNeural",
+  sl: "sl-SI-PetraNeural",
+  et: "et-EE-AnuNeural",
+  lv: "lv-LV-EveritaNeural",
+  lt: "lt-LT-OnaNeural",
+  bn: "bn-IN-TanishaaNeural",
+  ta: "ta-IN-PallaviNeural",
+  te: "te-IN-ShrutiNeural",
+  mr: "mr-IN-AarohiNeural",
+  gu: "gu-IN-DhwaniNeural",
+  kn: "kn-IN-SapnaNeural",
+  ml: "ml-IN-SobhanaNeural",
+  ur: "ur-PK-UzmaNeural",
+  fa: "fa-IR-DilaraNeural",
+  sw: "sw-KE-ZuriNeural",
+  af: "af-ZA-AdriNeural",
+  ca: "ca-ES-JoanaNeural",
+  cy: "cy-GB-NiaNeural",
+  ga: "ga-IE-OrlaNeural",
+  mt: "mt-MT-GraceNeural",
+  is: "is-IS-GudrunNeural",
+  mk: "mk-MK-MarijaNeural",
+  sr: "sr-RS-SophieNeural",
+  bs: "bs-BA-VesnaNeural",
+  sq: "sq-AL-AnilaNeural",
+  am: "am-ET-MekdesNeural",
+  az: "az-AZ-BabekNeural",
+  ka: "ka-GE-EkaNeural",
+  kk: "kk-KZ-AigulNeural",
+  mn: "mn-MN-YesUINeural",
+  ne: "ne-NP-HemkalaNeural",
+  ps: "ps-AF-LatifaNeural",
+  si: "si-LK-ThiliniNeural",
+  so: "so-SO-UbaxNeural",
+  zu: "zu-ZA-ThandoNeural"
+};
+
+// src/lib/tts/generate.ts
+init_helpers();
+
+// src/lib/tts/synthesize.ts
+init_helpers();
+import { exec } from "child_process";
+import { writeFile as writeFile2 } from "fs/promises";
+import { join as join4, resolve as resolve2 } from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function synthesizeSpeech(text, outputPath, voice) {
+  const tempScriptPath = join4(resolve2(outputPath, ".."), `tts-${Date.now()}.py`);
+  const wslScriptPath = isWindows ? toWSLPathForTTS(resolve2(tempScriptPath)) : tempScriptPath;
+  const wslOutputPath = isWindows ? toWSLPathForTTS(resolve2(outputPath)) : outputPath;
+  const pythonScript = `
+import asyncio
+from edge_tts import Communicate
+
+async def main():
+    text = ${JSON.stringify(text)}
+    voice = ${JSON.stringify(voice)}
+    output = ${JSON.stringify(wslOutputPath)}
+    communicate = Communicate(text, voice)
+    await communicate.save(output)
+
+asyncio.run(main())
+`;
+  try {
+    await writeFile2(tempScriptPath, pythonScript);
+    const pythonCmd = isWindows ? `wsl python3 "${wslScriptPath}"` : `python3 "${wslScriptPath}"`;
+    await execAsync(pythonCmd, { timeout: 3e4 });
+    await import("fs/promises").then((fs) => fs.unlink(tempScriptPath).catch(() => {
+    }));
+    return;
+  } catch (pythonErr) {
+    await import("fs/promises").then((fs) => fs.unlink(tempScriptPath).catch(() => {
+    }));
+    const pythonMsg = pythonErr instanceof Error ? pythonErr.message : String(pythonErr);
+    const maxRetries = 2;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const { MsEdgeTTS, OUTPUT_FORMAT } = await import("msedge-tts");
+        const tts = new MsEdgeTTS();
+        await tts.setMetadata(voice, OUTPUT_FORMAT.AUDIO_24KHZ_96KBITRATE_MONO_MP3);
+        await tts.toFile(outputPath, text);
+        return;
+      } catch (nodeErr) {
+        if (attempt === maxRetries) {
+          const nodeMsg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
+          throw new Error(`TTS failed (Python: ${pythonMsg.slice(0, 100)}, Node: ${nodeMsg.slice(0, 100)})`);
+        }
+        await new Promise((r) => setTimeout(r, 500));
+      }
+    }
+  }
+}
+
+// src/lib/tts/generate.ts
+init_timing();
+function estimateDurationFromText(text, wordsPerMinute = 150) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0).length;
+  return Math.max(Math.round(words / wordsPerMinute * 60 * 1e3), 1500);
+}
+function resolveVoice(config) {
+  if (config.audio?.voice) return config.audio.voice;
+  if (config.lang) return LANGUAGE_VOICES[config.lang] || null;
+  return null;
+}
+async function generateVoiceover(steps, config, workDir, outputDir, logError, task, info) {
+  const voice = resolveVoice(config);
+  if (!voice) {
+    const stepAudio2 = /* @__PURE__ */ new Map();
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      const textDuration = step.caption ? estimateDurationFromText(step.caption) : 0;
+      const actionDuration = estimateActionDuration(step);
+      const manualDuration = (step.duration ?? 0) * 1e3;
+      const mediaDuration = await getMediaStepDuration(step, outputDir);
+      const duration = Math.max(
+        textDuration,
+        actionDuration,
+        manualDuration,
+        mediaDuration,
+        config.timing.minStepDuration
+      );
+      stepAudio2.set(i + 1, { duration, words: step.caption ? estimateWordTimings(step.caption, duration) : [] });
+    }
+    info("No voice configured");
+    return { voiceoverPath: "", stepAudio: stepAudio2 };
+  }
+  const audioDir = join5(workDir, "audio");
+  await mkdir(audioDir, { recursive: true });
+  const segments = [];
+  const stepAudio = /* @__PURE__ */ new Map();
+  const ttsTask = task("Generating voiceover");
+  for (let idx = 0; idx < steps.length; idx++) {
+    const step = steps[idx];
+    const stepNum = idx + 1;
+    if (!step.caption) {
+      const actionDuration = estimateActionDuration(step);
+      const manualDuration = (step.duration ?? 0) * 1e3;
+      const mediaDuration = await getMediaStepDuration(step, outputDir);
+      const silenceDuration = Math.max(actionDuration, manualDuration, mediaDuration, config.timing.minStepDuration);
+      const silencePath = join5(audioDir, `step-${stepNum}-silence.mp3`);
+      await generateSilence(silencePath, silenceDuration);
+      segments.push(silencePath);
+      stepAudio.set(stepNum, { duration: silenceDuration, words: [] });
+      continue;
+    }
+    const audioPath = join5(audioDir, `step-${stepNum}.mp3`);
+    if (segments.length > 0) await new Promise((r) => setTimeout(r, 200));
+    try {
+      await synthesizeSpeech(step.caption, audioPath, voice);
+      segments.push(audioPath);
+      const audioDuration = await getMediaDuration(audioPath);
+      const actionDuration = estimateActionDuration(step);
+      const manualDuration = (step.duration ?? 0) * 1e3;
+      const mediaDuration = await getMediaStepDuration(step, outputDir);
+      const stepDuration = Math.max(
+        audioDuration,
+        config.timing.minStepDuration,
+        actionDuration,
+        manualDuration,
+        mediaDuration
+      );
+      if (stepDuration > audioDuration) {
+        const paddingPath = join5(audioDir, `step-${stepNum}-padding.mp3`);
+        await generateSilence(paddingPath, stepDuration - audioDuration);
+        segments.push(paddingPath);
+      }
+      stepAudio.set(stepNum, { duration: stepDuration, words: estimateWordTimings(step.caption, audioDuration) });
+    } catch (err) {
+      await logError(`TTS Step ${stepNum}`, err);
+      stepAudio.set(stepNum, { duration: config.timing.minStepDuration, words: [] });
+    }
+  }
+  const stepsWithCaptions = steps.filter((s) => s.caption).length;
+  ttsTask.succeed(`${segments.length}/${stepsWithCaptions} clips`);
+  if (segments.length === 0) {
+    return { voiceoverPath: "", stepAudio };
+  }
+  const concatTask = task("Combining audio");
+  await mkdir(outputDir, { recursive: true });
+  const voiceoverPath = join5(outputDir, "voiceover.wav");
+  await concatenateAudio(segments, voiceoverPath, workDir);
+  concatTask.succeed("Done");
+  const meta = {
+    captionsHash: getCaptionsHash(steps),
+    totalCaptionLength: steps.reduce((sum, s) => sum + (s.caption?.length || 0), 0),
+    stepCount: steps.length,
+    voice,
+    stepDurations: Object.fromEntries(Array.from(stepAudio.entries()).map(([k, v]) => [k, v.duration]))
+  };
+  await saveVoiceoverMeta(outputDir, meta);
+  return { voiceoverPath, stepAudio };
+}
+
+// src/lib/tts/index.ts
+init_timing();
+
+// src/lib/index.ts
+init_utils();
+init_watermark();
+export {
+  CONFIG_FILE,
+  CURSOR_CSS,
+  CURSOR_PNG,
+  CURSOR_SCRIPT,
+  DEFAULT_CAPTIONS,
+  DEFAULT_CONFIG,
+  EXCLUDED_LINK_PATTERNS,
+  FEATURES,
+  INTERACTIVE_SELECTORS,
+  LANGUAGE_VOICES,
+  VERSION,
+  alignVoiceoverToRecording,
+  applyTransitions,
+  buildKeepSegments,
+  buildStepTransitions,
+  buildSystemPrompt,
+  buildUserPrompt,
+  buildWatermarkFilters,
+  callAI,
+  canReuseVoiceover,
+  composeVideo,
+  concatMedia,
+  concatVideoWithOutro,
+  crawlPage,
+  estimateWordTimings,
+  generateASSHeader,
+  generateSilence,
+  generateVoiceover,
+  getErrorMessage,
+  getLanguageName,
+  getMediaDuration,
+  getStatus,
+  getStatusCached,
+  getTierByEmail,
+  getUpgradeUrl,
+  hasAccess,
+  hasTrialRemaining,
+  hexToASS,
+  isCanceling,
+  isExcludedLink,
+  isPaid,
+  isVerified,
+  loadExistingVoiceover,
+  loadVoiceoverMeta,
+  mapTimestampsAfterCompression,
+  normalizeUrl,
+  parseAIPlanResponse,
+  parsePartial,
+  pricingUrl,
+  registerFreeUser,
+  resolveVoice,
+  rgbaToHex,
+  shouldSkipLink,
+  shouldWatermark,
+  showPaywall,
+  speedUpVideo,
+  spliceVideos,
+  synthesizeSpeech,
+  toTitleCase,
+  windowsPathToWSL
+};