Reject integer/complex output on explicit jit_backend="js"

The explicit JS path bypassed the output-dtype check, so an integer/complex
output kernel would silently compute in float64 instead of failing. Raise a
clear ValueError up front (matching the documented "explicit js raises on
gaps" contract); integer inputs with a floating output still use JS. Keeps
integer output entirely on miniexpr. Add a test and update the coverage plan.

Author: FrancescAlted

plans/dsl-js-coverage.md

@@ -71,7 +71,9 @@ except Exception:
 ```
 
 With an **explicit** `jit_backend="js"`, the same gaps instead **raise** rather than fall
-back (the user asked for JS specifically, so we don't second-guess them).
+back (the user asked for JS specifically, so we don't second-guess them). This includes a
+non-floating *output* dtype: `_maybe_js_backend` raises a clear `ValueError` up front rather
+than letting the float64 bridge silently compute integer/complex output (see below).
 
 The JS backend today covers *float64/float32 element-wise scalar kernels* using arithmetic,
 `where`, comparisons, `if/elif/else`, `range` loops, and whitelisted math functions.

src/blosc2/lazyexpr.py

@@ -1510,6 +1510,14 @@ def _maybe_js_backend(expression, jit, jit_backend, reduce_args, operands, kwarg
     if jit_backend == "js":
         if reduce_args:
             raise ValueError('jit_backend="js" does not support reductions')
+        out_dtype = kwargs.get("dtype")
+        if out_dtype is not None and not np.issubdtype(np.dtype(out_dtype), np.floating):
+            # The JS bridge computes in float64 and cannot reproduce integer/complex output
+            # semantics (division/overflow/truncation); keep those on miniexpr.
+            raise ValueError(
+                'jit_backend="js" requires a floating-point output dtype '
+                f"(got {np.dtype(out_dtype)}); drop jit_backend to use miniexpr"
+            )
         return _as_js_udf(expression, shape), None, None
     prefer_js = (
         jit is not False  # jit=True/None prefer the best JIT (js); only jit=False forces interpreter

tests/ndarray/test_dsl_js.py

@@ -306,3 +306,13 @@ def test_explicit_js_off_wasm_raises():
     assert not blosc2.IS_WASM  # this test runs on a native build
     with pytest.raises(RuntimeError, match="WebAssembly"):
         lx._maybe_js_backend(_add, None, "js", {}, {}, {})
+
+
+def test_explicit_js_integer_output_raises():
+    # Integer/complex output is left to miniexpr; explicit jit_backend="js" must reject it
+    # (the float64 bridge can't reproduce integer semantics) rather than silently compute.
+    af = blosc2.asarray(np.ones((4, 4), dtype=np.float64))
+    with pytest.raises(ValueError, match="floating-point output"):
+        lx._maybe_js_backend(_add, None, "js", {}, {"a": af, "b": af}, {"dtype": np.int64})
+    with pytest.raises(ValueError, match="floating-point output"):
+        lx._maybe_js_backend(_add, None, "js", {}, {"a": af, "b": af}, {"dtype": np.complex128})