fix(media): floor the scaled concat axes so the area bound actually holds

The scale factor lands both axes on a product of exactly the budget, so an axis
allowed to round up can put the pair back over it — and when both round up and
both land even, nothing pulls them back. A brute force over every dimension pair
in 16..4096 finds 219,280 that violate the bound under round-to-even, worst
2694x3520 -> 2688x3512, 3072 pixels over. Under floor-to-even: none.

Flooring keeps each axis at or below its exact target, so the product cannot
exceed the budget. Probed dimensions are already integers, so this changes only
the scaled path.

Author: icecrasher321

apps/sim/lib/media/ffmpeg.test.ts

@@ -204,6 +204,21 @@ describe('runFfmpegOperation concat normalization target', () => {
     expect(width).toBe(height)
   })
 
+  it('holds the area bound for dimensions that round up on both axes', async () => {
+    // 2694x3520 is the worst case in the whole dimension space: the scale factor
+    // lands both axes on .5, and rounding both up to an even number put the pair
+    // 3072 pixels back over the budget it had just been scaled into.
+    probeReport.json = JSON.stringify({
+      streams: [{ codec_type: 'video', codec_name: 'h264', width: 2694, height: 3520 }],
+      format: { duration: '2', format_name: 'mp4' },
+    })
+
+    await runFfmpegOperation('concat', [videoInput, videoInput])
+
+    const target = capturedVideoFilters[0].match(/scale=(\d+):(\d+):/)
+    expect(Number(target![1]) * Number(target![2])).toBeLessThanOrEqual(4096 * 2304)
+  })
+
   it('emits even dimensions, which yuv420p requires', async () => {
     probeReport.json = JSON.stringify({
       streams: [{ codec_type: 'video', codec_name: 'h264', width: 1919, height: 1081 }],

apps/sim/lib/media/ffmpeg.ts

@@ -645,8 +645,17 @@ function clampProbedFrame(width: number, height: number): { width: number; heigh
   return { width: w, height: h }
 }
 
+/**
+ * Floors rather than rounds, which is what makes the area bound hold.
+ *
+ * The scale factor lands both axes on a product of exactly the budget, so any
+ * axis allowed to round *up* can put the pair back over it — and when both round
+ * up and both land even, nothing pulls them back. Flooring keeps each axis at or
+ * below its exact target, so the product cannot exceed the budget. Probed
+ * dimensions are already integers, so this only ever bites on the scaled path.
+ */
 function clampProbedAxis(value: number): number {
-  const bounded = Math.min(Math.max(Math.round(value), MIN_SCALE_DIMENSION), MAX_SCALE_DIMENSION)
+  const bounded = Math.min(Math.max(Math.floor(value), MIN_SCALE_DIMENSION), MAX_SCALE_DIMENSION)
   return bounded - (bounded % 2)
 }