@@ -8780,6 +8780,16 @@ const _foldColorMix = (inner, hexAlpha, forFallback) => {
 		if (color === null) return null;
 		weights.push(percent);
 		colors.push(color);
+		// Achromatic, so a polar space gives it no hue: the engine leaves the hue
+		// missing and interpolates the other color's own (CSS Color 4 §12.2), and a
+		// hue written in that space is lost on the way through sRGB regardless.
+		if (
+			space.hue !== -1 &&
+			color.linear[0] === color.linear[1] &&
+			color.linear[1] === color.linear[2]
+		) {
+			return null;
+		}
 	}
 	// An omitted percentage is what the other leaves; both omitted is an even mix.
 	if (weights[0] < 0 && weights[1] < 0) weights[0] = weights[1] = 50;
 
@@ -8083,6 +8083,24 @@ describe("CssSyntax minify — color-mix()", () => {
 		).toBe("a{color:#993a33}");
 	});
 
+	it("keeps a polar mix an achromatic color reaches with no hue", () => {
+		// A gray converts into hsl and hwb with its hue missing, and the engine
+		// interpolates the other color's own rather than the zero it lands on.
+		for (const css of [
+			"color-mix(in hsl,green,#fff)",
+			"color-mix(in hsl,green,#000)",
+			"color-mix(in hwb,green,gray)",
+			// ...and a hue written beside a zero saturation is lost the same way.
+			"color-mix(in hsl,green,hsl(50 0% 100%))"
+		]) {
+			expect(minify(`a{color:${css}}`)).toBe(`a{color:${css}}`);
+		}
+		// A space with no hue takes the same color and folds the mix as before.
+		expect(minify("a{color:color-mix(in srgb,#000 25%,#fff)}")).toBe(
+			"a{color:#bfbfbf}"
+		);
+	});
+
 	it("reads its own hue method, not one a nested mix left behind", () => {
 		// The nested mix resolves through this same fold, so a method held in module
 		// state would be the inner one's by the time the outer interpolates.
 
@@ -75,6 +75,7 @@ const buildCorpus = (dir, extension, minify) => {
  * @property {(conditions: string[]) => string[]} supportsSignatures whether each support condition holds
  * @property {(tagName: string, attribute: string, value: string | null) => [string | undefined, unknown]} probeReflection the IDL member an attribute reflects, and its value
  * @property {(value: string) => string} canonical a value under the one name the spec gives it
+ * @property {(value: string) => string} paintedColors a value with every color it holds painted
  */
 
 /**
@@ -181,6 +182,49 @@ const installHelpers = () => {
 		return out + rewrite(run);
 	};
 
+	// A color token, and the whole of a color function that holds no call of its
+	// own — which is every spelling but a nested `calc()`.
+	const COLOR_TOKEN_RE =
+		/#[\da-f]{3,8}\b|\b(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color|color-mix)\([^()]*\)/gi;
+
+	// One word, so a number with its unit is read whole rather than as an ident.
+	const WORD_RE = /[\w-]/;
+
+	/**
+	 * Every color a value holds, as the pixel it paints. A color the engine hands
+	 * back as written — a `var()` fallback, the one `image()` carries — is a color
+	 * still, and two spellings of it are one value. A bare keyword counts only
+	 * inside a call, where it is an argument: `font-family:red` names a family.
+	 * `currentcolor` is never painted, since the pixel it takes is the element's.
+	 * @param {string} value a value
+	 * @returns {string} the value, its colors painted
+	 */
+	const paintedColors = (value) =>
+		outsideText(value, (run) => {
+			let out = "";
+			let word = "";
+			let depth = 0;
+			const take = () => {
+				out +=
+					depth > 0 && word !== "" && !/^currentcolor$/i.test(word)
+						? painted(word)
+						: word;
+				word = "";
+			};
+			for (const ch of run.replace(COLOR_TOKEN_RE, (color) => painted(color))) {
+				if (WORD_RE.test(ch)) {
+					word += ch;
+					continue;
+				}
+				take();
+				if (ch === "(") depth++;
+				else if (ch === ")" && depth > 0) depth--;
+				out += ch;
+			}
+			take();
+			return out;
+		});
+
 	// The three code points CSS Syntax §3.3 calls a newline, `\r\n` included.
 	const NEWLINE = /[\n\r\f]/;
 
@@ -364,16 +408,9 @@ const installHelpers = () => {
 		// CSS Color 4 §5: `transparent` is that color written as a keyword, and an
 		// engine echoing a descriptor hands back whichever spelling it was given.
 		out = out.replace(/(^|[^\w-])transparent(?![\w-])/gi, "$1rgba(0, 0, 0, 0)");
-		// A color written into a value the engine cannot compute — a `var()`
-		// fallback — is still a color, and `#ff0` is `rgb(255,255,0)`.
 		// A string is text and a `url()` body names something, so neither holds a
 		// color: `url(#fff)` and `url(#ffffff)` are two different elements.
-		out = outsideText(out, (run) =>
-			run.replace(
-				/#[\da-f]{3,8}\b|\b(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\([^()]*\)/gi,
-				(color) => painted(color)
-			)
-		);
+		out = paintedColors(out);
 		return (
 			out
 				// Nothing fuses with a comma or a block's delimiters, so the whitespace
@@ -1202,7 +1239,8 @@ const installHelpers = () => {
 			containerSignatures,
 			supportsSignatures,
 			probeReflection,
-			canonical
+			canonical,
+			paintedColors
 		};
 };
 
 
@@ -690,9 +690,9 @@ describe("printer output in real Chrome", () => {
 	const compareValues = (cases) =>
 		inBatches(probePage, cases, (batch) =>
 			probePage.evaluate((each) => {
-				const { canonical } = /** @type {{ __eq: PageHelpers }} */ (
-					/** @type {unknown} */ (window)
-				).__eq;
+				const { canonical, paintedColors } =
+					/** @type {{ __eq: PageHelpers }} */ (/** @type {unknown} */ (window))
+						.__eq;
 				const probe = document.createElement("div");
 				document.body.append(probe);
 				// Computed values, not `cssText`: `left bottom` and `0% 100%` are one
@@ -720,12 +720,12 @@ describe("printer output in real Chrome", () => {
 					// boundary ("ab"+"c" against "a"+"bc") reads as equal.
 					let out = "";
 					for (const name of names) {
-						// Under the one name the spec gives the value: the engine echoes
-						// the spelling it was handed — `jump-start` beside `start`, a
-						// gradient's implied last stop beside a written one — so without
-						// this the tier reads a synonym as a change of meaning.
-						out += `${name}:${canonical(
-							computed.getPropertyValue(name)
+						// Under the one name the spec gives the value, its colors painted:
+						// the engine echoes the spelling it was handed — `jump-start`
+						// beside `start`, the color `image()` carries — so without this
+						// the tier reads a synonym as a change of meaning.
+						out += `${name}:${paintedColors(
+							canonical(computed.getPropertyValue(name))
 						)}\u0000`;
 					}
 					return out;