fix(round): strategy-dependent result for infinite step

round(A, B) with finite A and infinite B is not always 0 — the multiples
of an infinite step are {-∞, 0, +∞}, so up (ceiling) lands on +∞ for
positive A and down (floor) lands on -∞ for negative A. nearest/to-zero
still collapse to ±0 carrying A's sign.

Previously the !isFinite(b) branch returned signed zero for every
strategy, so round(up, 5, infinity) yielded 0 instead of calc(infinity)
and round(down, -5, infinity) yielded 0 instead of calc(-infinity). Also
fixes the dimensional form (round(up, 5px, calc(infinity * 1px))).

Corrects the general.test.mjs case that had codified the buggy output
and adds strategy-dependent coverage to round.test.mjs.

Author: dkryaklin

src/lib/simplify/round.js

@@ -42,16 +42,25 @@ function simplifyRound(args) {
   if (!fold) {return passthrough();}
 
   const [a, b] = /** @type {[number, number]} */ (fold.values);
-  // Spec §10.7.1 non-finite step: NaN propagates; infinite step with
-  // finite A folds to ±0 carrying A's sign (every strategy picks the same
-  // single point); both infinite cancels to NaN. Infinite-A / finite-B
-  // falls through to applyRound, where floor*b===ceil*b===±∞ collapses
-  // back to A (§10.3.1 "result is the same infinity").
+  // Spec §10.7.1 non-finite step: NaN propagates; both infinite cancels to
+  // NaN. Infinite step with finite A is strategy-dependent — the multiples
+  // of an infinite step are {-∞, 0, +∞}, so `up` (ceiling) lands on +∞ for
+  // positive A and `down` (floor) lands on -∞ for negative A; every other
+  // case folds to ±0 carrying A's sign. Infinite-A / finite-B falls through
+  // to applyRound, where floor*b===ceil*b===±∞ collapses back to A
+  // (§10.3.1 "result is the same infinity").
   if (isNaN(b)) {return num(NaN);}
   if (!isFinite(b)) {
     if (!isFinite(a)) {return num(NaN);}
-    const signedZero = a < 0 || Object.is(a, -0) ? -0 : 0;
-    return fold.unit === '' ? num(signedZero) : dim(signedZero, fold.unit);
+    let result;
+    if (strategy === 'up' && a > 0) {
+      result = Infinity;
+    } else if (strategy === 'down' && a < 0) {
+      result = -Infinity;
+    } else {
+      result = a < 0 || Object.is(a, -0) ? -0 : 0;
+    }
+    return fold.unit === '' ? num(result) : dim(result, fold.unit);
   }
 
   const result = applyRound(strategy, a, b);

test/unit/simplify/general.test.mjs

@@ -221,16 +221,16 @@ test('spec §10.3.1 line 1020: round(A, 0) is NaN', () => {
   assert.equal(out('round(down, 5, 0)'), 'calc(NaN)');
   assert.equal(out('round(to-zero, 5, 0)'), 'calc(NaN)');
 });
-test("spec §10.7.1: round(finite, ±infinity) → 0 carrying A's sign", () => {
-  // floor(A/±∞) = ceil(A/±∞) = ±0; the spec collapses that interval to
-  // the nearest multiple of step, which is 0 with sign of A. Strategy
-  // doesn't change the result. Found by the differential randomizer.
-  assert.equal(out('round(5, infinity)'), '0');
-  assert.equal(out('round(up, 5, infinity)'), '0');
-  // The simplifier produces -0 for negative A here, but the serializer
-  // collapses sign-of-zero to match CSS's numeric `-0 === 0` and the
-  // existing test expectations across abs/sign/etc.
-  assert.equal(out('round(down, calc(0 - 5), infinity)'), '0');
+test('spec §10.7.1: round(finite, ±infinity) is strategy-dependent', () => {
+  // The multiples of an infinite step are {-∞, 0, +∞}. up (ceiling) lands
+  // on +∞ for positive A; down (floor) lands on -∞ for negative A; nearest
+  // and to-zero collapse to 0 carrying A's sign. The serializer collapses
+  // sign-of-zero to match CSS's numeric `-0 === 0`.
+  assert.equal(out('round(5, infinity)'), '0'); // nearest default
+  assert.equal(out('round(up, 5, infinity)'), 'calc(infinity)');
+  assert.equal(out('round(down, calc(0 - 5), infinity)'), 'calc(-infinity)');
+  assert.equal(out('round(down, 5, infinity)'), '0');
+  assert.equal(out('round(up, calc(0 - 5), infinity)'), '0');
   assert.equal(out('round(3, calc(0 - infinity))'), '0');
 });
 test('spec §10.7.1: round(_, NaN) is NaN', () => {

test/unit/simplify/round.test.mjs

@@ -91,6 +91,29 @@ test('round: A infinite, B finite → same infinity (§10.3.1 line 1022)', () =>
   assert.equal(out('round(up, infinity, 10)'), 'calc(infinity)');
   assert.equal(out('round(down, calc(0 - infinity), 10)'), 'calc(-infinity)');
 });
+test('round: A finite, B infinite → strategy-dependent (§10.3.1)', () => {
+  // Multiples of an infinite step are {-∞, 0, +∞}.
+  // up (ceiling) lands on +∞ for positive A; down (floor) lands on -∞ for
+  // negative A; every other case folds to ±0 carrying A's sign.
+  assert.equal(out('round(up, 5, infinity)'), 'calc(infinity)');
+  assert.equal(out('round(down, calc(0 - 5), infinity)'), 'calc(-infinity)');
+  assert.equal(out('round(down, 5, infinity)'), '0');
+  assert.equal(out('round(up, calc(0 - 5), infinity)'), '0');
+  assert.equal(out('round(nearest, 5, infinity)'), '0');
+  assert.equal(out('round(to-zero, 5, infinity)'), '0');
+  // Dimensional A with an infinite dim step keeps the unit.
+  assert.equal(
+    out('round(up, 5px, calc(infinity * 1px))'),
+    'calc(infinity * 1px)'
+  );
+  assert.equal(
+    out('round(down, calc(0px - 5px), calc(infinity * 1px))'),
+    'calc(-infinity * 1px)'
+  );
+});
+test('round: A and B both infinite → NaN', () => {
+  assert.equal(out('round(infinity, infinity)'), 'calc(NaN)');
+});
 test('round: zero A → 0 (exact multiple)', () => {
   assert.equal(out('round(0, 5)'), '0');
   assert.equal(out('round(up, 0, 5)'), '0');