larkup 0.4.12 → 0.4.14

package/.next/standalone/apps/web/lib/media/progress.ts

@@ -0,0 +1,209 @@
+export interface MediaProgressStep {
+  stage: string;
+  status: 'waiting' | 'running' | 'completed' | 'skipped' | 'failed';
+  percent?: number;
+  current?: number;
+  total?: number;
+  unit?: string;
+  estimatedRemainingSeconds?: number;
+  elapsedSeconds?: number;
+  sequence?: number;
+  message?: string;
+  startedAt?: string;
+  updatedAt?: string;
+  finishedAt?: string;
+}
+
+/** Use the current attempt rather than the original upload time after a retry. */
+export function mediaProcessingStartedAt(asset: {
+  createdAt: string;
+  processingStartedAt?: string;
+}): string {
+  return asset.processingStartedAt ?? asset.createdAt;
+}
+
+/** Returns the completed attempt duration when both persisted timestamps exist. */
+export function completedMediaProcessingSeconds(asset: {
+  processingStatus: string;
+  processingStartedAt?: string;
+  processingSteps?: MediaProgressStep[];
+}): number | null {
+  if (asset.processingStatus !== 'completed' || !asset.processingStartedAt) return null;
+
+  const startedAt = Date.parse(asset.processingStartedAt);
+  if (!Number.isFinite(startedAt)) return null;
+
+  const completedSteps =
+    asset.processingSteps
+      ?.map((step) => Date.parse(step.finishedAt ?? ''))
+      .filter(Number.isFinite) ?? [];
+  if (completedSteps.length === 0) return null;
+  const finishedAt = Math.max(...completedSteps);
+  if (!Number.isFinite(finishedAt) || finishedAt < startedAt) return null;
+  return Math.round((finishedAt - startedAt) / 1_000);
+}
+
+const STAGE_LABELS: Record<string, string> = {
+  download: 'Download',
+  prepare: 'Cloud video preparation',
+  extract: 'Media extraction',
+  transcribe: 'Speech timeline',
+  vision: 'Visual analysis',
+  synthesize: 'Knowledge notes',
+  index: 'Search indexing',
+};
+
+/** The most recently updated running stage is the primary visible work. */
+export function primaryRunningMediaStep<T extends MediaProgressStep>(
+  steps: T[] | undefined,
+): T | undefined {
+  return steps
+    ?.filter((step) => step.status === 'running')
+    .reduce<T | undefined>((latest, step) => {
+      if (!latest) return step;
+      const latestAt = Date.parse(latest.updatedAt ?? latest.startedAt ?? '');
+      const stepAt = Date.parse(step.updatedAt ?? step.startedAt ?? '');
+      if (!Number.isFinite(latestAt)) return step;
+      return Number.isFinite(stepAt) && stepAt >= latestAt ? step : latest;
+    }, undefined);
+}
+
+export function mediaStepProgress(step: MediaProgressStep | undefined): number | null {
+  if (!step) return null;
+  if (typeof step.percent === 'number' && Number.isFinite(step.percent)) {
+    return Math.max(0, Math.min(100, step.percent));
+  }
+  if (typeof step.current === 'number' && typeof step.total === 'number' && step.total > 0) {
+    return Math.max(0, Math.min(100, (step.current / step.total) * 100));
+  }
+  return null;
+}
+
+/** Keep sub-percent worker movement visible without noisy trailing zeroes. */
+export function formatMediaProgressPercent(value: number): string {
+  const bounded = Math.max(0, Math.min(100, Number.isFinite(value) ? value : 0));
+  const rounded = Math.round(bounded * 10) / 10;
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(1);
+}
+
+/** Return the latest bounded worker measurement for this indexing attempt. */
+export function smoothMediaProcessingProgress(
+  asset: {
+    processingProgress?: number;
+    processingStatus: string;
+    processingPaused?: boolean;
+    durationSecs?: number;
+    processingSteps?: MediaProgressStep[];
+  },
+  _now = Date.now(),
+): number {
+  const reported = Math.max(0, Math.min(100, asset.processingProgress ?? 0));
+  if (asset.processingStatus === 'completed') return 100;
+  return reported;
+}
+
+/**
+ * Ease confirmed jumps and keep a slow asymptotic trickle while fresh worker
+ * heartbeats prove the job is active. It can approach, but never claim, 99%.
+ */
+export function advanceMediaProcessingProgress(
+  displayed: number,
+  confirmed: number,
+  elapsedMs: number,
+  workerActive = false,
+): number {
+  const current = Math.max(0, Math.min(100, displayed));
+  const target = Math.max(0, Math.min(100, confirmed));
+  const boundedElapsed = Math.max(0, elapsedMs);
+  if (target > current) {
+    const maximumAdvance = boundedElapsed * 0.002;
+    return Math.round(Math.min(target, current + maximumAdvance) * 1_000) / 1_000;
+  }
+  if (!workerActive || current >= 99) return current;
+  const trickle = (99 - current) * (1 - Math.exp(-boundedElapsed / 1_000_000));
+  return Math.round(Math.min(99, current + trickle) * 1_000) / 1_000;
+}
+
+/** A running step without fresh worker telemetry is waiting, not progressing. */
+export function isMediaStepTelemetryStale(
+  step: MediaProgressStep | undefined,
+  now = Date.now(),
+  maxAgeMs = 20_000,
+): boolean {
+  if (!step || step.status !== 'running') return false;
+  const timestamp = Date.parse(step.updatedAt ?? step.startedAt ?? '');
+  return Number.isFinite(timestamp) && now - timestamp > maxAgeMs;
+}
+
+/**
+ * Reserve “Finalizing” for the last local publishing step. Visual analysis can
+ * legitimately spend time at 99% while building its search vectors, so calling
+ * that finalization would promise an imminent completion that is not true.
+ */
+export function isFinalizingMediaStep(step: MediaProgressStep | undefined): boolean {
+  const progress = mediaStepProgress(step);
+  return (
+    step?.status === 'running' && step.stage === 'index' && progress !== null && progress >= 98
+  );
+}
+
+/** A factual label for the active unit of work, separate from weighted overall progress. */
+export function describeActiveMediaStep(step: MediaProgressStep | undefined): string | null {
+  if (!step) return null;
+  const label = STAGE_LABELS[step.stage] ?? step.stage;
+  const progress = mediaStepProgress(step);
+  const count =
+    typeof step.current === 'number' && typeof step.total === 'number' && step.total > 0
+      ? `${step.current} / ${step.total}${step.unit ? ` ${step.unit}` : ''}`
+      : null;
+  if (progress === null) return `${label} · active request in progress`;
+  if (isFinalizingMediaStep(step)) {
+    return `${label} · finalizing verified results`;
+  }
+  return [label, count, `${Math.round(progress)}% this step`].filter(Boolean).join(' · ');
+}
+
+/**
+ * Estimate only countable work. A percentage-only ETA becomes misleading when
+ * a remote worker has reported an optimistic progress band but is still
+ * waiting on a model request.
+ */
+export function estimateMediaStepRemainingSeconds(
+  step: MediaProgressStep | undefined,
+  now = Date.now(),
+): number | null {
+  if (
+    Number.isFinite(step?.estimatedRemainingSeconds) &&
+    (step?.estimatedRemainingSeconds ?? 0) > 5
+  ) {
+    const updatedAt = Date.parse(step?.updatedAt ?? '');
+    if (!Number.isFinite(updatedAt) || isMediaStepTelemetryStale(step, now)) return null;
+    const sinceUpdate = Math.max(0, (now - updatedAt) / 1_000);
+    const remaining = Math.round((step?.estimatedRemainingSeconds ?? 0) - sinceUpdate);
+    // Never park at one second after a forecast has expired. Wait for the next
+    // measured worker update and display no ETA in the meantime.
+    return remaining > 0 ? remaining : null;
+  }
+  if (
+    !step?.startedAt ||
+    !Number.isFinite(step.current) ||
+    !Number.isFinite(step.total) ||
+    step.current === undefined ||
+    step.total === undefined ||
+    step.current < 2 ||
+    step.total <= step.current
+  ) {
+    return null;
+  }
+
+  const startedAt = new Date(step.startedAt).getTime();
+  if (!Number.isFinite(startedAt)) return null;
+  const elapsedSeconds = Math.max(0, (now - startedAt) / 1_000);
+  if (elapsedSeconds < 5) return null;
+
+  const remainingSeconds = Math.round(
+    (elapsedSeconds / step.current) * (step.total - step.current),
+  );
+  // A clearly unreasonable estimate is less useful than no estimate.
+  return remainingSeconds > 0 && remainingSeconds <= 12 * 60 * 60 ? remainingSeconds : null;
+}

package/.next/standalone/apps/web/lib/media/source-identity.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { canonicalMediaSourceUrl, newestEquivalentMediaAsset } from './source-identity';
+
+describe('canonicalMediaSourceUrl', () => {
+  it('treats seek and tracking variants as the same media source', () => {
+    expect(canonicalMediaSourceUrl('https://media.example/watch?v=abc&t=6s&utm_source=chat')).toBe(
+      canonicalMediaSourceUrl('https://media.example/watch?v=abc'),
+    );
+  });
+
+  it('keeps parameters that identify different source media', () => {
+    expect(canonicalMediaSourceUrl('https://media.example/watch?v=abc')).not.toBe(
+      canonicalMediaSourceUrl('https://media.example/watch?v=def'),
+    );
+  });
+});
+
+describe('newestEquivalentMediaAsset', () => {
+  it('prefers the newest completed import across seek URL variants', () => {
+    const old = {
+      id: 'old',
+      originalUrl: 'https://www.youtube.com/watch?v=abc',
+      updatedAt: '2026-09-02T00:00:00Z',
+    };
+    const current = {
+      id: 'current',
+      originalUrl: 'https://www.youtube.com/watch?v=abc&t=6s',
+      updatedAt: '2026-09-03T00:00:00Z',
+    };
+
+    expect(newestEquivalentMediaAsset(old, [old, current])).toBe(current);
+  });
+});

package/.next/standalone/apps/web/lib/media/source-selection.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { selectedRemoteDuration, selectedRemoteUrls } from './source-selection';
+
+describe('remote media source selection', () => {
+  const playlistUrl = 'https://www.youtube.com/watch?v=chosen-video&list=long-playlist&index=16';
+  const estimates = [
+    {
+      originalUrl: playlistUrl,
+      durationSecs: 87_540,
+      singleItemDurationSecs: 3_600,
+      singleItemUrl: 'https://www.youtube.com/watch?v=chosen-video',
+      entryCount: 24,
+    },
+  ];
+
+  it('uses only the chosen video duration for a single-video import', () => {
+    expect(selectedRemoteDuration(estimates, true)).toBe(3_600);
+    expect(selectedRemoteDuration(estimates, false)).toBe(87_540);
+  });
+
+  it('never substitutes a playlist total when one item has no duration yet', () => {
+    expect(
+      selectedRemoteDuration(
+        [{ originalUrl: playlistUrl, durationSecs: 87_540, entryCount: 24 }],
+        true,
+      ),
+    ).toBe(0);
+  });
+
+  it('imports the inspected video rather than its playlist', () => {
+    expect(selectedRemoteUrls([playlistUrl], estimates, true)).toEqual([
+      'https://www.youtube.com/watch?v=chosen-video',
+    ]);
+    expect(selectedRemoteUrls([playlistUrl], estimates, false)).toEqual([playlistUrl]);
+  });
+});

package/.next/standalone/apps/web/lib/media/source-selection.ts

@@ -0,0 +1,47 @@
+export interface RemoteMediaEstimate {
+  originalUrl: string;
+  durationSecs?: number;
+  singleItemDurationSecs?: number;
+  singleItemUrl?: string;
+  entryCount?: number;
+}
+
+export function selectedRemoteDuration(
+  estimates: RemoteMediaEstimate[] | null,
+  singleItem: boolean,
+): number {
+  return (
+    estimates?.reduce(
+      (total, estimate) =>
+        total +
+        (singleItem
+          ? (estimate.singleItemDurationSecs ??
+            ((estimate.entryCount ?? 1) <= 1 ? estimate.durationSecs : 0) ??
+            0)
+          : (estimate.durationSecs ?? 0)),
+      0,
+    ) ?? 0
+  );
+}
+
+export function selectedRemoteUrls(
+  urls: string[],
+  estimates: RemoteMediaEstimate[] | null,
+  singleItem: boolean,
+): string[] {
+  if (!singleItem) return urls;
+  const estimateByUrl = new Map(estimates?.map((estimate) => [estimate.originalUrl, estimate]));
+  return urls.map((url) => {
+    const inspectedUrl = estimateByUrl.get(url)?.singleItemUrl;
+    if (inspectedUrl) return inspectedUrl;
+    try {
+      const parsed = new URL(url);
+      if (parsed.hostname.includes('youtube.com')) {
+        parsed.searchParams.delete('list');
+        parsed.searchParams.delete('index');
+        return parsed.toString();
+      }
+    } catch {}
+    return url;
+  });
+}

package/.next/standalone/apps/web/lib/media/source-utils.test.ts

@@ -0,0 +1,231 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  ffprobeExecutable,
+  hasInflatedPlaybackTimeline,
+  inspectYouTubeMetadata,
+  parseYoutubeJson3Transcript,
+  parseYtDlpProgress,
+  resolveYtDlpMediaPath,
+  selectYoutubeCaptionLanguage,
+  ytDlpImportPrintTemplate,
+  youtubeDownloadFormat,
+} from './source-utils';
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryDirectories
+      .splice(0)
+      .map((directory) => fs.rm(directory, { recursive: true, force: true })),
+  );
+});
+
+describe('inspectYouTubeMetadata', () => {
+  it('keeps the playlist total separate from the video selected by the watch URL', () => {
+    const inspection = inspectYouTubeMetadata(
+      'https://www.youtube.com/watch?v=selected-id&list=playlist-id&index=2',
+      {
+        title: 'A long playlist',
+        entries: [
+          { id: 'first-id', duration: 1_800 },
+          { id: 'selected-id', duration: 3_600 },
+          { id: 'third-id', duration: 2_400 },
+        ],
+      },
+    );
+
+    expect(inspection).toMatchObject({
+      durationSecs: 7_800,
+      singleItemDurationSecs: 3_600,
+      singleItemUrl: 'https://www.youtube.com/watch?v=selected-id',
+      entryCount: 3,
+    });
+  });
+
+  it('selects the first entry when a playlist URL has no video id', () => {
+    const inspection = inspectYouTubeMetadata('https://www.youtube.com/playlist?list=playlist-id', {
+      entries: [
+        { id: 'first-id', duration: 1_800 },
+        { id: 'second-id', duration: 3_600 },
+      ],
+    });
+
+    expect(inspection.singleItemDurationSecs).toBe(1_800);
+    expect(inspection.singleItemUrl).toBe('https://www.youtube.com/watch?v=first-id');
+  });
+});
+
+describe('parseYtDlpProgress', () => {
+  it('keeps the downloader byte count, speed, ETA, and decimal percent', () => {
+    const progress = parseYtDlpProgress(
+      '[download]  12.5% of ~ 80.00MiB at 4.00MiB/s ETA 00:18',
+      3,
+    );
+
+    expect(progress).toMatchObject({
+      percent: 12.5,
+      current: 10 * 1_024 ** 2,
+      total: 80 * 1_024 ** 2,
+      unit: 'bytes',
+      elapsedSeconds: 3,
+      estimatedRemainingSeconds: 18,
+      message: 'Downloading video · 12.5% · 4.00MiB/s · 00:18 left',
+    });
+  });
+
+  it('ignores downloader log lines that contain no measured progress', () => {
+    expect(parseYtDlpProgress('[youtube] Extracting URL')).toBeNull();
+  });
+});
+
+describe('youtubeDownloadFormat', () => {
+  it('prefers a muxable MP4 video and M4A audio pair before combined fallbacks', () => {
+    const [preferred, combinedFallback] = youtubeDownloadFormat().split('/');
+    expect(preferred).toContain('bestvideo*');
+    expect(preferred).toContain('[vcodec^=avc]');
+    expect(preferred).toContain('+bestaudio[ext=m4a]');
+    expect(combinedFallback).toContain('acodec!=none');
+    expect(youtubeDownloadFormat().split('/').at(-1)).toContain('acodec!=none');
+  });
+});
+
+describe('ytDlpImportPrintTemplate', () => {
+  it('serializes one object so missing metadata never becomes a bare NA token', () => {
+    const template = ytDlpImportPrintTemplate();
+
+    expect(template).toBe('%(.{filepath,title,webpage_url,ext,language,requested_subtitles})j');
+    expect(template).not.toContain('"language":%(language)j');
+  });
+});
+
+describe('hasInflatedPlaybackTimeline', () => {
+  it('detects a padded audio/container clock without flagging normal stream drift', () => {
+    expect(
+      hasInflatedPlaybackTimeline({
+        durationSecs: 3_600,
+        videoDurationSecs: 3_600,
+        audioDurationSecs: 7_200,
+        containerDurationSecs: 7_200,
+        hasVideo: true,
+        hasAudio: true,
+        hasCorruptionSignals: false,
+      }),
+    ).toBe(true);
+    expect(
+      hasInflatedPlaybackTimeline({
+        durationSecs: 3_600,
+        videoDurationSecs: 3_600,
+        audioDurationSecs: 3_602,
+        containerDurationSecs: 3_602,
+        hasVideo: true,
+        hasAudio: true,
+        hasCorruptionSignals: false,
+      }),
+    ).toBe(false);
+  });
+});
+
+describe('parseYoutubeJson3Transcript', () => {
+  it('turns native YouTube captions into timestamped evidence and ignores formatting events', () => {
+    expect(
+      parseYoutubeJson3Transcript({
+        events: [
+          { tStartMs: 14_000, dDurationMs: 2_500, segs: [{ utf8: 'The ' }, { utf8: 'answer' }] },
+          { tStartMs: 16_500, dDurationMs: 500 },
+        ],
+      }),
+    ).toEqual([{ text: 'The answer', startSecs: 14, endSecs: 16.5 }]);
+  });
+});
+
+describe('selectYoutubeCaptionLanguage', () => {
+  it('prefers a native manual caption over translated automatic tracks', () => {
+    expect(
+      selectYoutubeCaptionLanguage({
+        language: 'de',
+        subtitles: { de: [{}] },
+        automatic_captions: { en: [{}], 'de-orig': [{}] },
+      }),
+    ).toBe('de');
+  });
+
+  it('falls back to the original-language automatic caption', () => {
+    expect(
+      selectYoutubeCaptionLanguage({
+        language: 'ar',
+        automatic_captions: { en: [{}], 'ar-orig': [{}] },
+      }),
+    ).toBe('ar-orig');
+  });
+});
+
+describe('resolveYtDlpMediaPath', () => {
+  it('uses the actual media output when yt-dlp reports a stale after-move filename', async () => {
+    const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), 'larkup-source-utils-'));
+    temporaryDirectories.push(outputDir);
+    const reportedPath = path.join(outputDir, 'How Large Language Models Work [5sLYAQS9sWQ].mp4');
+    const actualPath = path.join(
+      outputDir,
+      'How Large Language Models Work [5sLYAQS9sWQ].f251.webm',
+    );
+    await fs.writeFile(actualPath, 'video bytes');
+
+    await expect(resolveYtDlpMediaPath(reportedPath, outputDir)).resolves.toBe(actualPath);
+  });
+
+  it('rejects a downloader path outside its isolated import directory', async () => {
+    const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), 'larkup-source-utils-'));
+    temporaryDirectories.push(outputDir);
+
+    await expect(
+      resolveYtDlpMediaPath(path.join(os.tmpdir(), 'unrelated.mp4'), outputDir),
+    ).rejects.toThrow('outside its import directory');
+  });
+
+  it('prefers the final mux over a silent adaptive video intermediate', async () => {
+    const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), 'larkup-source-utils-'));
+    temporaryDirectories.push(outputDir);
+    const reportedPath = path.join(outputDir, 'Interview [video123].missing.mp4');
+    const silentIntermediate = path.join(outputDir, 'Interview [video123].f137.mp4');
+    const finalMux = path.join(outputDir, 'Interview [video123].webm');
+    await fs.writeFile(silentIntermediate, 'video only');
+    await fs.writeFile(finalMux, 'video and audio');
+
+    await expect(resolveYtDlpMediaPath(reportedPath, outputDir)).resolves.toBe(finalMux);
+  });
+
+  it('never recovers a stale video path as an audio-only adaptive stream', async () => {
+    const outputDir = await fs.mkdtemp(path.join(os.tmpdir(), 'larkup-source-utils-'));
+    temporaryDirectories.push(outputDir);
+    const reportedPath = path.join(outputDir, 'Final [video123].missing.mp4');
+    const videoIntermediate = path.join(outputDir, 'Final [video123].f137.mp4');
+    const audioIntermediate = path.join(outputDir, 'Final [video123].f140.m4a');
+    await fs.writeFile(videoIntermediate, 'video bytes');
+    await fs.writeFile(audioIntermediate, 'audio bytes');
+
+    await expect(resolveYtDlpMediaPath(reportedPath, outputDir)).resolves.toBe(videoIntermediate);
+  });
+});
+
+describe('ffprobeExecutable', () => {
+  const originalPath = process.env.LARKUP_FFPROBE_PATH;
+
+  afterEach(() => {
+    if (originalPath === undefined) delete process.env.LARKUP_FFPROBE_PATH;
+    else process.env.LARKUP_FFPROBE_PATH = originalPath;
+  });
+
+  it('uses an explicit deployment override before the bundled binary', () => {
+    process.env.LARKUP_FFPROBE_PATH = '/custom/bin/ffprobe';
+    expect(ffprobeExecutable()).toBe('/custom/bin/ffprobe');
+  });
+
+  it('uses a packaged ffprobe binary when PATH is unavailable', () => {
+    delete process.env.LARKUP_FFPROBE_PATH;
+    expect(ffprobeExecutable()).toContain('ffprobe');
+  });
+});

package/.next/standalone/apps/web/lib/media/tool-indexing-estimate.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { calculateToolIndexingEstimate } from './tool-indexing-estimate';
+
+describe('calculateToolIndexingEstimate', () => {
+  const fast = {
+    processingSecondsPerSourceMinute: 4,
+    maxProcessingSecondsPerSourceMinute: 5,
+    fixedOverheadSeconds: 60,
+    maxFixedOverheadSeconds: 60,
+    creditsPerSourceMinute: 1,
+  };
+
+  it('estimates a one-hour Fast video at five to six minutes', () => {
+    expect(calculateToolIndexingEstimate(fast, 60 * 60)).toEqual({
+      minimumMinutes: 5,
+      maximumMinutes: 6,
+      credits: 60,
+    });
+  });
+
+  it('keeps time and credits proportional to the actual selected duration', () => {
+    expect(calculateToolIndexingEstimate(fast, 1_459 * 60)).toEqual({
+      minimumMinutes: 99,
+      maximumMinutes: 123,
+      credits: 1_459,
+    });
+  });
+});

package/.next/standalone/apps/web/lib/media/tool-indexing-estimate.ts

@@ -0,0 +1,39 @@
+export interface ToolIndexingEstimateVariant {
+  processingSecondsPerSourceMinute: number;
+  maxProcessingSecondsPerSourceMinute?: number;
+  fixedOverheadSeconds?: number;
+  maxFixedOverheadSeconds?: number;
+  creditsPerSourceMinute: number;
+}
+
+export function calculateToolIndexingEstimate(
+  estimate: ToolIndexingEstimateVariant | undefined,
+  sourceDurationSecs?: number,
+) {
+  if (!estimate) return null;
+  const sourceMinutes = Math.max(0, (sourceDurationSecs ?? 0) / 60);
+  const displayDuration = sourceMinutes > 0 ? Math.max(sourceMinutes, 0.1) : 1;
+  const minimumMinutes = Math.max(
+    1,
+    Math.ceil(
+      ((estimate.fixedOverheadSeconds ?? 0) +
+        estimate.processingSecondsPerSourceMinute * displayDuration) /
+        60,
+    ),
+  );
+  const maximumMinutes = Math.max(
+    minimumMinutes,
+    Math.ceil(
+      ((estimate.maxFixedOverheadSeconds ?? estimate.fixedOverheadSeconds ?? 0) +
+        (estimate.maxProcessingSecondsPerSourceMinute ??
+          estimate.processingSecondsPerSourceMinute) *
+          displayDuration) /
+        60,
+    ),
+  );
+  return {
+    minimumMinutes,
+    maximumMinutes,
+    credits: Math.max(1, Math.ceil(estimate.creditsPerSourceMinute * displayDuration)),
+  };
+}