eprec 0.0.1 → 1.1.0

package/process-course/utils/time-ranges.test.ts

@@ -0,0 +1,221 @@
+import { test, expect } from 'bun:test'
+import {
+	mergeTimeRanges,
+	buildKeepRanges,
+	sumRangeDuration,
+	adjustTimeForRemovedRanges,
+} from './time-ranges'
+import type { TimeRange } from '../types'
+
+// Factory functions for test data
+function createRange(start: number, end: number): TimeRange {
+	return { start, end }
+}
+
+function createRanges(...pairs: [number, number][]): TimeRange[] {
+	return pairs.map(([start, end]) => createRange(start, end))
+}
+
+// mergeTimeRanges tests
+test('mergeTimeRanges returns empty array for empty input', () => {
+	expect(mergeTimeRanges([])).toEqual([])
+})
+
+test('mergeTimeRanges returns single range unchanged', () => {
+	expect(mergeTimeRanges([createRange(1, 5)])).toEqual([createRange(1, 5)])
+})
+
+test('mergeTimeRanges merges overlapping ranges', () => {
+	const ranges = createRanges([1, 5], [3, 8])
+	expect(mergeTimeRanges(ranges)).toEqual([createRange(1, 8)])
+})
+
+test('mergeTimeRanges merges adjacent ranges within 0.01 tolerance', () => {
+	const ranges = createRanges([1, 5], [5.005, 8])
+	expect(mergeTimeRanges(ranges)).toEqual([createRange(1, 8)])
+})
+
+test('mergeTimeRanges keeps separate non-adjacent ranges', () => {
+	const ranges = createRanges([1, 5], [6, 10])
+	expect(mergeTimeRanges(ranges)).toEqual(createRanges([1, 5], [6, 10]))
+})
+
+test('mergeTimeRanges handles unsorted input', () => {
+	const ranges = createRanges([10, 15], [1, 5], [3, 8])
+	expect(mergeTimeRanges(ranges)).toEqual(createRanges([1, 8], [10, 15]))
+})
+
+test('mergeTimeRanges merges multiple overlapping ranges into one', () => {
+	const ranges = createRanges([1, 3], [2, 5], [4, 7], [6, 10])
+	expect(mergeTimeRanges(ranges)).toEqual([createRange(1, 10)])
+})
+
+test('mergeTimeRanges handles contained range', () => {
+	const ranges = createRanges([1, 10], [3, 5])
+	expect(mergeTimeRanges(ranges)).toEqual([createRange(1, 10)])
+})
+
+test('mergeTimeRanges handles same start time', () => {
+	const ranges = createRanges([1, 5], [1, 8])
+	expect(mergeTimeRanges(ranges)).toEqual([createRange(1, 8)])
+})
+
+test('mergeTimeRanges handles same end time', () => {
+	const ranges = createRanges([1, 10], [5, 10])
+	expect(mergeTimeRanges(ranges)).toEqual([createRange(1, 10)])
+})
+
+test('mergeTimeRanges handles zero-width range', () => {
+	expect(mergeTimeRanges([createRange(5, 5)])).toEqual([createRange(5, 5)])
+})
+
+// buildKeepRanges tests
+test('buildKeepRanges returns full range when no exclusions', () => {
+	expect(buildKeepRanges(0, 100, [])).toEqual([createRange(0, 100)])
+})
+
+test('buildKeepRanges excludes single middle range', () => {
+	const exclude = [createRange(30, 50)]
+	expect(buildKeepRanges(0, 100, exclude)).toEqual(
+		createRanges([0, 30], [50, 100]),
+	)
+})
+
+test('buildKeepRanges excludes range at start', () => {
+	const exclude = [createRange(0, 20)]
+	expect(buildKeepRanges(0, 100, exclude)).toEqual([createRange(20, 100)])
+})
+
+test('buildKeepRanges excludes range at end', () => {
+	const exclude = [createRange(80, 100)]
+	expect(buildKeepRanges(0, 100, exclude)).toEqual([createRange(0, 80)])
+})
+
+test('buildKeepRanges excludes multiple non-overlapping ranges', () => {
+	const exclude = createRanges([10, 20], [50, 60])
+	expect(buildKeepRanges(0, 100, exclude)).toEqual(
+		createRanges([0, 10], [20, 50], [60, 100]),
+	)
+})
+
+test('buildKeepRanges merges overlapping exclusions', () => {
+	const exclude = createRanges([10, 30], [20, 40])
+	expect(buildKeepRanges(0, 100, exclude)).toEqual(
+		createRanges([0, 10], [40, 100]),
+	)
+})
+
+test('buildKeepRanges handles exclusion beyond end', () => {
+	const exclude = [createRange(80, 120)]
+	expect(buildKeepRanges(0, 100, exclude)).toEqual([createRange(0, 80)])
+})
+
+test('buildKeepRanges handles exclusion before start', () => {
+	const exclude = [createRange(-10, 20)]
+	expect(buildKeepRanges(0, 100, exclude)).toEqual([createRange(20, 100)])
+})
+
+test('buildKeepRanges returns empty when entire range excluded', () => {
+	const exclude = [createRange(0, 100)]
+	expect(buildKeepRanges(0, 100, exclude)).toEqual([])
+})
+
+test('buildKeepRanges handles unsorted exclusions', () => {
+	const exclude = createRanges([50, 60], [10, 20])
+	expect(buildKeepRanges(0, 100, exclude)).toEqual(
+		createRanges([0, 10], [20, 50], [60, 100]),
+	)
+})
+
+test('buildKeepRanges filters zero-width keep ranges', () => {
+	const exclude = createRanges([0, 50], [50, 100])
+	expect(buildKeepRanges(0, 100, exclude)).toEqual([])
+})
+
+test('buildKeepRanges ignores exclusion before range', () => {
+	const exclude = [createRange(-20, -10)]
+	expect(buildKeepRanges(0, 100, exclude)).toEqual([createRange(0, 100)])
+})
+
+// sumRangeDuration tests
+test('sumRangeDuration returns 0 for empty array', () => {
+	expect(sumRangeDuration([])).toBe(0)
+})
+
+test('sumRangeDuration returns duration of single range', () => {
+	expect(sumRangeDuration([createRange(10, 30)])).toBe(20)
+})
+
+test('sumRangeDuration sums multiple ranges', () => {
+	const ranges = createRanges([0, 10], [20, 35], [50, 60])
+	expect(sumRangeDuration(ranges)).toBe(35)
+})
+
+test('sumRangeDuration handles zero-width ranges', () => {
+	const ranges = createRanges([5, 5], [10, 20])
+	expect(sumRangeDuration(ranges)).toBe(10)
+})
+
+test('sumRangeDuration handles invalid negative duration', () => {
+	expect(sumRangeDuration([createRange(20, 10)])).toBe(-10)
+})
+
+test('sumRangeDuration handles floating point values', () => {
+	const ranges = createRanges([0, 1.5], [2.5, 4.75])
+	expect(sumRangeDuration(ranges)).toBeCloseTo(3.75)
+})
+
+// adjustTimeForRemovedRanges tests
+test('adjustTimeForRemovedRanges returns same time when no ranges removed', () => {
+	expect(adjustTimeForRemovedRanges(50, [])).toBe(50)
+})
+
+test('adjustTimeForRemovedRanges adjusts for removed range before time', () => {
+	const removed = [createRange(10, 20)]
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(40)
+})
+
+test('adjustTimeForRemovedRanges does not adjust for removed range after time', () => {
+	const removed = [createRange(60, 80)]
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(50)
+})
+
+test('adjustTimeForRemovedRanges adjusts for multiple removed ranges', () => {
+	const removed = createRanges([5, 10], [20, 30])
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(35)
+})
+
+test('adjustTimeForRemovedRanges handles time within removed range', () => {
+	const removed = [createRange(40, 60)]
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(40)
+})
+
+test('adjustTimeForRemovedRanges handles time at start of removed range', () => {
+	const removed = [createRange(50, 60)]
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(50)
+})
+
+test('adjustTimeForRemovedRanges handles time at end of removed range', () => {
+	const removed = [createRange(40, 50)]
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(40)
+})
+
+test('adjustTimeForRemovedRanges handles overlapping removed ranges', () => {
+	const removed = createRanges([10, 30], [20, 40])
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(20)
+})
+
+test('adjustTimeForRemovedRanges handles unsorted removed ranges', () => {
+	const removed = createRanges([30, 40], [10, 20])
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(30)
+})
+
+test('adjustTimeForRemovedRanges handles time at zero', () => {
+	const removed = [createRange(10, 20)]
+	expect(adjustTimeForRemovedRanges(0, removed)).toBe(0)
+})
+
+test('adjustTimeForRemovedRanges handles removed range starting at zero', () => {
+	const removed = [createRange(0, 10)]
+	expect(adjustTimeForRemovedRanges(50, removed)).toBe(40)
+})

package/process-course/utils/time-ranges.ts

@@ -0,0 +1,86 @@
+import type { TimeRange } from '../types'
+
+/**
+ * Merge overlapping or adjacent time ranges into a minimal set of non-overlapping ranges.
+ */
+export function mergeTimeRanges(ranges: TimeRange[]): TimeRange[] {
+	if (ranges.length === 0) {
+		return []
+	}
+	const sorted = [...ranges].sort((a, b) => a.start - b.start)
+	const merged: TimeRange[] = []
+	let current = sorted[0]
+	if (!current) {
+		return []
+	}
+	for (const range of sorted.slice(1)) {
+		if (range.start <= current.end + 0.01) {
+			current = { start: current.start, end: Math.max(current.end, range.end) }
+		} else {
+			merged.push(current)
+			current = range
+		}
+	}
+	merged.push(current)
+	return merged
+}
+
+/**
+ * Build keep ranges by subtracting exclusion windows from a full duration.
+ */
+export function buildKeepRanges(
+	start: number,
+	end: number,
+	exclude: TimeRange[],
+): TimeRange[] {
+	if (exclude.length === 0) {
+		return [{ start, end }]
+	}
+	const ranges: TimeRange[] = []
+	let cursor = start
+	for (const window of mergeTimeRanges(exclude)) {
+		if (window.end <= cursor) {
+			continue
+		}
+		if (window.start > cursor) {
+			ranges.push({ start: cursor, end: window.start })
+		}
+		cursor = Math.max(cursor, window.end)
+	}
+	if (cursor < end) {
+		ranges.push({ start: cursor, end })
+	}
+	return ranges.filter((range) => range.end > range.start)
+}
+
+/**
+ * Sum the total duration of a set of time ranges.
+ */
+export function sumRangeDuration(ranges: TimeRange[]): number {
+	return ranges.reduce((total, range) => total + (range.end - range.start), 0)
+}
+
+/**
+ * Adjust a timestamp to account for removed time ranges.
+ */
+export function adjustTimeForRemovedRanges(
+	time: number,
+	removed: TimeRange[],
+): number {
+	if (removed.length === 0) {
+		return time
+	}
+	let adjusted = time
+	for (const range of mergeTimeRanges(removed)) {
+		if (range.end <= time) {
+			adjusted -= range.end - range.start
+			continue
+		}
+		if (range.start < time && range.end > time) {
+			adjusted -= time - range.start
+			break
+		}
+		break
+	}
+	return adjusted
+}

package/process-course/utils/transcript.test.ts

@@ -0,0 +1,257 @@
+import { test, expect } from 'bun:test'
+import {
+	countTranscriptWords,
+	findWordTimings,
+	normalizeSkipPhrases,
+	transcriptIncludesWord,
+	normalizeWords,
+} from './transcript'
+import { TRANSCRIPTION_PHRASES } from '../config'
+import type { TranscriptSegment } from '../../whispercpp-transcribe'
+
+function createPhrases(...phrases: string[]): string[] {
+	return phrases
+}
+
+function createSegment(
+	start: number,
+	end: number,
+	text: string,
+): TranscriptSegment {
+	return { start, end, text }
+}
+
+function createSegments(...segments: TranscriptSegment[]): TranscriptSegment[] {
+	return segments
+}
+
+// normalizeSkipPhrases tests
+test('normalizeSkipPhrases trims, lowercases, and filters empty', () => {
+	expect(normalizeSkipPhrases(createPhrases('  Hello ', ' ', 'World'))).toEqual(
+		['hello', 'world'],
+	)
+})
+
+test('normalizeSkipPhrases accepts a single phrase value', () => {
+	expect(normalizeSkipPhrases(' Jarvis Bad Take ')).toEqual(['jarvis bad take'])
+})
+
+test('normalizeSkipPhrases de-duplicates phrases while preserving order', () => {
+	expect(
+		normalizeSkipPhrases(
+			createPhrases(
+				'Jarvis Bad Take',
+				'jarvis bad take',
+				'bad take jarvis',
+				'BAD TAKE JARVIS',
+			),
+		),
+	).toEqual(['jarvis bad take', 'bad take jarvis'])
+})
+
+test('normalizeSkipPhrases falls back to defaults when empty', () => {
+	expect(normalizeSkipPhrases('   ')).toEqual(TRANSCRIPTION_PHRASES)
+	expect(normalizeSkipPhrases([])).toEqual(TRANSCRIPTION_PHRASES)
+})
+
+// countTranscriptWords tests
+test('countTranscriptWords returns 0 for empty string', () => {
+	expect(countTranscriptWords('')).toBe(0)
+})
+
+test('countTranscriptWords returns 0 for whitespace-only string', () => {
+	expect(countTranscriptWords('   ')).toBe(0)
+	expect(countTranscriptWords('\t\n')).toBe(0)
+})
+
+test('countTranscriptWords counts single word', () => {
+	expect(countTranscriptWords('hello')).toBe(1)
+})
+
+test('countTranscriptWords counts multiple words', () => {
+	expect(countTranscriptWords('hello world')).toBe(2)
+	expect(countTranscriptWords('one two three four five')).toBe(5)
+})
+
+test('countTranscriptWords handles multiple spaces between words', () => {
+	expect(countTranscriptWords('hello    world')).toBe(2)
+})
+
+test('countTranscriptWords handles leading and trailing whitespace', () => {
+	expect(countTranscriptWords('  hello world  ')).toBe(2)
+})
+
+test('countTranscriptWords handles mixed whitespace', () => {
+	expect(countTranscriptWords('hello\tworld\nfoo')).toBe(3)
+})
+
+test('countTranscriptWords counts punctuated words', () => {
+	expect(countTranscriptWords('Hello, world! How are you?')).toBe(5)
+})
+
+test('countTranscriptWords counts typical transcript', () => {
+	const text =
+		"So today we're going to learn about React hooks and how they work."
+	expect(countTranscriptWords(text)).toBe(13)
+})
+
+// transcriptIncludesWord tests
+test('transcriptIncludesWord returns false for empty transcript', () => {
+	expect(transcriptIncludesWord('', 'hello')).toBe(false)
+})
+
+test('transcriptIncludesWord returns false for whitespace-only transcript', () => {
+	expect(transcriptIncludesWord('   ', 'hello')).toBe(false)
+})
+
+test('transcriptIncludesWord finds exact word', () => {
+	expect(transcriptIncludesWord('hello world', 'hello')).toBe(true)
+	expect(transcriptIncludesWord('hello world', 'world')).toBe(true)
+})
+
+test('transcriptIncludesWord returns false for missing word', () => {
+	expect(transcriptIncludesWord('hello world', 'foo')).toBe(false)
+})
+
+test('transcriptIncludesWord is case insensitive', () => {
+	expect(transcriptIncludesWord('Hello World', 'hello')).toBe(true)
+	expect(transcriptIncludesWord('hello world', 'HELLO')).toBe(true)
+})
+
+test('transcriptIncludesWord does not match partial words', () => {
+	expect(transcriptIncludesWord('hello world', 'hell')).toBe(false)
+	expect(transcriptIncludesWord('hello world', 'ello')).toBe(false)
+})
+
+test('transcriptIncludesWord handles punctuation', () => {
+	expect(transcriptIncludesWord('Hello, world!', 'hello')).toBe(true)
+	expect(transcriptIncludesWord('Hello, world!', 'world')).toBe(true)
+})
+
+test('transcriptIncludesWord finds jarvis after jervis normalization', () => {
+	expect(transcriptIncludesWord('Jervis said hello', 'jarvis')).toBe(true)
+})
+
+test('transcriptIncludesWord finds bad and take after badtake normalization', () => {
+	expect(transcriptIncludesWord('That was a badtake', 'bad')).toBe(true)
+	expect(transcriptIncludesWord('That was a badtake', 'take')).toBe(true)
+})
+
+// normalizeWords - basic normalization
+test('normalizeWords returns empty array for empty string', () => {
+	expect(normalizeWords('')).toEqual([])
+})
+
+test('normalizeWords returns empty array for whitespace-only string', () => {
+	expect(normalizeWords('   ')).toEqual([])
+	expect(normalizeWords('\t\n')).toEqual([])
+})
+
+test('normalizeWords lowercases all words', () => {
+	expect(normalizeWords('Hello World')).toEqual(['hello', 'world'])
+	expect(normalizeWords('HELLO WORLD')).toEqual(['hello', 'world'])
+})
+
+test('normalizeWords removes punctuation', () => {
+	expect(normalizeWords('Hello, world!')).toEqual(['hello', 'world'])
+	expect(normalizeWords("What's up?")).toEqual(['what', 's', 'up'])
+})
+
+test('normalizeWords handles multiple spaces', () => {
+	expect(normalizeWords('hello    world')).toEqual(['hello', 'world'])
+})
+
+test('normalizeWords preserves numbers', () => {
+	expect(normalizeWords('hello 123 world')).toEqual(['hello', '123', 'world'])
+})
+
+test('normalizeWords handles mixed alphanumeric', () => {
+	expect(normalizeWords('react18 hooks')).toEqual(['react18', 'hooks'])
+})
+
+// normalizeWords - corrections
+test('normalizeWords corrects jervis to jarvis', () => {
+	expect(normalizeWords('jervis')).toEqual(['jarvis'])
+	expect(normalizeWords('Jervis said hello')).toEqual([
+		'jarvis',
+		'said',
+		'hello',
+	])
+})
+
+test('normalizeWords splits badtake into bad take', () => {
+	expect(normalizeWords('badtake')).toEqual(['bad', 'take'])
+	expect(normalizeWords('That was a badtake')).toEqual([
+		'that',
+		'was',
+		'a',
+		'bad',
+		'take',
+	])
+})
+
+test('normalizeWords splits batteik into bad take', () => {
+	expect(normalizeWords('batteik')).toEqual(['bad', 'take'])
+})
+
+test('normalizeWords splits batteke into bad take', () => {
+	expect(normalizeWords('batteke')).toEqual(['bad', 'take'])
+})
+
+// normalizeWords - blank audio handling
+test('normalizeWords returns empty for blank audio', () => {
+	expect(normalizeWords('blank audio')).toEqual([])
+})
+
+test('normalizeWords returns empty for Blank Audio (case insensitive)', () => {
+	expect(normalizeWords('Blank Audio')).toEqual([])
+})
+
+test('normalizeWords returns empty for blankaudio', () => {
+	expect(normalizeWords('blankaudio')).toEqual([])
+})
+
+test('normalizeWords keeps blank and audio in other contexts', () => {
+	expect(normalizeWords('blank space')).toEqual(['blank', 'space'])
+	expect(normalizeWords('audio file')).toEqual(['audio', 'file'])
+})
+
+// normalizeWords - edge cases
+test('normalizeWords returns empty for special characters only', () => {
+	expect(normalizeWords('!@#$%')).toEqual([])
+})
+
+test('normalizeWords handles single character', () => {
+	expect(normalizeWords('a')).toEqual(['a'])
+})
+
+test('normalizeWords handles single number', () => {
+	expect(normalizeWords('5')).toEqual(['5'])
+})
+
+test('normalizeWords handles complex sentence with commands', () => {
+	expect(
+		normalizeWords("Jarvis, bad take! Let's try again... thanks!"),
+	).toEqual(['jarvis', 'bad', 'take', 'let', 's', 'try', 'again', 'thanks'])
+})
+
+test('normalizeWords handles multiple corrections in one string', () => {
+	expect(normalizeWords('jervis badtake')).toEqual(['jarvis', 'bad', 'take'])
+})
+
+// findWordTimings tests
+test('findWordTimings returns empty for missing segments', () => {
+	expect(findWordTimings(createSegments(), 'jarvis')).toEqual([])
+})
+
+test('findWordTimings returns jarvis timings with normalization', () => {
+	const segments = createSegments(
+		createSegment(0, 4, 'Hello Jarvis'),
+		createSegment(4, 6, 'jervis again'),
+	)
+
+	expect(findWordTimings(segments, 'jarvis')).toEqual([
+		{ start: 2, end: 4 },
+		{ start: 4, end: 5 },
+	])
+})

package/process-course/utils/transcript.ts

@@ -0,0 +1,86 @@
+import type { TranscriptSegment } from '../../whispercpp-transcribe'
+import type { TimeRange } from '../types'
+import { TRANSCRIPTION_PHRASES } from '../config'
+import { buildTranscriptWords } from '../jarvis-commands/parser'
+
+/**
+ * Normalize skip phrases from CLI input.
+ */
+export function normalizeSkipPhrases(rawPhrases: unknown): string[] {
+	const rawList = Array.isArray(rawPhrases) ? rawPhrases : [rawPhrases]
+	const phrases = rawList
+		.filter((value): value is string => typeof value === 'string')
+		.map((value) => value.trim())
+		.filter(Boolean)
+		.map((value) => value.toLowerCase())
+	const uniquePhrases = [...new Set(phrases)]
+
+	return uniquePhrases.length > 0 ? uniquePhrases : TRANSCRIPTION_PHRASES
+}
+
+/**
+ * Count words in a transcript string.
+ */
+export function countTranscriptWords(transcript: string): number {
+	if (!transcript.trim()) {
+		return 0
+	}
+	return transcript.trim().split(/\s+/).length
+}
+
+/**
+ * Check if a transcript includes a specific word.
+ */
+export function transcriptIncludesWord(
+	transcript: string,
+	word: string,
+): boolean {
+	if (!transcript.trim()) {
+		return false
+	}
+	const normalized = normalizeWords(transcript)
+	return normalized.includes(word.toLowerCase())
+}
+
+/**
+ * Normalize text into an array of lowercase words, with common corrections.
+ */
+export function normalizeWords(text: string): string[] {
+	const normalized = text
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, ' ')
+		.trim()
+	if (!normalized) {
+		return []
+	}
+	if (normalized === 'blank audio' || normalized === 'blankaudio') {
+		return []
+	}
+	const words = normalized
+		.split(/\s+/)
+		.filter(Boolean)
+		.flatMap((word) => {
+			if (word === 'jervis') {
+				return ['jarvis']
+			}
+			if (word === 'badtake' || /^batte(ik|ke)$/.test(word)) {
+				return ['bad', 'take']
+			}
+			return [word]
+		})
+	return words
+}
+
+export function findWordTimings(
+	segments: TranscriptSegment[],
+	word: string,
+): TimeRange[] {
+	const target = word.trim().toLowerCase()
+	if (!target) {
+		return []
+	}
+	const words = buildTranscriptWords(segments)
+	return words
+		.filter((entry) => entry.word === target)
+		.map((entry) => ({ start: entry.start, end: entry.end }))
+}

package/process-course/utils/video-editing.ts

@@ -0,0 +1,44 @@
+/**
+ * Allocate padding at join points between videos, intelligently distributing
+ * silence when one side lacks sufficient padding.
+ */
+export function allocateJoinPadding(options: {
+	paddingSeconds: number
+	previousAvailableSeconds: number
+	currentAvailableSeconds: number
+}): { previousPaddingSeconds: number; currentPaddingSeconds: number } {
+	const desiredTotal = options.paddingSeconds * 2
+	const totalAvailable =
+		options.previousAvailableSeconds + options.currentAvailableSeconds
+	const targetTotal = Math.min(desiredTotal, totalAvailable)
+	let previousPadding = Math.min(
+		options.paddingSeconds,
+		options.previousAvailableSeconds,
+	)
+	let currentPadding = Math.min(
+		options.paddingSeconds,
+		options.currentAvailableSeconds,
+	)
+	let remaining = targetTotal - (previousPadding + currentPadding)
+
+	if (remaining > 0) {
+		const extra = Math.min(
+			options.previousAvailableSeconds - previousPadding,
+			remaining,
+		)
+		previousPadding += extra
+		remaining -= extra
+	}
+	if (remaining > 0) {
+		const extra = Math.min(
+			options.currentAvailableSeconds - currentPadding,
+			remaining,
+		)
+		currentPadding += extra
+	}
+
+	return {
+		previousPaddingSeconds: previousPadding,
+		currentPaddingSeconds: currentPadding,
+	}
+}