An export helper that multiplies the canvas by window.devicePixelRatio looks generous on a 3× laptop. A label laid out at 400×100 comes back as a 1200×300 PNG, and if the slot it goes into is 800×200, something downstream scales it down. It is tempting to call that free supersampling. In this run it was a trade. Measured against an 8× reference, the downscaled DPR 3 file had the smallest error of the nine exports, 1.46 on a 0–255 grey scale. Its outlines were also softer than a plain render at the target size: the grey ramp along each edge ran 2.517 px, where drawing straight at 800×200 gave 1.641 px. So the real question is which of those two numbers your export is judged by.

How each export was scored

Scope: one Apple-silicon Mac, desktop Chromium, each case run once. The text sample is self-made: one line mixing Chinese characters and Latin letters, bold 28px, dark on white, in a 400×100 logical box, with an 800×200 file as the target. Three export paths were compared at DPR 1, 2 and 3. Path A keeps the canvas at its CSS size and upscales the bitmap bilinearly, which is what reusing a 1× preview amounts to. Path B sizes the canvas by DPR and then brings the result to 800×200. Path C ignores the screen and renders at 800×200 directly. The reference was drawn at 3200×800 and area-averaged down to 800×200. Two scores came out of each file. Edge transition width is, row by row, the mean length of runs of pixels whose grey value sits between 32 and 223; both thresholds were picked for this run and are not a standard. Error subtracts each pixel's grey value from the reference's, takes the absolute value and averages over the frame, so it can run from 0 to 255; it is also a metric defined for this run. Edge width describes outlines; error covers the whole image.

At DPR 3 error went down and edges got wider

Export Pixels out Brought to 800×200 by Edge width (px) Error vs reference
B at DPR 3 1200×300 bilinear downscale 2.517 1.46
C at any DPR 800×200 nothing 1.641 1.603
A at any DPR 400×100 bilinear upscale 5.98 4.759
8× reference 800×200 area average 1.768 0

B at DPR 3 lowered the error by 0.143, roughly 8.9% under the direct render. Its edge width is about 1.53 times that of C. A narrower edge is not automatically better, since the reference itself has 1.768 px of ramp. C lands 0.127 px under it and B at DPR 3 lands 0.749 px over it. Judged by edge width, C is the closer match. Judged by error, the supersampled file is. On this one sample both are true at once. C also produced pixel-identical output at DPR 1, 2 and 3. Only pixels were compared there; file bytes were not.

Why the two scores split is still an inference

This section is reasoning, not measurement. The lower error plausibly comes from the reference being a supersampled, area-averaged image itself: B at DPR 3 sampled every glyph at three times the density before reducing, closer to what the reference did. The wider edges plausibly come from the reduction step. Going from 1200 to 800 is a factor of 1.5, and a bilinear filter at a non-integer ratio blends neighbouring pixels across the outline, which stretches the grey ramp. The run did not try an area-average downscale of the same 1200×300 file, so whether a box filter would keep the low error and also narrow the edges is open. imageSmoothingQuality, Safari, Firefox and Windows text rendering were not tested either.

The same helper shipped three different files

Back to measured numbers. At DPR 1 path B is path A, because devicePixelRatio is 1 and nothing gets multiplied. The 400×100 export gets upscaled and scores 5.98 px and 4.759, the worst row in the table. At DPR 2 path B scored exactly what C scored. At DPR 3 it took the trade described above. One function, one input, three results, decided by the screen of whoever clicked export. That part matters more to me than the 0.143. If those exports ever fed a visual regression baseline, the baseline would depend on which machine produced it, and diffs would appear without any code change. Then there is the size. By arithmetic, 1200×300 is 360,000 pixels, 2.25 times the 160,000 in the target, and an RGBA backing store for it is about 1.44 MB against 0.64 MB (4 bytes per pixel, decimal megabytes). Render and downscale time were not measured in this run.

Picking the path on purpose

If the job is small text that has to look crisp at the size it ships, render at the target. In this run that meant 1.641 px edges, close to the reference, and the same pixels on every screen. If closeness to a high-resolution reference is the acceptance check, supersampling did help here, by 0.143 on a 255 scale. Then I would fix the factor in code instead of inheriting it from the display, and check edges after the downscale; that combination is untested. For adding text to pictures in the browser I use ImgIng https://imging.ai/ ; its site says export goes back to the original canvas size and composes the result again instead of saving the resolution-adjusted preview. That reads like path C, though I have no view into its code. Before changing an export helper, export one label both ways, score both numbers against an 8× reference, and write down which one the team optimises.