@@ -291,6 +291,49 @@ describe("ArtifactTransaction", () => {
     transaction.rollback();
   });
 
+  it("rejects a video encoded at a different size than the render asked for", async () => {
+    // A 4K export of a 1080x1920 HDR project once published a 1080x1920 file as done.
+    const dir = tempDir();
+    const probe: ArtifactDurationProbe = async () => ({
+      durationSeconds: 2,
+      width: 1080,
+      height: 1920,
+    });
+    const transaction = new ArtifactTransaction(join(dir, "render.mp4"), "file", undefined, probe);
+    writeFileSync(transaction.stagingPath, "fake-mp4-bytes-that-are-non-empty");
+
+    await expect(
+      transaction.validate({
+        expectedDurationSeconds: 2,
+        expectedWidth: 2160,
+        expectedHeight: 3840,
+      }),
+    ).rejects.toThrow("expected 2160x3840, probed 1080x1920");
+
+    transaction.rollback();
+  });
+
+  it("accepts the one-pixel pad a 4:2:0 encode gives an odd side", async () => {
+    const dir = tempDir();
+    const probe: ArtifactDurationProbe = async () => ({
+      durationSeconds: 2,
+      width: 1082,
+      height: 724,
+    });
+    const transaction = new ArtifactTransaction(join(dir, "render.mp4"), "file", undefined, probe);
+    writeFileSync(transaction.stagingPath, "fake-mp4-bytes-that-are-non-empty");
+
+    await expect(
+      transaction.validate({
+        expectedDurationSeconds: 2,
+        expectedWidth: 1081,
+        expectedHeight: 724,
+      }),
+    ).resolves.toBeUndefined();
+
+    transaction.rollback();
+  });
+
   it("rejects a video whose probed frame count is far short of the captured frame count", async () => {
     // #3395 field packet frame shortfalls (148 of 300, 1240 of 1566) are
     // both well beyond the single-frame tolerance, so the frame-count check
@@ -502,6 +545,12 @@ describe("buildArtifactExpectation", () => {
     }
   });
 
+  it("carries the requested output size", () => {
+    expect(
+      buildArtifactExpectation({ ...base, outputFormat: "mp4", width: 2160, height: 3840 }),
+    ).toMatchObject({ expectedWidth: 2160, expectedHeight: 3840 });
+  });
+
   it("names the video playlist and requires the master for hls", () => {
     expect(buildArtifactExpectation({ ...base, outputFormat: "hls" })).toEqual({
       expectedDurationSeconds: 4,
 
@@ -42,6 +42,8 @@ const defaultFileSystem: ArtifactTransactionFileSystem = {
 export interface ArtifactDurationProbeResult {
   durationSeconds: number;
   frames?: number;
+  width?: number;
+  height?: number;
 }
 
 /**
@@ -68,6 +70,8 @@ async function defaultArtifactDurationProbe(path: string): Promise<ArtifactDurat
   return {
     durationSeconds: meta.durationSeconds,
     frames: meta.frames,
+    width: meta.width,
+    height: meta.height,
   };
 }
 
@@ -97,6 +101,9 @@ export interface ArtifactValidationExpectation {
   expectedDurationSeconds: number;
   fps?: number;
   expectedFrames?: number;
+  /** The output size the render was asked for; a route that ignores it must not publish. */
+  expectedWidth?: number;
+  expectedHeight?: number;
   toleranceSeconds?: number;
   /** Path relative to the staging directory to run the duration probe against. */
   probeTarget?: string;
@@ -122,13 +129,17 @@ export function buildArtifactExpectation(input: {
   durationSeconds: number;
   fps: number;
   expectedFrames: number | undefined;
+  width?: number;
+  height?: number;
 }): ArtifactValidationExpectation | undefined {
   if (input.outputFormat === "png-sequence" || input.outputFormat === "gif") return undefined;
   if (!Number.isFinite(input.durationSeconds) || input.durationSeconds <= 0) return undefined;
   const expectation: ArtifactValidationExpectation = {
     expectedDurationSeconds: input.durationSeconds,
     fps: input.fps,
     expectedFrames: input.expectedFrames,
+    expectedWidth: input.width,
+    expectedHeight: input.height,
   };
   if (input.outputFormat !== "hls") return expectation;
   return {
@@ -239,6 +250,23 @@ function assertFrameCountWithinTolerance(
   );
 }
 
+function assertSizeMatches(
+  expected: ArtifactValidationExpectation,
+  probed: ArtifactDurationProbeResult,
+  stagingPath: string,
+): void {
+  const { expectedWidth: width, expectedHeight: height } = expected;
+  if (width === undefined || height === undefined) return;
+  if (probed.width === undefined || probed.height === undefined) return;
+  // A 4:2:0 encode pads an odd side up by one pixel.
+  const fits = (want: number, got: number): boolean => got === want || got === want + (want % 2);
+  if (fits(width, probed.width) && fits(height, probed.height)) return;
+  throw new Error(
+    `Render artifact has the wrong size: expected ${width}x${height}, ` +
+      `probed ${probed.width}x${probed.height}. Artifact: ${stagingPath}`,
+  );
+}
+
 /**
  * Stages a render beside its final destination and promotes only a validated
  * artifact. File promotion uses one atomic replacement rename, so an existing
@@ -342,6 +370,7 @@ export class ArtifactTransaction {
       // above carries the gate on its own.
       assertFrameCountWithinTolerance(expected.expectedFrames, probed.frames, probePath);
     }
+    assertSizeMatches(expected, probed, probePath);
   }
 
   private async runDurationProbe(probePath: string): Promise<ArtifactDurationProbeResult> {
 
@@ -11,6 +11,12 @@ describe("assertOutputScaleSupported", () => {
       expect(() => assertOutputScaleSupported(scale, "hdr_layered")).toThrow(/hdr_layered/);
   });
 
+  it("names the ways out that apply: --sdr for HDR footage, mp4 for shader transitions", () => {
+    expect(() => assertOutputScaleSupported(2, "hdr_layered")).toThrow(/add --sdr/);
+    expect(() => assertOutputScaleSupported(2, "hdr_layered")).toThrow(/render as mp4/);
+    expect(() => assertOutputScaleSupported(2, "hdr_layered")).not.toThrow(/page-side compositing/);
+  });
+
   it("lets every route run at the composition's size, and the screenshot routes scale", () => {
     for (const route of ["sdr_streaming", "sdr_disk", "sdr_segmented", "hdr_layered"] as const)
       expect(() => assertOutputScaleSupported(1, route)).not.toThrow();
 
@@ -26,6 +26,7 @@ export function assertOutputScaleSupported(
   if (reason === null) return;
   throw new Error(
     `[Render] --resolution other than the composition's size is not supported on the "${route}" ` +
-      `capture route: ${reason}. Render at the composition's size, or as mp4 with page-side compositing.`,
+      `capture route: ${reason}. Render at the composition's size; or, for HDR footage, add --sdr to ` +
+      "render this size in standard colour; or, for shader transitions, render as mp4.",
   );
 }
@@ -3560,6 +3560,7 @@ async function executeRenderPipeline(input: {
     // comps that route to the layered/HDR paths.)
     const nativeHdrIds = new Set([...nativeHdrVideoIds, ...nativeHdrImageIds]);
     const hasHdrContent = Boolean(effectiveHdr && nativeHdrIds.size > 0);
+    if (hasHdrContent) assertOutputScaleSupported(deviceScaleFactor, "hdr_layered");
     // DE priority inversion eligibility — evaluated BEFORE capture calibration
     // because when every multi-worker resolution would be inverted to 1 anyway,
     // the calibration stage (a throwaway Chrome launch + timeline-spread sample
@@ -5084,6 +5085,8 @@ async function executeRenderPipeline(input: {
         durationSeconds: job.duration,
         fps: fpsToNumber(job.config.fps),
         expectedFrames: captureTotalFrames,
+        width: outputWidth,
+        height: outputHeight,
       }),
     );
Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ export function assertOutputScaleSupported(`
`26`	`26`	`if (reason === null) return;`
`27`	`27`	`throw new Error(`
`28`	`28`	`[Render] --resolution other than the composition's size is not supported on the "${route}" ` +
`29`		- `capture route: ${reason}. Render at the composition's size, or as mp4 with page-side compositing.`,
	`29`	+ `capture route: ${reason}. Render at the composition's size; or, for HDR footage, add --sdr to ` +
	`30`	`+ "render this size in standard colour; or, for shader transitions, render as mp4.",`
`30`	`31`	`);`
`31`	`32`	`}`