@vertesia/workflow 1.5.0-dev.20260714.072725Z → 1.5.0-dev.20260722.120446Z

package/src/activities/media/exec.ts

@@ -0,0 +1,265 @@
+import { type ExecFileOptions, execFile as execFileCallback, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { Context } from '@temporalio/activity';
+
+const execFileAsync = promisify(execFileCallback);
+
+/** 10MB buffer for ffmpeg output. */
+export const FFMPEG_MAX_BUFFER = 1024 * 1024 * 10;
+
+const MAX_COMMAND_TIMEOUT_MARGIN_MS = 60_000;
+
+/** Terminate an ffmpeg child that makes no encoding progress for this long, so Temporal can retry it promptly. */
+const FFMPEG_STALL_TIMEOUT_MS = 120_000;
+
+// ffmpeg streams encoding progress as `frame=`/`time=` stats. We track the *advance* of these monotonic fields (rather
+// than mere presence) so a wedged encoder that keeps re-emitting an identical status line is still detected as stalled.
+const FFMPEG_TIME_PATTERN = /time=\s*(\d+):([0-5]?\d):([0-5]?\d(?:\.\d+)?)/;
+const FFMPEG_FRAME_PATTERN = /frame=\s*(\d+)/;
+// ffmpeg delimits stats snapshots with a carriage return, so the carry buffer normally stays tiny. These bounds are a
+// defensive guard against an unterminated stream, retaining enough of a tail to reunite a marker split at the boundary.
+const PROGRESS_CARRY_LIMIT = 64 * 1024;
+const PROGRESS_CARRY_TAIL = 512;
+
+const activityCommandDeadlines = new WeakMap<Context, number>();
+
+/**
+ * Anchor the child-process deadline at the moment the Activity starts, so every later command derives its timeout from a
+ * stable point regardless of how long input download took.
+ */
+export function initializeActivityCommandDeadline(): number {
+    const context = Context.current();
+    const existingDeadlineMs = activityCommandDeadlines.get(context);
+    if (existingDeadlineMs) {
+        return existingDeadlineMs;
+    }
+    const deadlineMs = Date.now() + context.info.startToCloseTimeoutMs;
+    activityCommandDeadlines.set(context, deadlineMs);
+    return deadlineMs;
+}
+
+function getActivityCommandTimeoutMs(): number {
+    const context = Context.current();
+    const { startToCloseTimeoutMs } = context.info;
+    const timeoutMarginMs = Math.min(MAX_COMMAND_TIMEOUT_MARGIN_MS, startToCloseTimeoutMs / 10);
+    const activityDeadlineMs = initializeActivityCommandDeadline();
+    return Math.max(1, activityDeadlineMs - Date.now() - timeoutMarginMs);
+}
+
+/**
+ * Execute media tooling with Temporal cancellation propagated to the child process.
+ *
+ * Temporal can begin a retry after an attempt times out while the original worker process is still running. Passing the
+ * Activity cancellation signal prevents an orphaned ffmpeg process from competing with its retry for CPU.
+ */
+export async function execActivityFile(
+    command: string,
+    args: string[],
+    options: ExecFileOptions = {},
+): Promise<{ stdout: string; stderr: string }> {
+    const activityTimeoutMs = getActivityCommandTimeoutMs();
+    const configuredTimeoutMs = options.timeout && options.timeout > 0 ? options.timeout : activityTimeoutMs;
+
+    return (await execFileAsync(command, args, {
+        ...options,
+        encoding: 'utf8',
+        signal: Context.current().cancellationSignal,
+        timeout: Math.min(configuredTimeoutMs, activityTimeoutMs),
+    })) as { stdout: string; stderr: string };
+}
+
+export interface ProgressAwareOptions {
+    /**
+     * Coarse upper bound on retained stdout/stderr, counted in UTF-16 code units (not UTF-8 bytes). ffmpeg output is
+     * ASCII-dominant so this closely tracks bytes; it only exists to keep captured output from growing without bound
+     * (older output is dropped — tail retained — rather than failing the command). Not a strict byte cap.
+     */
+    maxBuffer?: number;
+    stallTimeoutMs?: number;
+}
+
+function parseFfmpegTimeCentis(text: string): number | undefined {
+    const match = FFMPEG_TIME_PATTERN.exec(text);
+    if (!match) {
+        return undefined;
+    }
+    const totalSeconds = Number(match[1]) * 3600 + Number(match[2]) * 60 + Number(match[3]);
+    return Number.isFinite(totalSeconds) ? Math.round(totalSeconds * 100) : undefined;
+}
+
+function parseFfmpegFrame(text: string): number | undefined {
+    const match = FFMPEG_FRAME_PATTERN.exec(text);
+    return match ? Number(match[1]) : undefined;
+}
+
+export interface ProgressTracker {
+    /** Feed a raw output chunk; returns true when a monotonic progress field advanced past its previous maximum. */
+    observe(chunk: string): boolean;
+}
+
+/**
+ * Track ffmpeg forward progress across arbitrarily-chunked output.
+ *
+ * Node delivers stream data in arbitrary slices, so a marker such as `frame=42` can arrive split across two chunks. The
+ * tracker buffers partial records until a `\r`/`\n` delimiter completes them, then reports advancement only when the
+ * parsed frame count or media timestamp exceeds the previous maximum — repeated identical stats from a wedged encoder do
+ * not count as progress.
+ */
+export function createFfmpegProgressTracker(): ProgressTracker {
+    let carry = '';
+    let maxTimeCentis = -1;
+    let maxFrame = -1;
+
+    const noteSegment = (segment: string): boolean => {
+        let advanced = false;
+        const timeCentis = parseFfmpegTimeCentis(segment);
+        if (timeCentis !== undefined && timeCentis > maxTimeCentis) {
+            maxTimeCentis = timeCentis;
+            advanced = true;
+        }
+        const frame = parseFfmpegFrame(segment);
+        if (frame !== undefined && frame > maxFrame) {
+            maxFrame = frame;
+            advanced = true;
+        }
+        return advanced;
+    };
+
+    return {
+        observe(chunk: string): boolean {
+            carry += chunk;
+            const segments = carry.split(/[\r\n]+/);
+            carry = segments.pop() ?? '';
+            let advanced = false;
+            for (const segment of segments) {
+                advanced = noteSegment(segment) || advanced;
+            }
+            if (carry.length > PROGRESS_CARRY_LIMIT) {
+                advanced = noteSegment(carry) || advanced;
+                carry = carry.slice(carry.length - PROGRESS_CARRY_TAIL);
+            }
+            return advanced;
+        },
+    };
+}
+
+/**
+ * Execute a long-running media command while enforcing a progress-stall watchdog on top of the Activity deadline and
+ * cancellation.
+ *
+ * The worker heartbeats every Activity on a fixed interval, so a wedged ffmpeg child that stops emitting progress would
+ * otherwise keep the Activity alive until its multi-hour Start-to-Close timeout. Watching ffmpeg's progress markers lets
+ * us terminate a stalled encode within `stallTimeoutMs` so Temporal retries it promptly (escalating to a faster preset
+ * on the next attempt). A stall is surfaced as a `killed` error so it propagates as an Activity failure via
+ * {@link rethrowIfActivityStopped} instead of being swallowed into a missing rendition.
+ */
+export async function execActivityFileWithProgress(
+    command: string,
+    args: string[],
+    { maxBuffer = FFMPEG_MAX_BUFFER, stallTimeoutMs = FFMPEG_STALL_TIMEOUT_MS }: ProgressAwareOptions = {},
+): Promise<{ stdout: string; stderr: string }> {
+    const activityTimeoutMs = getActivityCommandTimeoutMs();
+    const stallWindowMs = Math.max(1, Math.min(stallTimeoutMs, activityTimeoutMs));
+
+    return await new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
+        const child = spawn(command, args, {
+            signal: Context.current().cancellationSignal,
+            timeout: activityTimeoutMs,
+            killSignal: 'SIGKILL',
+        });
+
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let stalled = false;
+        let stallTimer: NodeJS.Timeout | undefined;
+
+        const armStallTimer = () => {
+            if (stallTimer) {
+                clearTimeout(stallTimer);
+            }
+            stallTimer = setTimeout(() => {
+                stalled = true;
+                child.kill('SIGKILL');
+            }, stallWindowMs);
+            // Never keep the event loop alive solely for the watchdog timer.
+            stallTimer.unref?.();
+        };
+
+        const append = (current: string, chunk: string): string => {
+            const combined = current + chunk;
+            return combined.length > maxBuffer ? combined.slice(combined.length - maxBuffer) : combined;
+        };
+
+        // ffmpeg writes progress to stderr by default, but track both streams so the watchdog works regardless of where
+        // a given command reports it. Each stream keeps its own line buffer.
+        const stdoutProgress = createFfmpegProgressTracker();
+        const stderrProgress = createFfmpegProgressTracker();
+
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk: string) => {
+            stdout = append(stdout, chunk);
+            if (stdoutProgress.observe(chunk)) {
+                armStallTimer();
+            }
+        });
+        child.stderr?.on('data', (chunk: string) => {
+            stderr = append(stderr, chunk);
+            if (stderrProgress.observe(chunk)) {
+                armStallTimer();
+            }
+        });
+
+        armStallTimer();
+
+        const settle = (finish: () => void) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (stallTimer) {
+                clearTimeout(stallTimer);
+            }
+            finish();
+        };
+
+        child.on('error', (error) => settle(() => reject(error)));
+
+        child.on('close', (code, signal) =>
+            settle(() => {
+                if (stalled) {
+                    const seconds = Math.round(stallWindowMs / 1000);
+                    reject(
+                        Object.assign(new Error(`${command} made no progress for ${seconds}s and was terminated`), {
+                            killed: true,
+                            stalled: true,
+                        }),
+                    );
+                } else if (code === 0) {
+                    resolve({ stdout, stderr });
+                } else {
+                    const detail = signal ? `signal ${signal}` : `code ${code}`;
+                    reject(
+                        Object.assign(new Error(`${command} exited with ${detail}: ${stderr.slice(-2000)}`), {
+                            killed: child.killed || signal != null,
+                            code,
+                            signal,
+                        }),
+                    );
+                }
+            }),
+        );
+    });
+}
+
+/**
+ * Re-throw errors that represent the Activity being stopped (cancellation, Start-to-Close timeout, or a progress-stall
+ * kill) so they are not swallowed by rendition fallback handling. Genuine tool failures still return `null` upstream.
+ */
+export function rethrowIfActivityStopped(error: unknown): void {
+    const commandTimedOut = typeof error === 'object' && error !== null && 'killed' in error && error.killed === true;
+    if (Context.current().cancellationSignal.aborted || commandTimedOut) {
+        throw error;
+    }
+}

package/src/activities/media/prepareAudio.ts

@@ -1,8 +1,6 @@
-import { execFile as execFileCallback } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { promisify } from 'node:util';
 import { log } from '@temporalio/activity';
 import { RequestError } from '@vertesia/api-fetch-client';
 import type { VertesiaClient } from '@vertesia/client';
@@ -17,12 +15,15 @@ import {
 import { setupActivity } from '../../dsl/setup/ActivityContext.js';
 import { DocumentNotFoundError, InvalidContentTypeError } from '../../errors.js';
 import { saveBlobToTempFile } from '../../utils/blobs.js';
-
-const execFileAsync = promisify(execFileCallback);
+import {
+    execActivityFile,
+    execActivityFileWithProgress,
+    initializeActivityCommandDeadline,
+    rethrowIfActivityStopped,
+} from './exec.js';
 
 // Default configuration constants
 const DEFAULT_AUDIO_BITRATE = '128k'; // Default audio bitrate for AAC encoding
-const FFMPEG_MAX_BUFFER = 1024 * 1024 * 10; // 10MB buffer for ffmpeg output
 
 export interface PrepareAudioParams {
     audioBitrate?: string; // Audio bitrate for AAC encoding, default '128k'
@@ -79,7 +80,7 @@ export interface PrepareAudioResult {
 async function getAudioMetadata(audioPath: string): Promise<AudioMetadataExtended> {
     try {
         const args = ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', audioPath];
-        const { stdout } = await execFileAsync('ffprobe', args);
+        const { stdout } = await execActivityFile('ffprobe', args);
         const metadata = JSON.parse(stdout.toString()) as FFProbeOutput;
 
         const audioStream = metadata.streams.find((stream) => stream.codec_type === 'audio');
@@ -96,6 +97,7 @@ async function getAudioMetadata(audioPath: string): Promise<AudioMetadataExtende
 
         return { duration, codec, bitrate, sampleRate, channels };
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Failed to get audio metadata: ${error instanceof Error ? error.message : 'Unknown error'}`);
         throw new Error(`Failed to probe audio metadata: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
@@ -128,7 +130,7 @@ async function generateAudioRendition(
     log.info('Generating web audio rendition (AAC M4A)', { command: 'ffmpeg', args: command, audioBitrate });
 
     try {
-        const { stderr } = await execFileAsync('ffmpeg', command, { maxBuffer: FFMPEG_MAX_BUFFER });
+        const { stderr } = await execActivityFileWithProgress('ffmpeg', command);
         const stderrText = stderr.toString();
 
         if (stderrText && !stderrText.includes('frame=')) {
@@ -145,6 +147,7 @@ async function generateAudioRendition(
             return null;
         }
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Failed to generate audio rendition: ${error instanceof Error ? error.message : 'Unknown error'}`);
         return null;
     }
@@ -200,6 +203,7 @@ async function uploadAudioAsRendition(
 export async function prepareAudio(
     payload: DSLActivityExecutionPayload<PrepareAudioParams>,
 ): Promise<PrepareAudioResult> {
+    initializeActivityCommandDeadline();
     const { client, objectId, params } = await setupActivity<PrepareAudioParams>(payload);
 
     const audioBitrate = params.audioBitrate ?? DEFAULT_AUDIO_BITRATE;
@@ -294,6 +298,7 @@ export async function prepareAudio(
             status: 'success',
         };
     } catch (error) {
+        rethrowIfActivityStopped(error);
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
         log.error(`Error preparing audio: ${errorMessage}`, { error });
 

package/src/activities/media/prepareVideo.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { resolveVideoPreset, shouldTranscodeVideo } from './prepareVideo.js';
+
+describe('shouldTranscodeVideo', () => {
+    it('transcodes by default', () => {
+        expect(shouldTranscodeVideo()).toBe(true);
+        expect(shouldTranscodeVideo(false)).toBe(true);
+    });
+
+    it('skips transcoding when explicitly requested', () => {
+        expect(shouldTranscodeVideo(true)).toBe(false);
+    });
+});
+
+describe('resolveVideoPreset', () => {
+    it.each([
+        { preset: 'medium', attempt: 1, expected: 'medium' },
+        { preset: 'medium', attempt: 2, expected: 'fast' },
+        { preset: 'medium', attempt: 3, expected: 'veryfast' },
+        { preset: 'medium', attempt: 5, expected: 'veryfast' },
+        { preset: 'fast', attempt: 1, expected: 'fast' },
+        { preset: 'fast', attempt: 2, expected: 'veryfast' },
+        { preset: 'ultrafast', attempt: 2, expected: 'ultrafast' },
+    ] as const)('uses $expected for $preset on attempt $attempt', ({ preset, attempt, expected }) => {
+        expect(resolveVideoPreset(preset, attempt)).toBe(expected);
+    });
+});

package/src/activities/media/prepareVideo.ts

@@ -1,9 +1,7 @@
-import { execFile as execFileCallback } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { promisify } from 'node:util';
-import { ApplicationFailure, log } from '@temporalio/activity';
+import { ApplicationFailure, Context, log } from '@temporalio/activity';
 import { RequestError } from '@vertesia/api-fetch-client';
 import type { VertesiaClient } from '@vertesia/client';
 import {
@@ -19,8 +17,12 @@ import {
 import { setupActivity } from '../../dsl/setup/ActivityContext.js';
 import { DocumentNotFoundError, InvalidContentTypeError } from '../../errors.js';
 import { saveBlobToTempFile } from '../../utils/blobs.js';
-
-const execFileAsync = promisify(execFileCallback);
+import {
+    execActivityFile,
+    execActivityFileWithProgress,
+    initializeActivityCommandDeadline,
+    rethrowIfActivityStopped,
+} from './exec.js';
 
 // Default configuration constants
 const DEFAULT_MAX_RESOLUTION = 1920; // Max resolution for video rendition (produces 1080p)
@@ -35,7 +37,6 @@ const POSTER_TIMESTAMP_MAX = 2; // Maximum poster timestamp in seconds
 const MIN_SCREENSHOT_TIMESTAMP = 1; // Minimum timestamp for screenshots in seconds
 
 // FFmpeg configuration constants
-const FFMPEG_MAX_BUFFER = 1024 * 1024 * 10; // 10MB buffer for ffmpeg output
 const VIDEO_CRF = '23'; // Constant Rate Factor for video quality (18-28, lower = better)
 const AUDIO_BITRATE = '128k'; // Audio bitrate for AAC encoding
 const JPEG_QUALITY = '2'; // JPEG quality for screenshots (1-31, lower = better)
@@ -45,6 +46,24 @@ export interface PrepareVideoParams {
     thumbnailSize?: number; // Max size (longest side) for thumbnail image, default 256
     posterSize?: number; // Max size (longest side) for poster image, default 1920
     generateAudio?: boolean; // Generate audio-only rendition (AAC), default true
+    videoPreset?: VideoPreset; // FFmpeg encoding preset, default medium
+    skipTranscode?: boolean; // Skip the main video re-encode, default false
+}
+
+export type VideoPreset = 'medium' | 'fast' | 'veryfast' | 'ultrafast';
+
+export function shouldTranscodeVideo(skipTranscode?: boolean): boolean {
+    return skipTranscode !== true;
+}
+
+export function resolveVideoPreset(preset: VideoPreset, attempt: number): VideoPreset {
+    if (preset === 'ultrafast') {
+        return preset;
+    }
+
+    const retryPresets: VideoPreset[] = ['medium', 'fast', 'veryfast'];
+    const initialPresetIndex = retryPresets.indexOf(preset);
+    return retryPresets[Math.min(initialPresetIndex + attempt - 1, retryPresets.length - 1)];
 }
 
 export interface PrepareVideo extends DSLActivitySpec<PrepareVideoParams> {
@@ -85,7 +104,7 @@ interface FFProbeOutput {
 async function getVideoMetadata(videoPath: string): Promise<VideoMetadataExtended> {
     try {
         const args = ['-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', videoPath];
-        const { stdout } = await execFileAsync('ffprobe', args);
+        const { stdout } = await execActivityFile('ffprobe', args);
         const metadata = JSON.parse(stdout.toString()) as FFProbeOutput;
 
         const videoStream = metadata.streams.find((stream) => stream.codec_type === 'video');
@@ -113,6 +132,7 @@ async function getVideoMetadata(videoPath: string): Promise<VideoMetadataExtende
 
         return { duration, width, height, codec, bitrate, fps, hasAudio };
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Failed to get video metadata: ${error instanceof Error ? error.message : 'Unknown error'}`);
         if (error instanceof ApplicationFailure) {
             throw error;
@@ -184,6 +204,7 @@ async function generateRenditionWithDimensions(
     outputDir: string,
     metadata: VideoMetadataExtended,
     maxResolution: number,
+    videoPreset: VideoPreset,
 ): Promise<MediaResult | null> {
     const outputFile = path.join(outputDir, `rendition_${maxResolution}p.mp4`);
 
@@ -207,7 +228,7 @@ async function generateRenditionWithDimensions(
         '-c:v',
         'libx264', // H.264 codec
         '-preset',
-        'medium', // Balance between speed and compression
+        videoPreset,
         '-crf',
         VIDEO_CRF, // Constant Rate Factor (18-28, lower = better quality)
         '-pix_fmt',
@@ -226,7 +247,7 @@ async function generateRenditionWithDimensions(
     log.info(`Generating ${maxResolution}p video rendition`, { command: 'ffmpeg', args: command });
 
     try {
-        const { stderr } = await execFileAsync('ffmpeg', command, { maxBuffer: FFMPEG_MAX_BUFFER });
+        const { stderr } = await execActivityFileWithProgress('ffmpeg', command);
         const stderrText = stderr.toString();
 
         if (stderrText && !stderrText.includes('frame=')) {
@@ -247,6 +268,7 @@ async function generateRenditionWithDimensions(
             return null;
         }
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Failed to generate video rendition: ${error instanceof Error ? error.message : 'Unknown error'}`);
         return null;
     }
@@ -273,7 +295,7 @@ async function generateAudioRendition(videoPath: string, outputDir: string): Pro
     log.info('Generating audio-only rendition', { command: 'ffmpeg', args: command });
 
     try {
-        const { stderr } = await execFileAsync('ffmpeg', command, { maxBuffer: FFMPEG_MAX_BUFFER });
+        const { stderr } = await execActivityFileWithProgress('ffmpeg', command);
         const stderrText = stderr.toString();
 
         if (stderrText && !stderrText.includes('frame=')) {
@@ -290,6 +312,7 @@ async function generateAudioRendition(videoPath: string, outputDir: string): Pro
             return null;
         }
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Failed to generate audio rendition: ${error instanceof Error ? error.message : 'Unknown error'}`);
         return null;
     }
@@ -331,7 +354,7 @@ async function generateScreenshot(
     log.info(`Generating ${name} at ${timestamp}s`, { command: 'ffmpeg', args: command });
 
     try {
-        const { stderr } = await execFileAsync('ffmpeg', command);
+        const { stderr } = await execActivityFile('ffmpeg', command);
         const stderrText = stderr.toString();
 
         if (stderrText && !stderrText.includes('frame=')) {
@@ -352,6 +375,7 @@ async function generateScreenshot(
             return null;
         }
     } catch (error) {
+        rethrowIfActivityStopped(error);
         log.error(`Failed to generate ${name}: ${error instanceof Error ? error.message : 'Unknown error'}`);
         return null;
     }
@@ -412,17 +436,22 @@ async function uploadMediaAsRendition(
 export async function prepareVideo(
     payload: DSLActivityExecutionPayload<PrepareVideoParams>,
 ): Promise<PrepareVideoResult> {
+    initializeActivityCommandDeadline();
     const { client, objectId, params } = await setupActivity<PrepareVideoParams>(payload);
 
     const maxResolution = params.maxResolution ?? DEFAULT_MAX_RESOLUTION;
     const thumbnailSize = params.thumbnailSize ?? DEFAULT_THUMBNAIL_SIZE;
     const posterSize = params.posterSize ?? DEFAULT_POSTER_SIZE;
     const generateAudio = params.generateAudio ?? DEFAULT_GENERATE_AUDIO;
+    const skipTranscode = params.skipTranscode ?? false;
+    const videoPreset = resolveVideoPreset(params.videoPreset ?? 'medium', Context.current().info.attempt);
 
     log.info(`Preparing video for ${objectId}`, {
         maxResolution,
         thumbnailSize,
         posterSize,
+        skipTranscode,
+        videoPreset,
     });
 
     // Retrieve the content object
@@ -454,13 +483,19 @@ export async function prepareVideo(
         const metadata = await getVideoMetadata(videoFile);
 
         // Step 2: Generate video rendition
-        log.info('Generating video rendition');
-        const renditionResult = await generateRenditionWithDimensions(
-            videoFile,
-            tempOutputDir,
-            metadata,
-            maxResolution,
-        );
+        let renditionResult: MediaResult | null = null;
+        if (!shouldTranscodeVideo(skipTranscode)) {
+            log.info('Skipping video rendition transcode by configuration');
+        } else {
+            log.info('Generating video rendition');
+            renditionResult = await generateRenditionWithDimensions(
+                videoFile,
+                tempOutputDir,
+                metadata,
+                maxResolution,
+                videoPreset,
+            );
+        }
 
         // Step 3 & 4: Generate thumbnail and poster in parallel
         log.info('Generating thumbnail and poster');
@@ -578,6 +613,7 @@ export async function prepareVideo(
             status: 'success',
         };
     } catch (error) {
+        rethrowIfActivityStopped(error);
         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
         log.error(`Error preparing video: ${errorMessage}`, { error });
 

package/src/activities/media/probeMediaStreams.test.ts

@@ -3,6 +3,7 @@ import type { VertesiaClient } from '@vertesia/client';
 import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { ActivityContext } from '../../dsl/setup/ActivityContext.js';
+import { execActivityFile } from './exec.js';
 import { type ProbeMediaStreamsParams, type ProbeMediaStreamsResult, probeMediaStreams } from './probeMediaStreams.js';
 
 vi.mock('../../dsl/setup/ActivityContext.js', async (importOriginal) => {
@@ -10,14 +11,12 @@ vi.mock('../../dsl/setup/ActivityContext.js', async (importOriginal) => {
     return { ...actual, setupActivity: vi.fn() };
 });
 
-// child_process.exec uses util.promisify.custom to return { stdout, stderr }.
-// vi.hoisted ensures these are defined before the vi.mock factory runs.
-const { execMock, execCustom } = vi.hoisted(() => {
-    const custom = vi.fn();
-    const mock = Object.assign(vi.fn(), { [Symbol.for('nodejs.util.promisify.custom')]: custom });
-    return { execMock: mock, execCustom: custom };
+// probeMediaStreams delegates ffprobe to the shared exec helper, so mock that seam and drive the parsed output
+// directly. The helper's cancellation/timeout wrapping is covered by exec.test.ts.
+vi.mock('./exec.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('./exec.js')>();
+    return { ...actual, execActivityFile: vi.fn() };
 });
-vi.mock('child_process', () => ({ exec: execMock }));
 
 let testEnv: MockActivityEnvironment;
 
@@ -44,7 +43,7 @@ const createPayload = (objectId = 'test-object-id'): DSLActivityExecutionPayload
 });
 
 function mockExec(stdout: string) {
-    execCustom.mockResolvedValue({ stdout, stderr: '' });
+    vi.mocked(execActivityFile).mockResolvedValue({ stdout, stderr: '' });
 }
 
 async function setupMockContext(objectId: string, signedUrl: string): Promise<void> {

package/src/activities/media/probeMediaStreams.ts

@@ -1,12 +1,9 @@
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
 import { ApplicationFailure, log } from '@temporalio/activity';
 import { RequestError } from '@vertesia/api-fetch-client';
 import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
 import { setupActivity } from '../../dsl/setup/ActivityContext.js';
 import { DocumentNotFoundError } from '../../errors.js';
-
-const execAsync = promisify(exec);
+import { execActivityFile, initializeActivityCommandDeadline, rethrowIfActivityStopped } from './exec.js';
 
 const FFPROBE_MAX_BUFFER = 1024 * 1024; // 1MB is more than enough for stream metadata JSON
 
@@ -32,6 +29,7 @@ interface FFProbeOutput {
 export async function probeMediaStreams(
     payload: DSLActivityExecutionPayload<ProbeMediaStreamsParams>,
 ): Promise<ProbeMediaStreamsResult> {
+    initializeActivityCommandDeadline();
     const { client, objectId } = await setupActivity<ProbeMediaStreamsParams>(payload);
 
     const inputObject = await client.objects.retrieve(objectId).catch((err: unknown) => {
@@ -54,12 +52,18 @@ export async function probeMediaStreams(
 
     // ffprobe reads only the container headers via HTTP range requests.
     // -probesize 32k caps the amount read from the network to ~32 KB.
+    // ffprobe emits no frame=/time= progress, so the stall watchdog does not apply here; the shared exec wrapper still
+    // propagates Activity cancellation and bounds the read by the Activity deadline, and passing the URL as an argv
+    // entry (not a shell string) removes the shell-interpolation surface.
     let stdout: string;
     try {
-        ({ stdout } = await execAsync(`ffprobe -v quiet -probesize 32k -print_format json -show_streams "${url}"`, {
-            maxBuffer: FFPROBE_MAX_BUFFER,
-        }));
+        ({ stdout } = await execActivityFile(
+            'ffprobe',
+            ['-v', 'quiet', '-probesize', '32k', '-print_format', 'json', '-show_streams', url],
+            { maxBuffer: FFPROBE_MAX_BUFFER },
+        ));
     } catch (err: unknown) {
+        rethrowIfActivityStopped(err);
         const message = err instanceof Error ? err.message : String(err);
         log.error(`ffprobe failed for object ${objectId}: ${message}`);
         throw new Error(`Failed to probe media streams for object ${objectId}: ${message}`);