First batch of fixes

Author: FrancescAlted

plans/wasm32-todo.md

@@ -1,60 +1,53 @@
 # wasm32 TODO (priority focus)
 
+Last local validation: 2026-02-19 (Pyodide cp313, Emscripten-4.0.9-wasm32).
+
 Scope for this list:
 - DSL control-flow stability on wasm32 (runtime OOB risk).
 - miniexpr fast-path enablement/coverage on wasm32.
 
 ## P0: unblock core DSL JIT stability (runtime safety)
 
-1. Remove the unconditional Emscripten skip in the wasm smoke test.
-   - `tests/ndarray/test_wasm_dsl_jit.py:22`
-   - Current blocker: `tests/ndarray/test_wasm_dsl_jit.py:24` skips on Emscripten.
-   - Exit criteria: smoke runs and passes on Pyodide in CI (no skip).
+1. [x] Remove the unconditional Emscripten skip in the wasm smoke test.
+   - Target: `tests/ndarray/test_wasm_dsl_jit.py::test_wasm_dsl_tcc_jit_smoke`
+   - Result: skip removed, test now runs and passes on local Pyodide.
 
-2. Stabilize full-control-flow DSL kernels on wasm32.
-   - `tests/ndarray/test_dsl_kernels.py:350`
-   - Current reason: "full DSL control-flow kernel is unstable on wasm32 (can trigger runtime OOB)".
-   - Exit criteria: unskip and pass consistently.
+2. [x] Stabilize full-control-flow DSL kernels on wasm32.
+   - Target: `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_full_control_flow_kept_as_dsl_function`
+   - Result: skip removed, test now runs and passes on local Pyodide.
 
-3. Stabilize while-loop DSL kernels on wasm32.
-   - `tests/ndarray/test_dsl_kernels.py:376`
-   - Current reason: "while-loop DSL kernel is unstable on wasm32 (can trigger runtime OOB)".
-   - Exit criteria: unskip and pass consistently.
+3. [x] Stabilize while-loop DSL kernels on wasm32.
+   - Target: `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_while_kept_as_dsl_function`
+   - Result: skip removed, test now runs and passes on local Pyodide.
 
-4. Stabilize scalar-parameter loop DSL kernels on wasm32.
-   - `tests/ndarray/test_dsl_kernels.py:398`
-   - Current reason: "scalar-param DSL loop kernel is unstable on wasm32 (can trigger runtime OOB)".
-   - Exit criteria: unskip and pass consistently.
+4. [x] Stabilize scalar-parameter loop DSL kernels on wasm32.
+   - Target: `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_accepts_scalar_param_per_call`
+   - Result: skip removed, test now runs and passes on local Pyodide.
 
 ## P1: recover miniexpr fast-path coverage on wasm32
 
-5. Re-enable DSL miniexpr fast-path instrumentation tests.
-   - `tests/ndarray/test_dsl_kernels.py:202`
-   - `tests/ndarray/test_dsl_kernels.py:259`
-   - `tests/ndarray/test_dsl_kernels.py:284`
-   - `tests/ndarray/test_dsl_kernels.py:422`
-   - `tests/ndarray/test_dsl_kernels.py:467`
-   - `tests/ndarray/test_dsl_kernels.py:505`
-   - `tests/ndarray/test_dsl_kernels.py:531`
-   - Current reason: "miniexpr fast path is not available on WASM".
-   - Exit criteria: tests run (no skip) and validate `_set_pref_expr`/policy behavior on wasm.
-
-6. Re-enable lazyexpr miniexpr fast-path behavior tests on wasm32.
-   - `tests/ndarray/test_lazyexpr.py:1488`
-   - `tests/ndarray/test_lazyexpr.py:1523`
-   - `tests/ndarray/test_lazyexpr.py:1559`
-   - `tests/ndarray/test_lazyexpr.py:1582`
-   - Current reason: "miniexpr fast path is not available on WASM".
-   - Exit criteria: tests run (no skip), fallback/strict semantics match non-wasm expectations.
-
-7. Revisit int-cast DSL behavior currently expected to fail on wasm.
-   - `tests/ndarray/test_dsl_kernels.py:312`
-   - Current behavior on wasm: expects `RuntimeError("DSL kernels require miniexpr")`.
-   - Exit criteria: either (a) supported and validated, or (b) explicitly documented as out-of-scope with rationale.
-
-## Suggested validation order
-
-1. `tests/ndarray/test_wasm_dsl_jit.py`
-2. `tests/ndarray/test_dsl_kernels.py -k "control_flow or while or scalar_param"`
-3. `tests/ndarray/test_dsl_kernels.py -k "miniexpr_fast_path or jit_policy_forwarding"`
-4. `tests/ndarray/test_lazyexpr.py -k "miniexpr_fast_path or strict_miniexpr or unary_negative_literal"`
+5. [x] Re-enable DSL miniexpr fast-path instrumentation tests.
+   - Targets:
+     - `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_index_symbols_keep_full_kernel`
+     - `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_with_no_inputs_handles_windows_dtype_policy`
+     - `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_index_symbols_float_cast_uses_miniexpr_fast_path`
+     - `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_scalar_param_keeps_miniexpr_fast_path`
+     - `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_scalar_float_cast_inlined_without_float_call`
+     - `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_miniexpr_failure_raises_even_with_strict_disabled`
+     - `tests/ndarray/test_dsl_kernels.py::test_lazyudf_jit_policy_forwarding`
+   - Result: wasm skips removed and tests pass on local Pyodide.
+
+6. [x] Re-enable lazyexpr miniexpr fast-path behavior tests on wasm32.
+   - Targets:
+     - `tests/ndarray/test_lazyexpr.py::test_lazyexpr_string_scalar_keeps_miniexpr_fast_path`
+     - `tests/ndarray/test_lazyexpr.py::test_lazyexpr_unary_negative_literal_matches_subtraction`
+     - `tests/ndarray/test_lazyexpr.py::test_lazyexpr_miniexpr_failure_falls_back_by_default`
+     - `tests/ndarray/test_lazyexpr.py::test_lazyexpr_miniexpr_failure_raises_when_strict`
+   - Fix applied: removed wasm-only non-DSL miniexpr gate in `src/blosc2/lazyexpr.py` (`fast_eval`).
+   - Result: skips removed and all four tests pass on local Pyodide.
+
+7. [ ] Revisit int-cast DSL behavior currently expected to fail on wasm.
+   - Target: `tests/ndarray/test_dsl_kernels.py::test_dsl_kernel_index_symbols_int_cast_matches_expected_ramp`
+   - Current local behavior (still expected): raises `RuntimeError` on wasm (`DSL kernels require miniexpr ... miniexpr compilation or execution failed`).
+   - Rationale for keeping open: int-cast DSL/miniexpr on wasm remains unsupported in current runtime/backend.
+   - Exit criteria: either (a) support `int(...)` casts in wasm miniexpr path, or (b) keep explicit unsupported policy with doc note.

src/blosc2/lazyexpr.py

@@ -1334,10 +1334,6 @@ def fast_eval(  # noqa: C901
     expr_string = expression.dsl_source if is_dsl else expression
     dsl_disable_reason = None
 
-    if blosc2.IS_WASM and not is_dsl:
-        # Keep wasm miniexpr scoped to DSL kernels until generic lazyexpr miniexpr paths are stabilized.
-        use_miniexpr = False
-
     # Disable miniexpr for UDFs (callable expressions), except DSL kernels
     if callable(expression) and not is_dsl:
         use_miniexpr = False

tests/ndarray/test_dsl_kernels.py

@@ -200,9 +200,6 @@ def test_dsl_kernel_integer_ops_kept_as_full_dsl_function():
 
 
 def test_dsl_kernel_index_symbols_keep_full_kernel(monkeypatch):
-    if blosc2.IS_WASM:
-        pytest.skip("miniexpr fast path is not available on WASM")
-
     assert kernel_index_ramp.dsl_source is not None
     assert "def kernel_index_ramp(x):" in kernel_index_ramp.dsl_source
 
@@ -257,9 +254,6 @@ def test_dsl_kernel_with_no_inputs_requires_shape_or_out():
 
 
 def test_dsl_kernel_with_no_inputs_handles_windows_dtype_policy(monkeypatch):
-    if blosc2.IS_WASM:
-        pytest.skip("miniexpr fast path is not available on WASM")
-
     import importlib
 
     lazyexpr_mod = importlib.import_module("blosc2.lazyexpr")
@@ -282,9 +276,6 @@ def test_dsl_kernel_index_symbols_float_cast_matches_expected_ramp():
 
 
 def test_dsl_kernel_index_symbols_float_cast_uses_miniexpr_fast_path(monkeypatch):
-    if blosc2.IS_WASM:
-        pytest.skip("miniexpr fast path is not available on WASM")
-
     original_set_pref_expr = blosc2.NDArray._set_pref_expr
     captured = {"calls": 0, "expr": None}
 
@@ -348,9 +339,6 @@ def test_dsl_kernel_bool_cast_numeric_matches_expected():
 
 
 def test_dsl_kernel_full_control_flow_kept_as_dsl_function():
-    if blosc2.IS_WASM:
-        pytest.skip("full DSL control-flow kernel is unstable on wasm32 (can trigger runtime OOB)")
-
     assert kernel_control_flow_full.dsl_source is not None
     assert "def kernel_control_flow_full(x, y):" in kernel_control_flow_full.dsl_source
     assert "for i in range(4):" in kernel_control_flow_full.dsl_source
@@ -374,9 +362,6 @@ def test_dsl_kernel_full_control_flow_kept_as_dsl_function():
 
 
 def test_dsl_kernel_while_kept_as_dsl_function():
-    if blosc2.IS_WASM:
-        pytest.skip("while-loop DSL kernel is unstable on wasm32 (can trigger runtime OOB)")
-
     assert kernel_while_full.dsl_source is not None
     assert "def kernel_while_full(x, y):" in kernel_while_full.dsl_source
     assert "while i < 3:" in kernel_while_full.dsl_source
@@ -396,9 +381,6 @@ def test_dsl_kernel_while_kept_as_dsl_function():
 
 
 def test_dsl_kernel_accepts_scalar_param_per_call():
-    if blosc2.IS_WASM:
-        pytest.skip("scalar-param DSL loop kernel is unstable on wasm32 (can trigger runtime OOB)")
-
     assert kernel_loop_param.dsl_source is not None
     assert "def kernel_loop_param(x, y, niter):" in kernel_loop_param.dsl_source
     assert "for _i in range(niter):" in kernel_loop_param.dsl_source
@@ -420,9 +402,6 @@ def test_dsl_kernel_accepts_scalar_param_per_call():
 
 
 def test_dsl_kernel_scalar_param_keeps_miniexpr_fast_path(monkeypatch):
-    if blosc2.IS_WASM:
-        pytest.skip("miniexpr fast path is not available on WASM")
-
     import importlib
 
     lazyexpr_mod = importlib.import_module("blosc2.lazyexpr")
@@ -465,9 +444,6 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
 
 
 def test_dsl_kernel_scalar_float_cast_inlined_without_float_call(monkeypatch):
-    if blosc2.IS_WASM:
-        pytest.skip("miniexpr fast path is not available on WASM")
-
     import importlib
 
     lazyexpr_mod = importlib.import_module("blosc2.lazyexpr")
@@ -503,9 +479,6 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
 
 
 def test_dsl_kernel_miniexpr_failure_raises_even_with_strict_disabled(monkeypatch):
-    if blosc2.IS_WASM:
-        pytest.skip("miniexpr fast path is not available on WASM")
-
     import importlib
 
     lazyexpr_mod = importlib.import_module("blosc2.lazyexpr")
@@ -529,9 +502,6 @@ def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
 
 
 def test_lazyudf_jit_policy_forwarding(monkeypatch):
-    if blosc2.IS_WASM:
-        pytest.skip("miniexpr fast path is not available on WASM")
-
     import importlib
 
     lazyexpr_mod = importlib.import_module("blosc2.lazyexpr")

tests/ndarray/test_lazyexpr.py

@@ -1484,7 +1484,6 @@ def test_numpy_funcs(array_fixture, func):
         pytest.skip("NumPy version has no cumulative_sum function.")
 
 
-@pytest.mark.skipif(blosc2.IS_WASM, reason="miniexpr fast path is not available on WASM")
 def test_lazyexpr_string_scalar_keeps_miniexpr_fast_path(monkeypatch):
     import importlib
 
@@ -1519,7 +1518,6 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
         lazyexpr_mod.try_miniexpr = old_try_miniexpr
 
 
-@pytest.mark.skipif(blosc2.IS_WASM, reason="miniexpr fast path is not available on WASM")
 def test_lazyexpr_unary_negative_literal_matches_subtraction(monkeypatch):
     import importlib
 
@@ -1555,7 +1553,6 @@ def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
         lazyexpr_mod.try_miniexpr = old_try_miniexpr
 
 
-@pytest.mark.skipif(blosc2.IS_WASM, reason="miniexpr fast path is not available on WASM")
 def test_lazyexpr_miniexpr_failure_falls_back_by_default(monkeypatch):
     import importlib
 
@@ -1578,7 +1575,6 @@ def failing_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None,
         lazyexpr_mod.try_miniexpr = old_try_miniexpr
 
 
-@pytest.mark.skipif(blosc2.IS_WASM, reason="miniexpr fast path is not available on WASM")
 def test_lazyexpr_miniexpr_failure_raises_when_strict(monkeypatch):
     import importlib
 

tests/ndarray/test_wasm_dsl_jit.py

@@ -5,8 +5,6 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #######################################################################
 
-import platform
-
 import numpy as np
 import pytest
 
@@ -20,9 +18,6 @@ def _wasm_kernel(x, y):
 
 @pytest.mark.skipif(not blosc2.IS_WASM, reason="WASM-only integration test")
 def test_wasm_dsl_tcc_jit_smoke():
-    if platform.system() == "Emscripten":
-        pytest.skip("Known unstable path on current Pyodide runtime (can trigger wasm OOB)")
-
     assert getattr(blosc2, "_WASM_MINIEXPR_ENABLED", False)
 
     a_np = np.linspace(-1.0, 1.0, 64, dtype=np.float64).reshape(8, 8)