Ext py

.github/workflows/ext.yaml

@@ -169,9 +169,6 @@ jobs:
       - name: Lint sseq_gui wasm
         run: make -C web_ext/sseq_gui lint-wasm
 
-      - name: Test worker panic handling
-        run: make -C web_ext/sseq_gui test-wasm-js
-
       - name: Build wasm
         run: make -C web_ext/sseq_gui wasm
 

ext/Cargo.toml

@@ -35,7 +35,9 @@ tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 
 zstd = { version = "0.13.3", optional = true }
 
-[target.'cfg(unix)'.dependencies]
+# Emscripten reports `target_family = "unix"` but lacks the signal APIs
+# (`pthread_sigmask`, …) that `ctrlc`/`nix` require, so exclude wasm targets.
+[target.'cfg(all(unix, not(target_arch = "wasm32")))'.dependencies]
 ctrlc = { version = "3", features = ["termination"] }
 
 [dev-dependencies]

ext/Makefile

@@ -11,10 +11,10 @@ test:
 
 lint:
 	cargo fmt --all -- --check
-	cargo clippy --workspace --no-default-features --profile test
-	cargo clippy --workspace --all-targets --profile test
-	cargo check --workspace --no-default-features --profile test
-	cargo check --workspace --all-targets --all-features --profile test
+	cargo clippy --workspace --no-default-features --profile test --fix
+	cargo clippy --workspace --all-targets --profile test --fix
+	cargo check --workspace --no-default-features --profile test --fix
+	cargo check --workspace --all-targets --all-features --profile test --fix
 
 docs:
 	# Prevent the cached crates.js from confusing the current run

ext/crates/algebra/src/algebra/adem_algebra.rs

@@ -16,7 +16,7 @@ use rustc_hash::FxHashMap as HashMap;
 #[cfg(doc)]
 use crate::algebra::SteenrodAlgebra;
 use crate::algebra::{
-    Algebra, Bialgebra, GeneratedAlgebra, UnstableAlgebra,
+    Algebra, Bialgebra, CoproductError, GeneratedAlgebra, UnstableAlgebra,
     combinatorics::{self, MAX_XI_TAU},
 };
 
@@ -1391,6 +1391,34 @@ impl Bialgebra for AdemAlgebra {
         }
     }
 
+    fn try_coproduct(
+        &self,
+        op_deg: i32,
+        op_idx: usize,
+    ) -> Result<Vec<(i32, usize, i32, usize)>, CoproductError> {
+        // Guards the `assert_eq!(op_deg % q, 0)` (generic) and `assert_eq!(op_idx, 0)`
+        // (p = 2) preconditions below, plus the out-of-range basis lookup, so
+        // `coproduct` never panics.
+        if op_deg < 0 {
+            return Err(CoproductError::OutOfRange);
+        }
+        self.compute_basis(op_deg);
+        if op_idx >= self.dimension(op_deg) {
+            return Err(CoproductError::OutOfRange);
+        }
+        if self.generic {
+            if op_deg != 1 {
+                let q = self.prime() * 2 - 2;
+                if !(op_deg as u32).is_multiple_of(q) {
+                    return Err(CoproductError::IndivisibleDegree { q, degree: op_deg });
+                }
+            }
+        } else if op_idx != 0 {
+            return Err(CoproductError::NonzeroIndex);
+        }
+        Ok(self.coproduct(op_deg, op_idx))
+    }
+
     fn coproduct(&self, op_deg: i32, op_idx: usize) -> Vec<(i32, usize, i32, usize)> {
         if self.generic {
             if op_deg == 1 {

ext/crates/algebra/src/algebra/algebra_trait.rs

@@ -494,6 +494,29 @@ impl<A: UnstableAlgebra> MuAlgebra<true> for A {
     }
 }
 
+/// Why [`GeneratedAlgebra::try_decompose_basis_element`] could not decompose a basis element.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DecomposeError {
+    /// `degree` is negative, or `idx` is not a valid basis index in that degree.
+    OutOfRange,
+    /// The basis element exists but has no decomposition: the degree-0 unit, or an
+    /// algebra generator.
+    Indecomposable,
+}
+
+impl std::fmt::Display for DecomposeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::OutOfRange => f.write_str("basis element index out of range"),
+            Self::Indecomposable => {
+                f.write_str("the unit and algebra generators are indecomposable")
+            }
+        }
+    }
+}
+
+impl std::error::Error for DecomposeError {}
+
 /// An [`Algebra`] equipped with a distinguished presentation.
 ///
 /// These data can be used to specify finite modules as the actions of the distinguished generators.
@@ -542,6 +565,33 @@ pub trait GeneratedAlgebra: Algebra {
         idx: usize,
     ) -> Vec<(u32, (i32, usize), (i32, usize))>;
 
+    /// Non-panicking variant of [`Self::decompose_basis_element`], distinguishing the two
+    /// reasons it can fail: [`DecomposeError::OutOfRange`] when `degree`/`idx` do not name a
+    /// basis element, and [`DecomposeError::Indecomposable`] when they name the degree-0 unit
+    /// or an algebra generator. Computes the basis up to `degree` first.
+    ///
+    /// These are exactly the inputs for which [`Self::decompose_basis_element`] is invalid and
+    /// would panic, so the delegation below never reaches the panicking path. An implementation
+    /// of [`Self::decompose_basis_element`] that can fail for other reasons should override both
+    /// that method and this one, keeping them consistent.
+    fn try_decompose_basis_element(
+        &self,
+        degree: i32,
+        idx: usize,
+    ) -> Result<Vec<(u32, (i32, usize), (i32, usize))>, DecomposeError> {
+        if degree < 0 {
+            return Err(DecomposeError::OutOfRange);
+        }
+        self.compute_basis(degree);
+        if idx >= self.dimension(degree) {
+            return Err(DecomposeError::OutOfRange);
+        }
+        if degree == 0 || self.generators(degree).contains(&idx) {
+            return Err(DecomposeError::Indecomposable);
+        }
+        Ok(self.decompose_basis_element(degree, idx))
+    }
+
     /// Returns relations that the algebra wants checked to ensure the consistency of module.
     ///
     /// Relations are encoded as general multi-degree elements which are killed in the quotient:

ext/crates/algebra/src/algebra/bialgebra_trait.rs

@@ -1,5 +1,42 @@
 use crate::algebra::Algebra;
 
+/// Why [`Bialgebra::try_coproduct`] could not compute a coproduct.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CoproductError {
+    /// `op_deg` is negative, or `op_idx` is not a valid basis index in that degree.
+    OutOfRange,
+    /// The Milnor coproduct is only implemented at the prime 2.
+    OddPrimeUnsupported,
+    /// The generic Adem coproduct is only defined when the degree is divisible by `q = 2p - 2`
+    /// (the degree-1 Bockstein aside).
+    IndivisibleDegree {
+        /// The modulus `q = 2p - 2` the degree must be divisible by.
+        q: u32,
+        /// The offending degree.
+        degree: i32,
+    },
+    /// The Adem coproduct at the prime 2 is only defined for index 0.
+    NonzeroIndex,
+}
+
+impl std::fmt::Display for CoproductError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::OutOfRange => f.write_str("basis element index out of range"),
+            Self::OddPrimeUnsupported => f.write_str("coproduct is only supported at p = 2"),
+            Self::IndivisibleDegree { q, degree } => {
+                write!(
+                    f,
+                    "coproduct expects a degree divisible by {q}, got {degree}"
+                )
+            }
+            Self::NonzeroIndex => f.write_str("at p = 2 the coproduct expects index 0"),
+        }
+    }
+}
+
+impl std::error::Error for CoproductError {}
+
 /// An [`Algebra`] equipped with a coproduct operation that makes it into a
 /// bialgebra.
 #[enum_dispatch::enum_dispatch]
@@ -13,6 +50,30 @@ pub trait Bialgebra: Algebra {
     /// `x` must have been returned by [`Bialgebra::decompose()`].
     fn coproduct(&self, op_deg: i32, op_idx: usize) -> Vec<(i32, usize, i32, usize)>;
 
+    /// Non-panicking variant of [`Self::coproduct`]. Computes the basis up to `op_deg` first and
+    /// returns [`CoproductError::OutOfRange`] when `op_deg`/`op_idx` do not name a basis element.
+    ///
+    /// This default only guards the out-of-range preconditions shared by every implementation, so
+    /// it is correct for [`Self::coproduct`] implementations that are total on valid basis
+    /// elements (such as [`crate::algebra::Field`]). Implementations whose `coproduct` is only
+    /// partially defined — e.g. [`crate::algebra::MilnorAlgebra`] (prime 2 only) and
+    /// [`crate::algebra::AdemAlgebra`] (degree/index restrictions) — override this method to guard
+    /// their extra preconditions, so the delegation below never reaches the panicking path.
+    fn try_coproduct(
+        &self,
+        op_deg: i32,
+        op_idx: usize,
+    ) -> Result<Vec<(i32, usize, i32, usize)>, CoproductError> {
+        if op_deg < 0 {
+            return Err(CoproductError::OutOfRange);
+        }
+        self.compute_basis(op_deg);
+        if op_idx >= self.dimension(op_deg) {
+            return Err(CoproductError::OutOfRange);
+        }
+        Ok(self.coproduct(op_deg, op_idx))
+    }
+
     /// Decomposes an element of the algebra into a product of elements, each of
     /// which we can compute a coproduct on efficiently.
     ///

ext/crates/algebra/src/algebra/milnor_algebra.rs

@@ -9,13 +9,15 @@ use once::OnceVec;
 use rustc_hash::FxHashMap as HashMap;
 use serde::{Deserialize, Serialize};
 
-use crate::algebra::{Algebra, Bialgebra, GeneratedAlgebra, UnstableAlgebra, combinatorics};
+use crate::algebra::{
+    Algebra, Bialgebra, CoproductError, GeneratedAlgebra, UnstableAlgebra, combinatorics,
+};
 
 fn q_part_default() -> u32 {
     !0
 }
 
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct MilnorProfile {
     /// If `true`, unspecified p_part entries will be 0. Otherwise they will be infinity.
     pub truncated: bool,
@@ -1722,6 +1724,26 @@ impl MilnorAlgebra {
 }
 
 impl Bialgebra for MilnorAlgebra {
+    fn try_coproduct(
+        &self,
+        op_deg: i32,
+        op_idx: usize,
+    ) -> Result<Vec<(i32, usize, i32, usize)>, CoproductError> {
+        // Guards the `assert_eq!(self.prime(), 2, ...)` below and the out-of-range
+        // `basis_element_from_index` lookup, so `coproduct` never panics.
+        if self.prime() != 2 {
+            return Err(CoproductError::OddPrimeUnsupported);
+        }
+        if op_deg < 0 {
+            return Err(CoproductError::OutOfRange);
+        }
+        self.compute_basis(op_deg);
+        if op_idx >= self.dimension(op_deg) {
+            return Err(CoproductError::OutOfRange);
+        }
+        Ok(self.coproduct(op_deg, op_idx))
+    }
+
     fn coproduct(&self, op_deg: i32, op_idx: usize) -> Vec<(i32, usize, i32, usize)> {
         assert_eq!(self.prime(), 2, "Coproduct at odd primes not supported");
         if op_deg == 0 {

ext/crates/algebra/src/algebra/mod.rs

@@ -5,10 +5,10 @@ pub mod adem_algebra;
 pub use adem_algebra::AdemAlgebra;
 
 mod algebra_trait;
-pub use algebra_trait::{Algebra, GeneratedAlgebra, MuAlgebra, UnstableAlgebra};
+pub use algebra_trait::{Algebra, DecomposeError, GeneratedAlgebra, MuAlgebra, UnstableAlgebra};
 
 mod bialgebra_trait;
-pub use bialgebra_trait::Bialgebra;
+pub use bialgebra_trait::{Bialgebra, CoproductError};
 
 pub mod combinatorics;
 

ext/crates/algebra/src/algebra/steenrod_algebra.rs

@@ -9,7 +9,10 @@ use serde::Deserialize;
 use serde_json::Value;
 
 use crate::{
-    algebra::{AdemAlgebra, Algebra, Bialgebra, GeneratedAlgebra, MilnorAlgebra, UnstableAlgebra},
+    algebra::{
+        AdemAlgebra, Algebra, Bialgebra, CoproductError, DecomposeError, GeneratedAlgebra,
+        MilnorAlgebra, UnstableAlgebra,
+    },
     pair_algebra::PairAlgebra,
 };
 

ext/crates/algebra/src/lib.rs

@@ -7,13 +7,13 @@
 
 pub mod module;
 pub mod steenrod_evaluator;
-pub(crate) mod steenrod_parser;
+pub mod steenrod_parser;
 
 mod algebra;
 
 pub use crate::algebra::*;
 
-pub(crate) fn module_gens_from_json(
+pub fn module_gens_from_json(
     gens: &serde_json::Value,
 ) -> (
     bivec::BiVec<usize>,