fix: Signed right shift losing a bit on exact operands

bitwiseSignedRightShift divided by pow(2.0, float(shifts)), but pow is
approximate on most GPUs — it is usually exp2(y * log2(x)) — so the
divisor could land ~1 ulp high. The quotient then fell just short of a
whole number and floor() discarded it: 2 >> 1 returned 0, 8 >> 1
returned 3, 8 >> 3 returned 0.

Only even left operands were affected. Odd ones carry a fractional part
large enough to absorb the error, which is why 3 >> 1 and 5 >> 1 were
always right and the breakage looked arbitrary.

Use _pow2 instead, the exact constant-multiply helper already added for
the same class of bug in the float packing (#659). Applied to both the
webgl and webgl2 shaders, with a forward declaration since _pow2 is
defined further down.

The other shift and bitwise operators are integer loops that never
touched pow, which matches the failure set exactly.

macOS suite goes 9 -> 3 failures; only the Infinity encoding family is
left. Verified exhaustively against JS semantics for `>>` over a wide
value range including negatives (0/484 mismatches, was 7/100 on the
0-9 grid alone), the other five bitwise operators unchanged, and 9
BrowserStack targets green — the webgl2 path has no node coverage.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: fuzzie360

dist/gpu-browser-core.js

@@ -5,7 +5,7 @@
  * GPU Accelerated JavaScript
  *
  * @version 2.19.7
- * @date Mon Jul 27 2026 00:05:27 GMT+0800 (Singapore Standard Time)
+ * @date Mon Jul 27 2026 00:22:08 GMT+0800 (Singapore Standard Time)
  *
  * @license MIT
  * The MIT License
@@ -6617,8 +6617,14 @@ int bitwiseZeroFillLeftShift(int n, int shift) {
   return result;
 }
 
+// _pow2 is defined further down, alongside encode32/decode32
+float _pow2(float e);
 int bitwiseSignedRightShift(int num, int shifts) {
-  return int(floor(float(num) / pow(2.0, float(shifts))));
+  // pow(2.0, n) is approximate on many GPUs, and landing 1 ulp high makes the
+  // division fall just under a whole number, which floor() then rounds away:
+  // 2 >> 1 came out 0, 8 >> 1 came out 3. Only exact left operands were
+  // affected, odd ones having enough slack to survive. _pow2 is exact.
+  return int(floor(float(num) / _pow2(float(shifts))));
 }
 
 int bitwiseZeroFillRightShift(int n, int shift) {
@@ -11358,8 +11364,14 @@ int bitwiseZeroFillLeftShift(int n, int shift) {
   return result;
 }
 
+// _pow2 is defined further down, alongside encode32/decode32
+float _pow2(float e);
 int bitwiseSignedRightShift(int num, int shifts) {
-  return int(floor(float(num) / pow(2.0, float(shifts))));
+  // pow(2.0, n) is approximate on many GPUs, and landing 1 ulp high makes the
+  // division fall just under a whole number, which floor() then rounds away:
+  // 2 >> 1 came out 0, 8 >> 1 came out 3. Only exact left operands were
+  // affected, odd ones having enough slack to survive. _pow2 is exact.
+  return int(floor(float(num) / _pow2(float(shifts))));
 }
 
 int bitwiseZeroFillRightShift(int n, int shift) {

dist/gpu-browser-core.min.js

@@ -5,7 +5,7 @@
  * GPU Accelerated JavaScript
  *
  * @version 2.19.7
- * @date Mon Jul 27 2026 00:05:27 GMT+0800 (Singapore Standard Time)
+ * @date Mon Jul 27 2026 00:22:08 GMT+0800 (Singapore Standard Time)
  *
  * @license MIT
  * The MIT License
@@ -12071,8 +12071,14 @@ int bitwiseZeroFillLeftShift(int n, int shift) {
   return result;
 }
 
+// _pow2 is defined further down, alongside encode32/decode32
+float _pow2(float e);
 int bitwiseSignedRightShift(int num, int shifts) {
-  return int(floor(float(num) / pow(2.0, float(shifts))));
+  // pow(2.0, n) is approximate on many GPUs, and landing 1 ulp high makes the
+  // division fall just under a whole number, which floor() then rounds away:
+  // 2 >> 1 came out 0, 8 >> 1 came out 3. Only exact left operands were
+  // affected, odd ones having enough slack to survive. _pow2 is exact.
+  return int(floor(float(num) / _pow2(float(shifts))));
 }
 
 int bitwiseZeroFillRightShift(int n, int shift) {
@@ -16812,8 +16818,14 @@ int bitwiseZeroFillLeftShift(int n, int shift) {
   return result;
 }
 
+// _pow2 is defined further down, alongside encode32/decode32
+float _pow2(float e);
 int bitwiseSignedRightShift(int num, int shifts) {
-  return int(floor(float(num) / pow(2.0, float(shifts))));
+  // pow(2.0, n) is approximate on many GPUs, and landing 1 ulp high makes the
+  // division fall just under a whole number, which floor() then rounds away:
+  // 2 >> 1 came out 0, 8 >> 1 came out 3. Only exact left operands were
+  // affected, odd ones having enough slack to survive. _pow2 is exact.
+  return int(floor(float(num) / _pow2(float(shifts))));
 }
 
 int bitwiseZeroFillRightShift(int n, int shift) {

dist/gpu-browser.js

@@ -192,8 +192,14 @@ int bitwiseZeroFillLeftShift(int n, int shift) {
   return result;
 }
 
+// _pow2 is defined further down, alongside encode32/decode32
+float _pow2(float e);
 int bitwiseSignedRightShift(int num, int shifts) {
-  return int(floor(float(num) / pow(2.0, float(shifts))));
+  // pow(2.0, n) is approximate on many GPUs, and landing 1 ulp high makes the
+  // division fall just under a whole number, which floor() then rounds away:
+  // 2 >> 1 came out 0, 8 >> 1 came out 3. Only exact left operands were
+  // affected, odd ones having enough slack to survive. _pow2 is exact.
+  return int(floor(float(num) / _pow2(float(shifts))));
 }
 
 int bitwiseZeroFillRightShift(int n, int shift) {

dist/gpu-browser.min.js

@@ -154,8 +154,14 @@ int bitwiseZeroFillLeftShift(int n, int shift) {
   return result;
 }
 
+// _pow2 is defined further down, alongside encode32/decode32
+float _pow2(float e);
 int bitwiseSignedRightShift(int num, int shifts) {
-  return int(floor(float(num) / pow(2.0, float(shifts))));
+  // pow(2.0, n) is approximate on many GPUs, and landing 1 ulp high makes the
+  // division fall just under a whole number, which floor() then rounds away:
+  // 2 >> 1 came out 0, 8 >> 1 came out 3. Only exact left operands were
+  // affected, odd ones having enough slack to survive. _pow2 is exact.
+  return int(floor(float(num) / _pow2(float(shifts))));
 }
 
 int bitwiseZeroFillRightShift(int n, int shift) {

src/backend/web-gl/fragment-shader.js

@@ -189,6 +189,21 @@ <h1>GPU.JS smoke test</h1>
         assertClose(kernel()[0], 5, 'loop total');
       });
 
+      test(label('signed right shift'), function (track) {
+        const gpu = track(new GPU({ mode: mode }));
+        // emulated in GLSL for both webgl and webgl2; used to use an
+        // approximate pow(2.0, n), so exact left operands shifted one too far
+        const kernel = gpu.createKernel(function (a, b) {
+          return a[this.thread.x] >> b[this.thread.x];
+        }, { output: [6] });
+        const left = [2, 4, 8, 8, 1024, -8];
+        const right = [1, 1, 3, 2, 5, 1];
+        const out = kernel(left, right);
+        left.forEach(function (value, i) {
+          assertClose(out[i], value >> right[i], value + ' >> ' + right[i], 0.001);
+        });
+      });
+
       test(label('modulo in a comparison'), function (track) {
         const gpu = track(new GPU({ mode: mode }));
         // used to fail to compile wherever fixIntegerDivisionAccuracy is off,