Spaces:
Running
Running
| // Clipwhit moment finder: pure functions (browser + Node tests). Turns a timestamped transcript and an audio | |
| // loudness envelope into ranked, non-overlapping short-clip candidates with the reasons each one scored. | |
| // © 2026 CyberMax. All rights reserved. | |
| export const STOP = new Set(('a an and are as at be but by for from has have he her his i if in into is it its just like me my ' + | |
| 'not of on or our out so that the their them then there they this to up us was we were what when which who will with you your ' + | |
| 'yeah okay ok um uh really very actually going gonna get got do does did dont don\'t im i\'m it\'s thats that\'s youre you\'re ' + | |
| 'about all also can could would should one two some more most much many been being because how why where here now know think ' + | |
| 'thing things people said say says want make made time right well let lets let\'s kind sort mean guess stuff lot little ' + | |
| 'first second third version episode listening welcome today back show talking talk thanks next every single least before after ' + | |
| 'would could should never always over under still even only same other another those these into onto than tell tells told give gave').split(/\s+/)); | |
| // Phrases that make a viewer stop scrolling (weights are relative; tuned on podcast transcripts). | |
| const HOOKS = [ | |
| [/\b(secret|nobody (tells|talks)|no one (tells|talks)|the truth|biggest mistake|mistakes?|the trick|here'?s (why|how|the thing|what)|what (nobody|most people))\b/i, 3], | |
| [/\b(never|always|stop|don'?t|worst|best|insane|crazy|shocking|surpris\w*|wrong|myth|lie|lied|honestly|truth)\b/i, 1.5], | |
| [/\b(how to|how i|how we|why you|why most|the reason|the one thing|the (first|second|third|only))\b/i, 2], | |
| [/\b(\d[\d,.]*\s?(%|percent|k|thousand|million|billion|x|times|hours?|days?|weeks?|years?|dollars?|views?)|\$\s?\d)/i, 2], | |
| [/\?/, 1], | |
| ]; | |
| const PAYOFF = /\b(that'?s (the|why|how|it)|the whole trick|so the lesson|the point is|bottom line|in short|which means|that'?s what)\b/i; | |
| const LAUGH = /\[(laugh\w*|applause|chuckl\w*)\]|\((laugh\w*|applause)\)|\b(ha(ha)+|lol)\b/i; | |
| const WEAK_START = /^(and|but|so|or|because|um|uh|like|yeah|okay|right)\b/i; | |
| const FILLER = /\b(um+|uh+|you know|i mean|sort of|kind of)\b/gi; | |
| export const clean = (s) => String(s || '').replace(/\s+/g, ' ').trim(); | |
| const wordsOf = (s) => clean(s).split(' ').filter(Boolean); | |
| /** Whisper chunks [{timestamp:[s,e], text}] -> [{start, end, text}] (drops empties, fixes null ends). */ | |
| export function toSegments(chunks, duration = Infinity) { | |
| const out = []; | |
| for (const c of chunks || []) { | |
| const text = clean(c.text); | |
| if (!text || /^\[(blank_audio|music|silence)\]$/i.test(text)) continue; | |
| const [s, e] = c.timestamp || [c.start, c.end]; | |
| const start = Math.max(0, Number(s) || 0); | |
| let end = Number(e); | |
| if (!Number.isFinite(end) || end <= start) end = Math.min(duration, start + Math.max(1.5, wordsOf(text).length * 0.35)); | |
| if (out.length && text === out[out.length - 1].text) continue; // Whisper repeats a line at window seams | |
| out.push({ start, end, text }); | |
| } | |
| return out; | |
| } | |
| /** Word timings spread over each segment by character length (Whisper gives segment-level stamps). */ | |
| export function toWords(segments) { | |
| const words = []; | |
| for (const s of segments) { | |
| const w = wordsOf(s.text); | |
| if (!w.length) continue; | |
| const weights = w.map((x) => Math.max(2, x.replace(/[^\p{L}\p{N}]/gu, '').length + 1)); | |
| const total = weights.reduce((a, b) => a + b, 0); | |
| let t = s.start; | |
| const span = Math.max(0.2, s.end - s.start); | |
| w.forEach((text, i) => { | |
| const d = (span * weights[i]) / total; | |
| words.push({ text, start: t, end: t + d }); | |
| t += d; | |
| }); | |
| } | |
| return words; | |
| } | |
| /** RMS loudness per `step` seconds from 16 kHz mono samples. */ | |
| export function envelope(audio, rate = 16000, step = 0.5) { | |
| const n = Math.max(1, Math.floor(rate * step)); | |
| const out = new Float32Array(Math.ceil(audio.length / n)); | |
| for (let i = 0; i < out.length; i++) { | |
| let sum = 0; | |
| const a = i * n, b = Math.min(audio.length, a + n); | |
| for (let j = a; j < b; j++) sum += audio[j] * audio[j]; | |
| out[i] = Math.sqrt(sum / Math.max(1, b - a)); | |
| } | |
| return { step, values: out }; | |
| } | |
| function energyOf(env, start, end) { | |
| if (!env || !env.values?.length) return null; | |
| const a = Math.floor(start / env.step), b = Math.max(a + 1, Math.ceil(end / env.step)); | |
| let s = 0, n = 0; | |
| for (let i = a; i < b && i < env.values.length; i++) { s += env.values[i]; n++; } | |
| return n ? s / n : null; | |
| } | |
| function mean(env) { | |
| if (!env || !env.values?.length) return null; | |
| let s = 0, n = 0; | |
| for (const v of env.values) if (v > 0.003) { s += v; n++; } | |
| return n ? s / n : null; | |
| } | |
| /** Candidate windows that start on a segment boundary and end on one, lasting minLen..maxLen seconds. */ | |
| export function candidates(segments, { minLen = 15, maxLen = 60 } = {}) { | |
| const out = []; | |
| for (let i = 0; i < segments.length; i++) { | |
| let text = ''; | |
| for (let j = i; j < segments.length; j++) { | |
| text += (text ? ' ' : '') + segments[j].text; | |
| const dur = segments[j].end - segments[i].start; | |
| if (dur > maxLen) break; | |
| if (dur >= minLen) out.push({ i, j, start: segments[i].start, end: segments[j].end, text }); | |
| } | |
| } | |
| return out; | |
| } | |
| /** Score one window. Returns { score, reasons[] } with every contribution named. */ | |
| export function scoreWindow(w, segments, env, avgEnergy, { target = 35 } = {}) { | |
| const reasons = []; | |
| let score = 0; | |
| const add = (v, why) => { if (v) { score += v; reasons.push(why); } }; | |
| const first = segments[w.i].text; | |
| const opener = clean(segments.slice(w.i, w.i + 2).map((s) => s.text).join(' ')).slice(0, 160); | |
| let hook = 0; | |
| for (const [re, wt] of HOOKS) if (re.test(opener)) hook += wt; | |
| add(Math.min(hook, 6) * 1.2, hook ? 'strong hook in the first seconds' : ''); | |
| let body = 0; | |
| for (const [re, wt] of HOOKS) if (re.test(w.text)) body += wt * 0.35; | |
| add(Math.min(body, 3), ''); | |
| add(PAYOFF.test(w.text) ? 2 : 0, 'has a payoff line'); | |
| add(/[.!?]["')\]]?$/.test(w.text.trim()) ? 1.5 : -1.5, /[.!?]["')\]]?$/.test(w.text.trim()) ? 'ends on a complete sentence' : 'ends mid-sentence'); | |
| add(/^[A-Z0-9"'$]/.test(first) && !WEAK_START.test(first) ? 1 : -1, WEAK_START.test(first) ? 'starts on a filler word' : 'clean start'); | |
| add(LAUGH.test(w.text) ? 2 : 0, 'laughter or reaction'); | |
| const dur = w.end - w.start; | |
| const n = wordsOf(w.text).length; | |
| const wps = n / Math.max(1, dur); | |
| add(wps >= 2.2 && wps <= 4.2 ? 1 : wps < 1.4 ? -2 : 0, wps >= 2.2 && wps <= 4.2 ? 'lively pace' : wps < 1.4 ? 'slow or silent stretch' : ''); | |
| const fillers = (w.text.match(FILLER) || []).length; | |
| add(fillers > 3 ? -Math.min(3, fillers * 0.3) : 0, fillers > 3 ? 'many filler words' : ''); | |
| const gap = w.i > 0 ? segments[w.i].start - segments[w.i - 1].end : 1; | |
| add(gap >= 0.6 ? 0.8 : 0, gap >= 0.6 ? 'begins after a pause' : ''); | |
| const e = energyOf(env, w.start, w.end); | |
| if (e != null && avgEnergy) { | |
| const r = e / avgEnergy; | |
| add(r > 1.15 ? Math.min(2, (r - 1) * 4) : r < 0.75 ? -1 : 0, r > 1.15 ? 'louder, more energetic audio' : r < 0.75 ? 'quiet audio' : ''); | |
| } | |
| add(-Math.abs(dur - target) / 12, ''); | |
| return { score: Math.round(score * 100) / 100, reasons: reasons.filter(Boolean) }; | |
| } | |
| /** Ranked, non-overlapping moments. */ | |
| export function pickMoments(segments, env, { count = 10, minLen = 15, maxLen = 60, target = 35 } = {}) { | |
| const avg = mean(env); | |
| const scored = candidates(segments, { minLen, maxLen }).map((w) => ({ ...w, ...scoreWindow(w, segments, env, avg, { target }) })); | |
| scored.sort((a, b) => b.score - a.score || a.start - b.start); | |
| const picked = []; | |
| const bag = (t) => new Set(wordsOf(t.toLowerCase()).map((w) => w.replace(/[^\p{L}\p{N}]/gu, '')).filter((w) => w.length > 2)); | |
| const similar = (a, b) => { let n = 0; for (const w of a) if (b.has(w)) n++; return n / Math.max(1, Math.min(a.size, b.size)); }; | |
| for (const c of scored) { | |
| if (picked.length >= count) break; | |
| if (picked.some((p) => c.start < p.end - 1 && c.end > p.start + 1)) continue; | |
| c.bag = bag(c.text); | |
| if (picked.some((p) => similar(c.bag, p.bag) > 0.7)) continue; // the same story told twice (re-runs, intros, ad reads) | |
| picked.push(c); | |
| } | |
| return picked.map((c, k) => ({ id: k + 1, start: c.start, end: c.end, text: c.text, score: c.score, reasons: c.reasons, ...clipMeta(c.text) })); | |
| } | |
| /** Also exported for the transcript-only Hook Finder: plain text / SRT / VTT -> segments. */ | |
| export function parseTranscript(src) { | |
| const txt = String(src || '').replace(/\r/g, ''); | |
| const ts = (h, m, s, ms) => (+h || 0) * 3600 + (+m) * 60 + (+s) + (+(ms || 0)) / 1000; | |
| const re = /(?:(\d+):)?(\d{1,2}):(\d{2})(?:[.,](\d{1,3}))?\s*-->\s*(?:(\d+):)?(\d{1,2}):(\d{2})(?:[.,](\d{1,3}))?[^\n]*\n([\s\S]*?)(?=\n\s*\n|\n?$)/g; | |
| const out = []; | |
| let m; | |
| while ((m = re.exec(txt))) { | |
| const text = clean(m[9].replace(/<[^>]+>/g, '').replace(/^\d+$/gm, '')); | |
| if (text) out.push({ start: ts(m[1], m[2], m[3], (m[4] || '0').padEnd(3, '0')), end: ts(m[5], m[6], m[7], (m[8] || '0').padEnd(3, '0')), text }); | |
| } | |
| if (out.length) return out; | |
| // Plain text: optional [hh:mm:ss] or (mm:ss) stamps; otherwise sentences at ~2.8 words per second. | |
| const sentences = txt.split(/\n+|(?<=[.!?])\s+/).map(clean).filter(Boolean); | |
| let t = 0; | |
| for (const s of sentences) { | |
| const st = s.match(/^[[(]?(?:(\d+):)?(\d{1,2}):(\d{2})[\])]?\s*/); | |
| if (st) t = ts(st[1], st[2], st[3]); | |
| const text = st ? s.slice(st[0].length) : s; | |
| if (!text) continue; | |
| const d = Math.max(1.2, wordsOf(text).length / 2.8); | |
| out.push({ start: t, end: t + d, text }); | |
| t += d; | |
| } | |
| return out; | |
| } | |
| const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1); | |
| /** Title, description and hashtags from the clip's own words (local, no AI). */ | |
| export function clipMeta(text) { | |
| const sentences = clean(text).split(/(?<=[.!?])\s+/).filter(Boolean); | |
| let best = sentences[0] || clean(text); | |
| let bestScore = -1; | |
| for (const s of sentences.slice(0, 6)) { | |
| let sc = 0; | |
| for (const [re, wt] of HOOKS) if (re.test(s)) sc += wt; | |
| sc -= Math.abs(wordsOf(s).length - 11) * 0.08; | |
| if (sc > bestScore) { bestScore = sc; best = s; } | |
| } | |
| let title = best.replace(WEAK_START, '').replace(/^[,\s]+/, '').replace(/[.,;:]+$/, ''); | |
| if (title.length > 70) title = title.slice(0, 67).replace(/\s+\S*$/, '') + '…'; | |
| title = cap(title); | |
| const counts = new Map(); | |
| for (const w of wordsOf(text.toLowerCase())) { | |
| const k = w.replace(/[^\p{L}\p{N}]/gu, ''); | |
| if (k.length < 4 || STOP.has(k) || /^\d+$/.test(k)) continue; | |
| counts.set(k, (counts.get(k) || 0) + 1); | |
| } | |
| const top = [...counts.entries()].sort((a, b) => b[1] - a[1] || b[0].length - a[0].length).slice(0, 3).map(([k]) => `#${k}`); | |
| const hashtags = [...new Set([...top, '#podcast', '#shorts'])].slice(0, 5); | |
| const description = `${sentences.slice(0, 2).join(' ').slice(0, 220)}${sentences.length > 2 ? '…' : ''}`; | |
| return { title, description, hashtags }; | |
| } | |
| export const clock = (s) => { | |
| s = Math.max(0, Math.round(s)); | |
| const h = Math.floor(s / 3600), m = Math.floor((s % 3600) / 60), x = s % 60; | |
| return h ? `${h}:${String(m).padStart(2, '0')}:${String(x).padStart(2, '0')}` : `${m}:${String(x).padStart(2, '0')}`; | |
| }; | |