@deck.gl/extensions 9.4.0-alpha.1 → 9.4.0-beta.1

package/dist/dist.dev.js

@@ -13,7 +13,11 @@ var __exports__ = (() => {
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    try {
+      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    } catch (e) {
+      throw mod = 0, e;
+    }
   };
   var __export = (target, all) => {
     for (var name in all)
@@ -918,8 +922,7 @@ void main() {
      */
     _updateCategoryBitMask(params, extension) {
       const { categorySize } = extension.opts;
-      if (!categorySize)
-        return;
+      if (!categorySize) return;
       const { filterCategories } = this.props;
       const categoryBitMask = new Uint32Array([0, 0, 0, 0]);
       const categoryFilters = categorySize === 1 ? [filterCategories] : filterCategories;
@@ -1417,7 +1420,7 @@ void main() {
   var sqrDist = squaredDistance;
   var len = length;
   var sqrLen = squaredLength;
-  var forEach = function() {
+  var forEach = (function() {
     const vec = create();
     return function(a, stride, offset, count, fn, arg) {
       let i;
@@ -1444,7 +1447,7 @@ void main() {
       }
       return a;
     };
-  }();
+  })();
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/math/fp64/fp64-utils.js
   function fp64ify(a, out = [], startIndex = 0) {
@@ -1673,6 +1676,462 @@ vec2 sqrt_fp64(vec2 a) {
 `
   );
 
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/math/fp64/fp64-arithmetic-wgsl-integer.js
+  var fp64arithmeticWGSLInteger = (
+    /* wgsl */
+    `struct Fp64F32Bits {
+  sign: u32,
+  baseExponent: i32,
+  significand: u32,
+  isZero: bool,
+  isInf: bool,
+  isNan: bool,
+};
+
+// Decode an f32 as (-1)^sign * significand * 2^baseExponent.
+fn fp64_decode_f32_bits(bits: u32) -> Fp64F32Bits {
+  let sign = bits >> 31u;
+  let exponentBits = (bits >> 23u) & 0xffu;
+  let fraction = bits & 0x7fffffu;
+
+  if (exponentBits == 0xffu) {
+    return Fp64F32Bits(sign, 0, 0u, false, fraction == 0u, fraction != 0u);
+  }
+  if (exponentBits == 0u) {
+    return Fp64F32Bits(sign, -149, fraction, fraction == 0u, false, false);
+  }
+  return Fp64F32Bits(sign, i32(exponentBits) - 150, 0x800000u | fraction, false, false, false);
+}
+
+fn fp64_f32_magnitude_compare(aBits: u32, bBits: u32) -> i32 {
+  let aMagnitude = aBits & 0x7fffffffu;
+  let bMagnitude = bBits & 0x7fffffffu;
+  if (aMagnitude == bMagnitude) {
+    return 0;
+  }
+  return select(-1, 1, aMagnitude > bMagnitude);
+}
+
+fn fp64_make_residual_f32_bits(
+  exactSign: u32,
+  exactMagnitude: vec2u,
+  exactBaseExponent: i32,
+  highBits: u32
+) -> u32 {
+  if (fp64_u64_is_zero(exactMagnitude)) {
+    return 0u;
+  }
+
+  let high = fp64_decode_f32_bits(highBits);
+  if (high.isInf || high.isNan) {
+    return exactSign << 31u;
+  }
+  if (high.isZero) {
+    return fp64_make_f32_bits_from_u64(exactSign, exactMagnitude, exactBaseExponent);
+  }
+
+  let commonBaseExponent = min(exactBaseExponent, high.baseExponent);
+  let exactShift = exactBaseExponent - commonBaseExponent;
+  let highShift = high.baseExponent - commonBaseExponent;
+
+  // A normal two-sum/two-product residual never needs a shift this large.
+  // This guard gives deterministic underflow behavior outside that contract.
+  if (exactShift >= 64 || highShift >= 64) {
+    return exactSign << 31u;
+  }
+
+  let exactAligned = fp64_u64_shift_left(exactMagnitude, u32(exactShift));
+  let highAligned = fp64_u64_shift_left(vec2u(0u, high.significand), u32(highShift));
+  let comparison = fp64_u64_compare(exactAligned, highAligned);
+  if (comparison == 0) {
+    return 0u;
+  }
+
+  var residualSign = exactSign;
+  var residualMagnitude: vec2u;
+  if (comparison > 0) {
+    residualMagnitude = fp64_u64_sub(exactAligned, highAligned);
+  } else {
+    residualSign = exactSign ^ 1u;
+    residualMagnitude = fp64_u64_sub(highAligned, exactAligned);
+  }
+  return fp64_make_f32_bits_from_u64(
+    residualSign,
+    residualMagnitude,
+    commonBaseExponent
+  );
+}
+
+fn fp64_split_accumulator_bits(
+  sign: u32,
+  magnitude: vec2u,
+  baseExponent: i32
+) -> vec2u {
+  let highBits = fp64_make_f32_bits_from_u64(sign, magnitude, baseExponent);
+  let lowBits = fp64_make_residual_f32_bits(sign, magnitude, baseExponent, highBits);
+  return vec2u(highBits, lowBits);
+}
+
+fn fp64_two_sum_integer_bits(aBits: u32, bBits: u32) -> vec2u {
+  let a = fp64_decode_f32_bits(aBits);
+  let b = fp64_decode_f32_bits(bBits);
+
+  if (a.isNan || b.isNan) {
+    return vec2u(0x7fc00000u, 0u);
+  }
+  if (a.isInf || b.isInf) {
+    if (a.isInf && b.isInf && a.sign != b.sign) {
+      return vec2u(0x7fc00000u, 0u);
+    }
+    return select(vec2u(bBits, 0u), vec2u(aBits, 0u), a.isInf);
+  }
+  if (a.isZero && b.isZero) {
+    return vec2u((a.sign & b.sign) << 31u, 0u);
+  }
+  if (a.isZero) {
+    return vec2u(bBits, 0u);
+  }
+  if (b.isZero) {
+    return vec2u(aBits, 0u);
+  }
+
+  let exponentDifference = select(
+    b.baseExponent - a.baseExponent,
+    a.baseExponent - b.baseExponent,
+    a.baseExponent >= b.baseExponent
+  );
+
+  // Beyond half an ulp, rounding cannot change the larger operand. Returning
+  // the smaller operand intact also avoids an unbounded integer alignment.
+  // At a power-of-two boundary the spacing below the larger operand is half
+  // the spacing above it, so an opposite-sign gap-25 operand can still change
+  // the rounded high limb. Gap 26 is the first universally safe early-out.
+  if (exponentDifference > 25) {
+    if (fp64_f32_magnitude_compare(aBits, bBits) >= 0) {
+      return vec2u(aBits, bBits);
+    }
+    return vec2u(bBits, aBits);
+  }
+
+  let commonBaseExponent = min(a.baseExponent, b.baseExponent);
+  let aMagnitude = fp64_u64_shift_left(
+    vec2u(0u, a.significand),
+    u32(a.baseExponent - commonBaseExponent)
+  );
+  let bMagnitude = fp64_u64_shift_left(
+    vec2u(0u, b.significand),
+    u32(b.baseExponent - commonBaseExponent)
+  );
+
+  var resultSign = a.sign;
+  var resultMagnitude: vec2u;
+  if (a.sign == b.sign) {
+    resultMagnitude = fp64_u64_add(aMagnitude, bMagnitude);
+  } else {
+    let comparison = fp64_u64_compare(aMagnitude, bMagnitude);
+    if (comparison == 0) {
+      return vec2u(0u, 0u);
+    }
+    if (comparison > 0) {
+      resultMagnitude = fp64_u64_sub(aMagnitude, bMagnitude);
+    } else {
+      resultSign = b.sign;
+      resultMagnitude = fp64_u64_sub(bMagnitude, aMagnitude);
+    }
+  }
+
+  return fp64_split_accumulator_bits(resultSign, resultMagnitude, commonBaseExponent);
+}
+
+fn fp64_two_sum_integer(a: f32, b: f32) -> vec2f {
+  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bitcast<u32>(b));
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+fn fp64_multiply_significands(a: u32, b: u32) -> vec2u {
+  let aLow = a & 0xffffu;
+  let aHigh = a >> 16u;
+  let bLow = b & 0xffffu;
+  let bHigh = b >> 16u;
+  let lowProduct = aLow * bLow;
+  let crossProduct = aLow * bHigh + aHigh * bLow;
+  let highProduct = aHigh * bHigh;
+
+  var result = vec2u(0u, lowProduct);
+  result = fp64_u64_add(
+    result,
+    fp64_u64_shift_left(vec2u(0u, crossProduct), 16u)
+  );
+  result = fp64_u64_add(result, vec2u(highProduct, 0u));
+  return result;
+}
+
+fn fp64_two_prod_integer_bits(aBits: u32, bBits: u32) -> vec2u {
+  let a = fp64_decode_f32_bits(aBits);
+  let b = fp64_decode_f32_bits(bBits);
+  let resultSign = a.sign ^ b.sign;
+
+  if (a.isNan || b.isNan || ((a.isZero || b.isZero) && (a.isInf || b.isInf))) {
+    return vec2u(0x7fc00000u, 0u);
+  }
+  if (a.isInf || b.isInf) {
+    return vec2u((resultSign << 31u) | 0x7f800000u, resultSign << 31u);
+  }
+  if (a.isZero || b.isZero) {
+    return vec2u(resultSign << 31u, resultSign << 31u);
+  }
+
+  let magnitude = fp64_multiply_significands(a.significand, b.significand);
+  return fp64_split_accumulator_bits(
+    resultSign,
+    magnitude,
+    a.baseExponent + b.baseExponent
+  );
+}
+
+fn fp64_two_prod_integer(a: f32, b: f32) -> vec2f {
+  let resultBits = fp64_two_prod_integer_bits(bitcast<u32>(a), bitcast<u32>(b));
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+fn fp64_round_add_integer(a: f32, b: f32) -> f32 {
+  return fp64_two_sum_integer(a, b).x;
+}
+
+fn fp64_round_mul_integer(a: f32, b: f32) -> f32 {
+  return fp64_two_prod_integer(a, b).x;
+}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn fp64_f32_finite_exponent(value: Fp64F32Bits) -> i32 {
+  let mostSignificantBit = 31u - countLeadingZeros(value.significand);
+  return value.baseExponent + i32(mostSignificantBit);
+}
+
+fn fp64_scale_f32_integer(value: f32, exponent: i32) -> f32 {
+  let decoded = fp64_decode_f32_bits(bitcast<u32>(value));
+  if (decoded.isZero || decoded.isInf || decoded.isNan) {
+    return value;
+  }
+  let resultBits = fp64_make_f32_bits_from_u64(
+    decoded.sign,
+    vec2u(0u, decoded.significand),
+    decoded.baseExponent + exponent
+  );
+  return bitcast<f32>(resultBits);
+}
+
+// Divide normalized significands so the hardware operation cannot overflow,
+// underflow, or flush a subnormal result. Reapply the exponent with integer
+// packing, which also produces subnormal correction limbs without relying on
+// floating-point arithmetic to preserve them.
+fn fp64_divide_f32_integer(aValue: f32, bValue: f32) -> f32 {
+  let a = fp64_decode_f32_bits(bitcast<u32>(aValue));
+  let b = fp64_decode_f32_bits(bitcast<u32>(bValue));
+  if (a.isZero || b.isZero || a.isInf || b.isInf || a.isNan || b.isNan) {
+    return aValue / bValue;
+  }
+
+  let aMostSignificantBit = 31u - countLeadingZeros(a.significand);
+  let bMostSignificantBit = 31u - countLeadingZeros(b.significand);
+  let normalizedABits = fp64_make_f32_bits_from_u64(
+    a.sign,
+    vec2u(0u, a.significand),
+    -i32(aMostSignificantBit)
+  );
+  let normalizedBBits = fp64_make_f32_bits_from_u64(
+    b.sign,
+    vec2u(0u, b.significand),
+    -i32(bMostSignificantBit)
+  );
+  let normalizedQuotient = bitcast<f32>(normalizedABits) / bitcast<f32>(normalizedBBits);
+  let quotient = fp64_decode_f32_bits(bitcast<u32>(normalizedQuotient));
+  let exponentShift =
+    a.baseExponent + i32(aMostSignificantBit) -
+    b.baseExponent - i32(bMostSignificantBit);
+  let quotientBits = fp64_make_f32_bits_from_u64(
+    quotient.sign,
+    vec2u(0u, quotient.significand),
+    quotient.baseExponent + exponentShift
+  );
+  return bitcast<f32>(quotientBits);
+}
+#endif
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn split(a: f32) -> vec2f {
+  let aBits = bitcast<u32>(a);
+  let decoded = fp64_decode_f32_bits(aBits);
+  if (decoded.isZero || decoded.isInf || decoded.isNan) {
+    return vec2f(a, 0.0);
+  }
+
+  var roundedHigh = decoded.significand >> 12u;
+  let remainder = decoded.significand & 0xfffu;
+  if (remainder > 0x800u || (remainder == 0x800u && (roundedHigh & 1u) == 1u)) {
+    roundedHigh = roundedHigh + 1u;
+  }
+  var highMagnitude = vec2u(0u, roundedHigh << 12u);
+  var highBits = fp64_make_f32_bits_from_u64(
+    decoded.sign,
+    highMagnitude,
+    decoded.baseExponent
+  );
+  // Rounding the high limb of a maximum-exponent value can overflow even
+  // though the original value is finite. Truncate only in that boundary case
+  // so split remains an exact finite decomposition.
+  if (fp64_decode_f32_bits(highBits).isInf) {
+    roundedHigh = decoded.significand >> 12u;
+    highMagnitude = vec2u(0u, roundedHigh << 12u);
+    highBits = fp64_make_f32_bits_from_u64(
+      decoded.sign,
+      highMagnitude,
+      decoded.baseExponent
+    );
+  }
+  let lowBits = fp64_make_residual_f32_bits(
+    decoded.sign,
+    vec2u(0u, decoded.significand),
+    decoded.baseExponent,
+    highBits
+  );
+  return vec2f(bitcast<f32>(highBits), bitcast<f32>(lowBits));
+}
+
+fn split2(a: vec2f) -> vec2f {
+  var result = split(a.x);
+  result.y = fp64_round_add_integer(result.y, a.y);
+  return result;
+}
+#endif
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn quickTwoSum(a: f32, b: f32) -> vec2f {
+  return fp64_two_sum_integer(a, b);
+}
+#endif
+
+fn twoSum(a: f32, b: f32) -> vec2f {
+  return fp64_two_sum_integer(a, b);
+}
+
+fn twoSub(a: f32, b: f32) -> vec2f {
+  let bBits = bitcast<u32>(b) ^ 0x80000000u;
+  let resultBits = fp64_two_sum_integer_bits(bitcast<u32>(a), bBits);
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn twoSqr(a: f32) -> vec2f {
+  return fp64_two_prod_integer(a, a);
+}
+
+fn twoProd(a: f32, b: f32) -> vec2f {
+  return fp64_two_prod_integer(a, b);
+}
+#endif
+
+fn sum_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var sum = fp64_two_sum_integer(a.x, b.x);
+  let lowSum = fp64_two_sum_integer(a.y, b.y);
+  sum.y = fp64_round_add_integer(sum.y, lowSum.x);
+  sum = fp64_two_sum_integer(sum.x, sum.y);
+  sum.y = fp64_round_add_integer(sum.y, lowSum.y);
+  return fp64_two_sum_integer(sum.x, sum.y);
+}
+
+fn sub_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let negatedB = vec2f(
+    bitcast<f32>(bitcast<u32>(b.x) ^ 0x80000000u),
+    bitcast<f32>(bitcast<u32>(b.y) ^ 0x80000000u)
+  );
+  return sum_fp64(a, negatedB);
+}
+
+fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
+  var product = fp64_two_prod_integer(a.x, b.x);
+  let crossProduct1 = fp64_round_mul_integer(a.x, b.y);
+  product.y = fp64_round_add_integer(product.y, crossProduct1);
+  product = fp64_two_sum_integer(product.x, product.y);
+  let crossProduct2 = fp64_round_mul_integer(a.y, b.x);
+  product.y = fp64_round_add_integer(product.y, crossProduct2);
+  return fp64_two_sum_integer(product.x, product.y);
+}
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn fp64_scale_fp64_integer(value: vec2f, exponent: i32) -> vec2f {
+  let high = fp64_scale_f32_integer(value.x, exponent);
+  let low = fp64_scale_f32_integer(value.y, exponent);
+  return sum_fp64(vec2f(high, 0.0), vec2f(low, 0.0));
+}
+
+fn fp64_div_fp64_normalized(a: vec2f, b: vec2f) -> vec2f {
+  let quotientHigh = fp64_divide_f32_integer(a.x, b.x);
+  var quotient = vec2f(quotientHigh, 0.0);
+
+  let remainder = sub_fp64(a, mul_fp64(b, quotient));
+  let quotientLow = fp64_divide_f32_integer(remainder.x, b.x);
+  quotient = sum_fp64(quotient, vec2f(quotientLow, 0.0));
+
+  let secondRemainder = sub_fp64(a, mul_fp64(b, quotient));
+  let correction = fp64_divide_f32_integer(secondRemainder.x, b.x);
+  return sum_fp64(quotient, vec2f(correction, 0.0));
+}
+
+fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
+  let decodedA = fp64_decode_f32_bits(bitcast<u32>(a.x));
+  let decodedB = fp64_decode_f32_bits(bitcast<u32>(b.x));
+  if (
+    decodedA.isZero || decodedB.isZero ||
+    decodedA.isInf || decodedB.isInf ||
+    decodedA.isNan || decodedB.isNan
+  ) {
+    return fp64_div_fp64_normalized(a, b);
+  }
+
+  let exponentA = fp64_f32_finite_exponent(decodedA);
+  let exponentB = fp64_f32_finite_exponent(decodedB);
+  // Correct the quotient near unity so b * q and the remainder stay clear of
+  // both f32 underflow and overflow. The exponent difference is applied once.
+  let normalizedA = fp64_scale_fp64_integer(a, -exponentA);
+  let normalizedB = fp64_scale_fp64_integer(b, -exponentB);
+  let normalizedQuotient = fp64_div_fp64_normalized(normalizedA, normalizedB);
+  return fp64_scale_fp64_integer(normalizedQuotient, exponentA - exponentB);
+}
+
+fn fp64_sqrt_fp64_normalized(a: vec2f) -> vec2f {
+  let estimate = sqrt(a.x);
+  let difference = sub_fp64(a, fp64_two_prod_integer(estimate, estimate)).x;
+  let denominator = fp64_round_add_integer(estimate, estimate);
+  let correction = fp64_divide_f32_integer(difference, denominator);
+  return sum_fp64(vec2f(estimate, 0.0), vec2f(correction, 0.0));
+}
+
+fn sqrt_fp64(a: vec2f) -> vec2f {
+  let decoded = fp64_decode_f32_bits(bitcast<u32>(a.x));
+  let decodedLow = fp64_decode_f32_bits(bitcast<u32>(a.y));
+  if (decoded.isZero && decodedLow.isZero) {
+    return vec2f(0.0, 0.0);
+  }
+  if (decoded.sign == 1u) {
+    let nanValue = fp64_nan(a.x);
+    return vec2f(nanValue, nanValue);
+  }
+
+  if (decoded.isInf || decoded.isNan) {
+    return fp64_sqrt_fp64_normalized(a);
+  }
+  let exponent = fp64_f32_finite_exponent(decoded);
+  // An even scale lets the final square-root rescale use an integer exponent.
+  let evenExponent = exponent - (exponent & 1);
+  let normalizedA = fp64_scale_fp64_integer(a, -evenExponent);
+  let normalizedRoot = fp64_sqrt_fp64_normalized(normalizedA);
+  return fp64_scale_fp64_integer(normalizedRoot, evenExponent / 2);
+}
+#endif
+`
+  );
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/math/fp64/fp64-arithmetic-wgsl.js
   var fp64arithmeticWGSL = (
     /* wgsl */
@@ -1683,11 +2142,608 @@ vec2 sqrt_fp64(vec2 a) {
 
 @group(0) @binding(auto) var<uniform> fp64arithmetic : Fp64ArithmeticUniforms;
 
+#ifndef LUMA_FP64_F32_INPUT_ONLY
+struct Fp64Bits {
+  sign: u32,
+  exponent: i32,
+  significand: vec2u,
+  isZero: bool,
+  isInf: bool,
+  isNan: bool,
+};
+#endif
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
 fn fp64_nan(seed: f32) -> f32 {
   let nanBits = 0x7fc00000u | select(0u, 1u, seed < 0.0);
   return bitcast<f32>(nanBits);
 }
+#endif
+
+fn fp64_u64_is_zero(value: vec2u) -> bool {
+  return value.x == 0u && value.y == 0u;
+}
+
+fn fp64_u64_compare(a: vec2u, b: vec2u) -> i32 {
+  if (a.x != b.x) {
+    return select(-1, 1, a.x > b.x);
+  }
+  if (a.y != b.y) {
+    return select(-1, 1, a.y > b.y);
+  }
+  return 0;
+}
+
+fn fp64_u64_add(a: vec2u, b: vec2u) -> vec2u {
+  let low = a.y + b.y;
+  let carry = select(0u, 1u, low < a.y);
+  return vec2u(a.x + b.x + carry, low);
+}
+
+fn fp64_u64_sub(a: vec2u, b: vec2u) -> vec2u {
+  let borrow = select(0u, 1u, a.y < b.y);
+  return vec2u(a.x - b.x - borrow, a.y - b.y);
+}
+
+fn fp64_u64_shift_left(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u((value.x << shift) | (value.y >> (32u - shift)), value.y << shift);
+  }
+  if (shift == 32u) {
+    return vec2u(value.y, 0u);
+  }
+  if (shift < 64u) {
+    return vec2u(value.y << (shift - 32u), 0u);
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_shift_right(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+  if (shift < 32u) {
+    return vec2u(value.x >> shift, (value.y >> shift) | (value.x << (32u - shift)));
+  }
+  if (shift == 32u) {
+    return vec2u(0u, value.x);
+  }
+  if (shift < 64u) {
+    return vec2u(0u, value.x >> (shift - 32u));
+  }
+  return vec2u(0u);
+}
+
+fn fp64_u64_get_bit(value: vec2u, bitIndex: u32) -> bool {
+  if (bitIndex >= 64u) {
+    return false;
+  }
+  if (bitIndex >= 32u) {
+    return ((value.x >> (bitIndex - 32u)) & 1u) != 0u;
+  }
+  return ((value.y >> bitIndex) & 1u) != 0u;
+}
+
+fn fp64_u64_has_bits_below(value: vec2u, bitCount: u32) -> bool {
+  if (bitCount == 0u) {
+    return false;
+  }
+  if (bitCount >= 64u) {
+    return !fp64_u64_is_zero(value);
+  }
+  if (bitCount > 32u) {
+    let highBitCount = bitCount - 32u;
+    let highMask = (1u << highBitCount) - 1u;
+    return value.y != 0u || (value.x & highMask) != 0u;
+  }
+  if (bitCount == 32u) {
+    return value.y != 0u;
+  }
+  let lowMask = (1u << bitCount) - 1u;
+  return (value.y & lowMask) != 0u;
+}
 
+#ifndef LUMA_FP64_F32_INPUT_ONLY
+fn fp64_u64_shift_right_sticky(value: vec2u, shift: u32) -> vec2u {
+  var shifted = fp64_u64_shift_right(value, shift);
+  if (fp64_u64_has_bits_below(value, shift)) {
+    shifted.y = shifted.y | 1u;
+  }
+  return shifted;
+}
+#endif
+
+fn fp64_u64_count_leading_zeros(value: vec2u) -> u32 {
+  if (value.x != 0u) {
+    return countLeadingZeros(value.x);
+  }
+  return 32u + countLeadingZeros(value.y);
+}
+
+fn fp64_round_shift_right_to_u32(value: vec2u, shift: u32) -> u32 {
+  if (shift == 0u) {
+    return value.y;
+  }
+
+  let truncated = fp64_u64_shift_right(value, shift);
+  var rounded = truncated.y;
+  let guard = fp64_u64_get_bit(value, shift - 1u);
+  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);
+  if (guard && (hasTrailingBits || (rounded & 1u) == 1u)) {
+    rounded = rounded + 1u;
+  }
+  return rounded;
+}
+
+#ifndef LUMA_FP64_F32_INPUT_ONLY
+fn fp64_round_shift_right(value: vec2u, shift: u32) -> vec2u {
+  if (shift == 0u) {
+    return value;
+  }
+
+  var rounded = fp64_u64_shift_right(value, shift);
+  let guard = fp64_u64_get_bit(value, shift - 1u);
+  let hasTrailingBits = fp64_u64_has_bits_below(value, shift - 1u);
+  if (guard && (hasTrailingBits || (rounded.y & 1u) == 1u)) {
+    rounded = fp64_u64_add(rounded, vec2u(0u, 1u));
+  }
+  return rounded;
+}
+#endif
+
+fn fp64_make_f32_bits_from_u64(sign: u32, significand: vec2u, baseExponent: i32) -> u32 {
+  if (fp64_u64_is_zero(significand)) {
+    return sign << 31u;
+  }
+
+  let leadingZeros = fp64_u64_count_leading_zeros(significand);
+  let mostSignificantBit = 63u - leadingZeros;
+  var exponent = baseExponent + i32(mostSignificantBit);
+
+  if (exponent > 127) {
+    return (sign << 31u) | 0x7f800000u;
+  }
+
+  if (exponent >= -126) {
+    let shift = i32(mostSignificantBit) - 23;
+    var significand24: u32;
+    if (shift > 0) {
+      significand24 = fp64_round_shift_right_to_u32(significand, u32(shift));
+    } else {
+      significand24 = fp64_u64_shift_left(significand, u32(-shift)).y;
+    }
+
+    if (significand24 >= 0x1000000u) {
+      significand24 = significand24 >> 1u;
+      exponent = exponent + 1;
+      if (exponent > 127) {
+        return (sign << 31u) | 0x7f800000u;
+      }
+    }
+
+    return (sign << 31u) | (u32(exponent + 127) << 23u) | (significand24 & 0x7fffffu);
+  }
+
+  let scaleExponent = baseExponent + 149;
+  var mantissa: u32;
+  if (scaleExponent >= 0) {
+    mantissa = fp64_u64_shift_left(significand, u32(scaleExponent)).y;
+  } else {
+    mantissa = fp64_round_shift_right_to_u32(significand, u32(-scaleExponent));
+  }
+
+  if (mantissa >= 0x800000u) {
+    return (sign << 31u) | 0x00800000u;
+  }
+  return (sign << 31u) | mantissa;
+}
+
+#ifndef LUMA_FP64_F32_INPUT_ONLY
+fn fp64_decode_bits(bits: vec2u) -> Fp64Bits {
+  let sign = bits.x >> 31u;
+  let exponentBits = (bits.x >> 20u) & 0x7ffu;
+  let fractionHigh = bits.x & 0xfffffu;
+  let fractionLow = bits.y;
+  let fraction = vec2u(fractionHigh, fractionLow);
+
+  if (exponentBits == 0x7ffu) {
+    let isInf = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, 0, vec2u(0u), false, isInf, !isInf);
+  }
+
+  if (exponentBits == 0u) {
+    let isZero = fp64_u64_is_zero(fraction);
+    return Fp64Bits(sign, -1022, fraction, isZero, false, false);
+  }
+
+  return Fp64Bits(sign, i32(exponentBits) - 1023, vec2u((1u << 20u) | fractionHigh, fractionLow), false, false, false);
+}
+
+fn fp64_finite_magnitude_compare(a: Fp64Bits, b: Fp64Bits) -> i32 {
+  if (a.exponent != b.exponent) {
+    return select(-1, 1, a.exponent > b.exponent);
+  }
+  return fp64_u64_compare(a.significand, b.significand);
+}
+#endif
+
+#ifndef LUMA_FP64_F32_INPUT_ONLY
+struct Fp64RawF32Bits {
+  sign: u32,
+  baseExponent: i32,
+  significand: u32,
+  isZero: bool,
+  isInf: bool,
+  isNan: bool,
+};
+
+// Decode an f32 as (-1)^sign * significand * 2^baseExponent. This shared
+// integer representation lets normalization remain independent of the
+// selected double-single arithmetic implementation.
+fn fp64_decode_raw_f32_bits(bits: u32) -> Fp64RawF32Bits {
+  let sign = bits >> 31u;
+  let exponentBits = (bits >> 23u) & 0xffu;
+  let fraction = bits & 0x7fffffu;
+
+  if (exponentBits == 0xffu) {
+    return Fp64RawF32Bits(sign, 0, 0u, false, fraction == 0u, fraction != 0u);
+  }
+  if (exponentBits == 0u) {
+    return Fp64RawF32Bits(sign, -149, fraction, fraction == 0u, false, false);
+  }
+  return Fp64RawF32Bits(
+    sign,
+    i32(exponentBits) - 150,
+    0x800000u | fraction,
+    false,
+    false,
+    false
+  );
+}
+
+fn fp64_raw_f32_magnitude_compare(aBits: u32, bBits: u32) -> i32 {
+  let aMagnitude = aBits & 0x7fffffffu;
+  let bMagnitude = bBits & 0x7fffffffu;
+  if (aMagnitude == bMagnitude) {
+    return 0;
+  }
+  return select(-1, 1, aMagnitude > bMagnitude);
+}
+
+fn fp64_make_raw_residual_f32_bits(
+  exactSign: u32,
+  exactMagnitude: vec2u,
+  exactBaseExponent: i32,
+  highBits: u32
+) -> u32 {
+  if (fp64_u64_is_zero(exactMagnitude)) {
+    return 0u;
+  }
+
+  let high = fp64_decode_raw_f32_bits(highBits);
+  if (high.isInf || high.isNan) {
+    return 0u;
+  }
+  if (high.isZero) {
+    return fp64_make_f32_bits_from_u64(exactSign, exactMagnitude, exactBaseExponent);
+  }
+
+  let commonBaseExponent = min(exactBaseExponent, high.baseExponent);
+  let exactShift = exactBaseExponent - commonBaseExponent;
+  let highShift = high.baseExponent - commonBaseExponent;
+  if (exactShift >= 64 || highShift >= 64) {
+    return 0u;
+  }
+
+  let exactAligned = fp64_u64_shift_left(exactMagnitude, u32(exactShift));
+  let highAligned = fp64_u64_shift_left(vec2u(0u, high.significand), u32(highShift));
+  let comparison = fp64_u64_compare(exactAligned, highAligned);
+  if (comparison == 0) {
+    return 0u;
+  }
+
+  var residualSign = exactSign;
+  var residualMagnitude: vec2u;
+  if (comparison > 0) {
+    residualMagnitude = fp64_u64_sub(exactAligned, highAligned);
+  } else {
+    residualSign = exactSign ^ 1u;
+    residualMagnitude = fp64_u64_sub(highAligned, exactAligned);
+  }
+  return fp64_make_f32_bits_from_u64(
+    residualSign,
+    residualMagnitude,
+    commonBaseExponent
+  );
+}
+
+fn fp64_split_raw_accumulator_bits(
+  sign: u32,
+  magnitude: vec2u,
+  baseExponent: i32
+) -> vec2u {
+  if (fp64_u64_is_zero(magnitude)) {
+    return vec2u(0u);
+  }
+  let highBits = fp64_make_f32_bits_from_u64(sign, magnitude, baseExponent);
+  let rawLowBits = fp64_make_raw_residual_f32_bits(sign, magnitude, baseExponent, highBits);
+  let lowBits = select(rawLowBits, 0u, (rawLowBits & 0x7fffffffu) == 0u);
+  if ((highBits & 0x7fffffffu) == 0u && (lowBits & 0x7fffffffu) == 0u) {
+    return vec2u(0u);
+  }
+  return vec2u(highBits, lowBits);
+}
+#endif
+
+#ifndef LUMA_FP64_F32_INPUT_ONLY
+// Round an arithmetic accumulator to binary64 before splitting it. The
+// aligned add/subtract paths retain three guard bits plus a sticky bit, which
+// is sufficient for round-to-nearest-even at the binary64 boundary.
+fn fp64_split_binary64_accumulator_bits(
+  sign: u32,
+  magnitude: vec2u,
+  baseExponent: i32
+) -> vec2u {
+  if (fp64_u64_is_zero(magnitude)) {
+    return vec2u(0u);
+  }
+
+  let mostSignificantBit = 63u - fp64_u64_count_leading_zeros(magnitude);
+  let exponent = baseExponent + i32(mostSignificantBit);
+  if (exponent > 1023) {
+    return vec2u((sign << 31u) | 0x7f800000u, 0u);
+  }
+
+  var roundedMagnitude = magnitude;
+  var roundedBaseExponent = baseExponent;
+  if (exponent >= -1022) {
+    if (mostSignificantBit > 52u) {
+      let shift = mostSignificantBit - 52u;
+      roundedMagnitude = fp64_round_shift_right(magnitude, shift);
+      roundedBaseExponent = baseExponent + i32(shift);
+    }
+  } else {
+    let shift = -1074 - baseExponent;
+    if (shift > 0) {
+      roundedMagnitude = fp64_round_shift_right(magnitude, u32(shift));
+      roundedBaseExponent = -1074;
+    }
+  }
+
+  if (fp64_u64_is_zero(roundedMagnitude)) {
+    return vec2u(0u);
+  }
+  return fp64_split_raw_accumulator_bits(sign, roundedMagnitude, roundedBaseExponent);
+}
+#endif
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn fp64_add_raw_f32_bits(aBits: u32, bBits: u32) -> vec2u {
+  let a = fp64_decode_raw_f32_bits(aBits);
+  let b = fp64_decode_raw_f32_bits(bBits);
+
+  if (a.isNan || b.isNan) {
+    return vec2u(0x7fc00000u, 0u);
+  }
+  if (a.isInf || b.isInf) {
+    if (a.isInf && b.isInf && a.sign != b.sign) {
+      return vec2u(0x7fc00000u, 0u);
+    }
+    return select(vec2u(bBits, 0u), vec2u(aBits, 0u), a.isInf);
+  }
+  if (a.isZero && b.isZero) {
+    return vec2u(0u);
+  }
+  if (a.isZero) {
+    return vec2u(bBits, 0u);
+  }
+  if (b.isZero) {
+    return vec2u(aBits, 0u);
+  }
+
+  let exponentDifference = abs(a.baseExponent - b.baseExponent);
+  if (exponentDifference > 25) {
+    if (fp64_raw_f32_magnitude_compare(aBits, bBits) >= 0) {
+      return vec2u(aBits, bBits);
+    }
+    return vec2u(bBits, aBits);
+  }
+
+  let commonBaseExponent = min(a.baseExponent, b.baseExponent);
+  let aMagnitude = fp64_u64_shift_left(
+    vec2u(0u, a.significand),
+    u32(a.baseExponent - commonBaseExponent)
+  );
+  let bMagnitude = fp64_u64_shift_left(
+    vec2u(0u, b.significand),
+    u32(b.baseExponent - commonBaseExponent)
+  );
+
+  var resultSign = a.sign;
+  var resultMagnitude: vec2u;
+  if (a.sign == b.sign) {
+    resultMagnitude = fp64_u64_add(aMagnitude, bMagnitude);
+  } else {
+    let comparison = fp64_u64_compare(aMagnitude, bMagnitude);
+    if (comparison == 0) {
+      return vec2u(0u);
+    }
+    if (comparison > 0) {
+      resultMagnitude = fp64_u64_sub(aMagnitude, bMagnitude);
+    } else {
+      resultSign = b.sign;
+      resultMagnitude = fp64_u64_sub(bMagnitude, aMagnitude);
+    }
+  }
+
+  return fp64_split_raw_accumulator_bits(
+    resultSign,
+    resultMagnitude,
+    commonBaseExponent
+  );
+}
+#endif
+
+#ifndef LUMA_FP64_F32_INPUT_ONLY
+fn fp64_add_aligned_magnitudes_to_fp64_bits(
+  sign: u32,
+  larger: Fp64Bits,
+  smaller: Fp64Bits
+) -> vec2u {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);
+  return fp64_split_binary64_accumulator_bits(
+    sign,
+    resultSignificand,
+    larger.exponent - 55
+  );
+}
+
+fn fp64_sub_aligned_magnitudes_to_fp64_bits(
+  sign: u32,
+  larger: Fp64Bits,
+  smaller: Fp64Bits
+) -> vec2u {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);
+  return fp64_split_binary64_accumulator_bits(
+    sign,
+    resultSignificand,
+    larger.exponent - 55
+  );
+}
+
+fn fp64_add_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_add(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+fn fp64_sub_aligned_magnitudes_to_f32_bits(sign: u32, larger: Fp64Bits, smaller: Fp64Bits) -> u32 {
+  let largeSignificand = fp64_u64_shift_left(larger.significand, 3u);
+  let smallSignificand = fp64_u64_shift_right_sticky(
+    fp64_u64_shift_left(smaller.significand, 3u),
+    u32(larger.exponent - smaller.exponent)
+  );
+  let resultSignificand = fp64_u64_sub(largeSignificand, smallSignificand);
+  return fp64_make_f32_bits_from_u64(sign, resultSignificand, larger.exponent - 55);
+}
+
+// Subtract two raw binary64 values and round the exact result once to f32.
+// The input words are canonical high/low words: .x contains sign/exponent/high
+// fraction bits, and .y contains the low 32 fraction bits.
+fn sub_fp64u32_to_f32_bits(aBits: vec2u, bBits: vec2u) -> u32 {
+  let a = fp64_decode_bits(aBits);
+  let b = fp64_decode_bits(bBits);
+  let bSubtractionSign = b.sign ^ 1u;
+
+  if (a.isNan || b.isNan) {
+    return 0x7fc00000u;
+  }
+  if (a.isInf && b.isInf) {
+    if (a.sign == bSubtractionSign) {
+      return (a.sign << 31u) | 0x7f800000u;
+    }
+    return 0x7fc00000u;
+  }
+  if (a.isInf) {
+    return (a.sign << 31u) | 0x7f800000u;
+  }
+  if (b.isInf) {
+    return (bSubtractionSign << 31u) | 0x7f800000u;
+  }
+  if (a.isZero && b.isZero) {
+    return select(0u, 0x80000000u, a.sign == 1u && b.sign == 0u);
+  }
+
+  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);
+  if (a.sign == bSubtractionSign) {
+    if (magnitudeComparison >= 0) {
+      return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+    }
+    return fp64_add_aligned_magnitudes_to_f32_bits(a.sign, b, a);
+  }
+
+  if (magnitudeComparison == 0) {
+    return 0u;
+  }
+  if (magnitudeComparison > 0) {
+    return fp64_sub_aligned_magnitudes_to_f32_bits(a.sign, a, b);
+  }
+  return fp64_sub_aligned_magnitudes_to_f32_bits(bSubtractionSign, b, a);
+}
+
+fn sub_fp64u32_to_f32(aBits: vec2u, bBits: vec2u) -> f32 {
+  return bitcast<f32>(sub_fp64u32_to_f32_bits(aBits, bBits));
+}
+
+// Subtract two raw binary64 values, round once to binary64, then split the
+// result into normalized f32 limbs. Finite results must fit within the f32
+// exponent range; larger magnitudes map to infinity and smaller magnitudes
+// map to zero. The input words use canonical high/low word order.
+fn sub_fp64u32_to_fp64_bits(aBits: vec2u, bBits: vec2u) -> vec2u {
+  let a = fp64_decode_bits(aBits);
+  let b = fp64_decode_bits(bBits);
+  let bSubtractionSign = b.sign ^ 1u;
+
+  if (a.isNan || b.isNan) {
+    return vec2u(0x7fc00000u, 0u);
+  }
+  if (a.isInf && b.isInf) {
+    if (a.sign == bSubtractionSign) {
+      return vec2u((a.sign << 31u) | 0x7f800000u, 0u);
+    }
+    return vec2u(0x7fc00000u, 0u);
+  }
+  if (a.isInf) {
+    return vec2u((a.sign << 31u) | 0x7f800000u, 0u);
+  }
+  if (b.isInf) {
+    return vec2u((bSubtractionSign << 31u) | 0x7f800000u, 0u);
+  }
+  if (a.isZero && b.isZero) {
+    return vec2u(0u);
+  }
+
+  let magnitudeComparison = fp64_finite_magnitude_compare(a, b);
+  if (a.sign == bSubtractionSign) {
+    if (magnitudeComparison >= 0) {
+      return fp64_add_aligned_magnitudes_to_fp64_bits(a.sign, a, b);
+    }
+    return fp64_add_aligned_magnitudes_to_fp64_bits(a.sign, b, a);
+  }
+
+  if (magnitudeComparison == 0) {
+    return vec2u(0u);
+  }
+  if (magnitudeComparison > 0) {
+    return fp64_sub_aligned_magnitudes_to_fp64_bits(a.sign, a, b);
+  }
+  return fp64_sub_aligned_magnitudes_to_fp64_bits(bSubtractionSign, b, a);
+}
+
+fn sub_fp64u32_to_fp64(aBits: vec2u, bBits: vec2u) -> vec2f {
+  let resultBits = sub_fp64u32_to_fp64_bits(aBits, bBits);
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+#endif
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
 fn fp64_runtime_zero() -> f32 {
   return fp64arithmetic.ONE * 0.0;
 }
@@ -1699,7 +2755,11 @@ fn prevent_fp64_optimization(value: f32) -> f32 {
   return value;
 #endif
 }
+#endif
 
+#ifdef LUMA_FP64_INTEGER_ARITHMETIC
+${fp64arithmeticWGSLInteger}
+#else
 fn split(a: f32) -> vec2f {
   let splitValue = prevent_fp64_optimization(fp64arithmetic.SPLIT + fp64_runtime_zero());
   let t = prevent_fp64_optimization(a * splitValue);
@@ -1850,6 +2910,7 @@ fn mul_fp64(a: vec2f, b: vec2f) -> vec2f {
   return prod;
 }
 
+#ifndef LUMA_FP64_PREDICATE_ONLY
 fn div_fp64(a: vec2f, b: vec2f) -> vec2f {
   let xn = prevent_fp64_optimization(1.0 / b.x);
   let yn = mul_fp64(a, vec2f(xn, fp64_runtime_zero()));
@@ -1882,6 +2943,97 @@ fn sqrt_fp64(a: vec2f) -> vec2f {
   return sum_fp64(vec2f(yn, 0.0), prod);
 #endif
 }
+#endif
+#endif
+
+#ifndef LUMA_FP64_PREDICATE_ONLY
+fn fp64_f32_bits_is_nan(bits: u32) -> bool {
+  return (bits & 0x7fffffffu) > 0x7f800000u;
+}
+
+fn fp64_f32_bits_is_inf(bits: u32) -> bool {
+  return (bits & 0x7fffffffu) == 0x7f800000u;
+}
+
+fn fp64_compare_f32_bits(aBits: u32, bBits: u32) -> i32 {
+  let aMagnitude = aBits & 0x7fffffffu;
+  let bMagnitude = bBits & 0x7fffffffu;
+  if (aMagnitude == 0u && bMagnitude == 0u) {
+    return 0;
+  }
+  let aSign = aBits >> 31u;
+  let bSign = bBits >> 31u;
+  if (aSign != bSign) {
+    return select(1, -1, aSign == 1u);
+  }
+  if (aMagnitude == bMagnitude) {
+    return 0;
+  }
+  let magnitudeComparison = select(-1, 1, aMagnitude > bMagnitude);
+  return select(magnitudeComparison, -magnitudeComparison, aSign == 1u);
+}
+
+// Normalize an arbitrary pair of finite f32 limbs with integer accumulation.
+// This is independent of LUMA_FP64_INTEGER_ARITHMETIC and canonicalizes every
+// representation of zero to vec2f(+0.0, +0.0).
+fn normalize_fp64(value: vec2f) -> vec2f {
+  let resultBits = fp64_add_raw_f32_bits(bitcast<u32>(value.x), bitcast<u32>(value.y));
+  return vec2f(bitcast<f32>(resultBits.x), bitcast<f32>(resultBits.y));
+}
+
+fn is_nan_fp64(value: vec2f) -> bool {
+  let normalized = normalize_fp64(value);
+  return fp64_f32_bits_is_nan(bitcast<u32>(normalized.x)) ||
+    fp64_f32_bits_is_nan(bitcast<u32>(normalized.y));
+}
+
+fn is_finite_fp64(value: vec2f) -> bool {
+  let normalized = normalize_fp64(value);
+  let highBits = bitcast<u32>(normalized.x);
+  let lowBits = bitcast<u32>(normalized.y);
+  return !fp64_f32_bits_is_nan(highBits) && !fp64_f32_bits_is_nan(lowBits) &&
+    !fp64_f32_bits_is_inf(highBits) && !fp64_f32_bits_is_inf(lowBits);
+}
+
+// Returns -1, 0, or 1. NaN is unordered and returns 0; call is_nan_fp64 or
+// is_finite_fp64 first when 0 must mean a finite zero.
+fn sign_fp64(value: vec2f) -> i32 {
+  let normalized = normalize_fp64(value);
+  let highBits = bitcast<u32>(normalized.x);
+  let lowBits = bitcast<u32>(normalized.y);
+  if (fp64_f32_bits_is_nan(highBits) || fp64_f32_bits_is_nan(lowBits)) {
+    return 0;
+  }
+  if ((highBits & 0x7fffffffu) != 0u) {
+    return select(1, -1, (highBits >> 31u) == 1u);
+  }
+  if ((lowBits & 0x7fffffffu) != 0u) {
+    return select(1, -1, (lowBits >> 31u) == 1u);
+  }
+  return 0;
+}
+
+// Compares double-single values and returns -1, 0, or 1. NaN is unordered
+// and returns 0; callers that require equality semantics must first check
+// is_nan_fp64 or is_finite_fp64.
+fn compare_fp64(a: vec2f, b: vec2f) -> i32 {
+  let normalizedA = normalize_fp64(a);
+  let normalizedB = normalize_fp64(b);
+  let aHighBits = bitcast<u32>(normalizedA.x);
+  let aLowBits = bitcast<u32>(normalizedA.y);
+  let bHighBits = bitcast<u32>(normalizedB.x);
+  let bLowBits = bitcast<u32>(normalizedB.y);
+  if (fp64_f32_bits_is_nan(aHighBits) || fp64_f32_bits_is_nan(aLowBits) ||
+      fp64_f32_bits_is_nan(bHighBits) || fp64_f32_bits_is_nan(bLowBits)) {
+    return 0;
+  }
+  let highComparison = fp64_compare_f32_bits(aHighBits, bHighBits);
+  if (highComparison != 0) {
+    return highComparison;
+  }
+  return fp64_compare_f32_bits(aLowBits, bLowBits);
+}
+#endif
 `
   );
 
@@ -3512,6 +4664,9 @@ in vec2 clip_commonPosition;
         clipByInstance = Boolean(this.props.clipByInstance);
       }
       this.state.clipByInstance = clipByInstance;
+      if (this.context.device.type === "webgpu") {
+        return {};
+      }
       return clipByInstance ? {
         modules: [shaderModuleVs],
         inject: injectionVs
@@ -3536,6 +4691,10 @@ in vec2 clip_commonPosition;
           Math.max(corner0[1], corner1[1])
         ];
       }
+      if (this.context.device.type === "webgpu") {
+        clipProps.enabled = true;
+        clipProps.mode = this.state.clipByInstance ? "instance" : "geometry";
+      }
       this.setShaderModuleProps({ clip: clipProps });
     }
   };