diff --git a/include/behaviortree_cpp/scripting/operators.hpp b/include/behaviortree_cpp/scripting/operators.hpp
index 483bc7f4d..28f5065eb 100644
--- a/include/behaviortree_cpp/scripting/operators.hpp
+++ b/include/behaviortree_cpp/scripting/operators.hpp
@@ -15,9 +15,18 @@
 #include "behaviortree_cpp/scripting/any_types.hpp"
 #include "behaviortree_cpp/scripting/script_parser.hpp"
 
+#include <cctype>
+#include <charconv>
 #include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <limits>
+#include <locale>
 #include <memory>
+#include <optional>
+#include <sstream>
 #include <string>
+#include <string_view>
 #include <vector>
 
 // Naive implementation of an AST with simple evaluation function.
@@ -27,6 +36,279 @@ using SimpleString = SafeAny::SimpleString;
 
 using expr_ptr = std::shared_ptr<struct ExprBase>;
 
+namespace detail
+{
+// 2^53: every integer up to here is exact as a double.
+constexpr double kMaxExactDouble =
+    static_cast<double>(int64_t{ 1 } << std::numeric_limits<double>::digits);
+
+inline std::string_view TrimSpaces(std::string_view str)
+{
+  const auto is_space = [](char c) {
+    return std::isspace(static_cast<unsigned char>(c)) != 0;
+  };
+  while(!str.empty() && is_space(str.front()))
+  {
+    str.remove_prefix(1);
+  }
+  while(!str.empty() && is_space(str.back()))
+  {
+    str.remove_suffix(1);
+  }
+  return str;
+}
+
+// Whether str spells a decimal number: digits, an optional leading '-', one '.', and an
+// exponent whose sign may be '+'. Checked before parsing so every standard library rejects the
+// same strings ("0x10", "nan", "+5").
+inline bool IsDecimalNumberText(std::string_view str)
+{
+  bool digit_seen = false;
+  bool dot_seen = false;
+  bool exponent_seen = false;
+  for(size_t i = 0; i < str.size(); ++i)
+  {
+    const char c = str[i];
+    const bool after_exponent = i > 0 && (str[i - 1] == 'e' || str[i - 1] == 'E');
+    if(std::isdigit(static_cast<unsigned char>(c)) != 0)
+    {
+      digit_seen = true;
+    }
+    else if(c == '-' && (i == 0 || after_exponent))
+    {
+    }
+    else if(c == '+' && after_exponent)
+    {
+    }
+    else if(c == '.' && !dot_seen && !exponent_seen)
+    {
+      dot_seen = true;
+    }
+    else if((c == 'e' || c == 'E') && digit_seen && !exponent_seen)
+    {
+      exponent_seen = true;
+      digit_seen = false;
+    }
+    else
+    {
+      return false;
+    }
+  }
+  return digit_seen;
+}
+
+// Locale-independent parsing for standard libraries without floating-point std::from_chars.
+inline std::optional<double> StreamParseNumber(std::string_view str)
+{
+  double out = 0;
+  std::istringstream stream{ std::string(str) };
+  stream.imbue(std::locale::classic());
+  stream >> out;
+  if(stream.fail() || stream.peek() != std::char_traits<char>::eof())
+  {
+    return std::nullopt;
+  }
+  return out;
+}
+
+// Locale-independent shortest %g form that reads back exactly.
+inline std::string StreamFormatNumber(double number)
+{
+  std::string text;
+  for(int precision = std::numeric_limits<double>::digits10;
+      precision <= std::numeric_limits<double>::max_digits10; ++precision)
+  {
+    std::ostringstream stream;
+    stream.imbue(std::locale::classic());
+    stream << std::setprecision(precision) << number;
+    text = stream.str();
+    if(StreamParseNumber(text) == number)
+    {
+      break;
+    }
+  }
+  return text;
+}
+
+// The number a string holds, if all of it apart from surrounding spaces is a finite decimal
+// number: "12", " 5 " and "-1.5e3" are numbers; "3 apples", "+5", "0x10", "nan" and "" are
+// not. Any::stringToNumber accepts a numeric prefix, so scripts don't use it.
+inline std::optional<double> ParseWholeNumber(std::string_view text)
+{
+  const auto str = TrimSpaces(text);
+  if(!IsDecimalNumberText(str))
+  {
+    return std::nullopt;
+  }
+  double out = 0;
+#if __cpp_lib_to_chars >= 201611L
+  const char* end = str.data() + str.size();
+  const auto [ptr, err] = std::from_chars(str.data(), end, out);
+  if(err != std::errc() || ptr != end)
+  {
+    return std::nullopt;
+  }
+#else
+  if(auto parsed = StreamParseNumber(str))
+  {
+    out = *parsed;
+  }
+  else
+  {
+    return std::nullopt;
+  }
+#endif
+  if(!std::isfinite(out))
+  {
+    return std::nullopt;
+  }
+  // Too small for a double: reject it on every standard library, as from_chars does.
+  const auto mantissa = str.substr(0, str.find_first_of("eE"));
+  if(out == 0 && mantissa.find_first_of("123456789") != std::string_view::npos)
+  {
+    return std::nullopt;
+  }
+  return out;
+}
+
+// An integer string parsed exactly, so values above 2^53 keep every digit.
+inline std::optional<int64_t> ParseWholeInteger(std::string_view text)
+{
+  const auto str = TrimSpaces(text);
+  int64_t out = 0;
+  const char* end = str.data() + str.size();
+  const auto [ptr, err] = std::from_chars(str.data(), end, out);
+  if(str.empty() || err != std::errc() || ptr != end)
+  {
+    return std::nullopt;
+  }
+  return out;
+}
+
+// The number a string holds for arithmetic. Integer text beyond 2^53 is an error, as it is for
+// an int64 entry, because a double would silently round it.
+inline std::optional<double> ArithmeticString(std::string_view text)
+{
+  const auto number = ParseWholeNumber(text);
+  const auto str = TrimSpaces(text);
+  if(number && str.find_first_not_of("-0123456789") == std::string_view::npos)
+  {
+    // Checked on the exact integer: the double has already rounded it.
+    constexpr auto kMaxExactInteger = static_cast<int64_t>(kMaxExactDouble);
+    const auto exact = ParseWholeInteger(str);
+    if(!exact || *exact > kMaxExactInteger || *exact < -kMaxExactInteger)
+    {
+      throw RuntimeError(StrCat("Number ['", std::string(str),
+                                "'] is too large to compute with exactly"));
+    }
+  }
+  return number;
+}
+
+inline std::string_view StringView(const SimpleString& str)
+{
+  return { str.data(), str.size() };
+}
+
+inline std::string ShownOperand(const Any& operand)
+{
+  return operand.isString() ? StrCat("'", operand.cast<std::string>(), "'") :
+                              demangle(operand.type());
+}
+
+inline std::string NotANumberError(const Any& operand, const char* op_str)
+{
+  auto msg = StrCat("Operand [", ShownOperand(operand), "] of operator [", op_str,
+                    "] is not a number");
+  if(std::string_view(op_str) == "+" || std::string_view(op_str) == "+=")
+  {
+    msg += ". Use [..] to join a string with a number";
+  }
+  return msg;
+}
+
+// A number as a double, reported as a script error when a double can't hold it exactly
+// (for example an int64 above 2^53).
+inline double NumberToDouble(const Any& value)
+{
+  try
+  {
+    return value.cast<double>();
+  }
+  catch(const std::exception& err)
+  {
+    throw RuntimeError(err.what());
+  }
+}
+
+// The value of an arithmetic operand: a number, or a string that is entirely a number.
+inline std::optional<double> ArithmeticOperand(const Any& value)
+{
+  if(value.isString())
+  {
+    return ArithmeticString(StringView(value.cast<SimpleString>()));
+  }
+  if(value.isNumber())
+  {
+    return NumberToDouble(value);
+  }
+  if(auto number = value.tryCast<double>())
+  {
+    return number.value();
+  }
+  return std::nullopt;
+}
+
+// The value of a bitwise operand as an exact integer.
+inline int64_t BitwiseOperand(const Any& value, const char* op_str)
+{
+  try
+  {
+    if(value.isString())
+    {
+      const auto owned = value.cast<SimpleString>();
+      const auto str = StringView(owned);
+      if(auto exact = ParseWholeInteger(str))
+      {
+        return *exact;
+      }
+      if(auto number = ParseWholeNumber(str);
+         number && std::abs(*number) <= kMaxExactDouble)
+      {
+        return Any(*number).cast<int64_t>();
+      }
+    }
+    else if(value.isNumber())
+    {
+      return value.cast<int64_t>();
+    }
+  }
+  catch(const std::exception&)
+  {
+    throw RuntimeError("Binary operators are not allowed if "
+                       "one of the operands is not an integer");
+  }
+  throw RuntimeError(NotANumberError(value, op_str));
+}
+
+// A string or number as `..` joins it. Whole doubles print as integers ("2", not "2.000000")
+// up to 2^53; other doubles in the shortest %g form that reads back exactly ("0.0001"), the
+// same on every standard library.
+inline std::string ConcatOperandString(const Any& value)
+{
+  if(value.castedType() != typeid(double))
+  {
+    return value.cast<std::string>();
+  }
+  const auto number = value.cast<double>();
+  if(std::trunc(number) == number && std::abs(number) <= kMaxExactDouble)
+  {
+    return std::to_string(static_cast<int64_t>(number));
+  }
+  return StreamFormatNumber(number);
+}
+}  // namespace detail
+
 // extended string to number that consider enums and booleans
 inline double StringToDouble(const Any& value, const Environment& env)
 {
@@ -47,7 +329,11 @@ inline double StringToDouble(const Any& value, const Environment& env)
       return it->second;
     }
   }
-  return value.cast<double>();
+  if(auto number = detail::ArithmeticString(str))
+  {
+    return *number;
+  }
+  throw RuntimeError(StrCat("String ['", str, "'] is not a number"));
 }
 
 struct ExprBase
@@ -121,9 +407,25 @@ struct ExprUnaryArithmetic : ExprBase
   Any evaluate(Environment& env) const override
   {
     auto rhs_v = rhs->evaluate(env);
+    if(op == complement && (rhs_v.isString() || rhs_v.isIntegral()))
+    {
+      return Any(static_cast<double>(~detail::BitwiseOperand(rhs_v, "~")));
+    }
+    if(rhs_v.isString())
+    {
+      // A numeric string, for example from a SubTree port, takes part as the number it holds.
+      const auto number =
+          detail::ArithmeticString(detail::StringView(rhs_v.cast<SimpleString>()));
+      if(!number)
+      {
+        throw RuntimeError(StrCat("Operand [", detail::ShownOperand(rhs_v),
+                                  "] of a unary operator is not a number"));
+      }
+      rhs_v = Any(*number);
+    }
     if(rhs_v.isNumber())
     {
-      const double rv = rhs_v.cast<double>();
+      const double rv = detail::NumberToDouble(rhs_v);
       switch(op)
       {
         case negate:
@@ -139,10 +441,6 @@ struct ExprUnaryArithmetic : ExprBase
           return Any(static_cast<double>(!static_cast<bool>(rv)));
       }
     }
-    else if(rhs_v.isString())
-    {
-      throw RuntimeError("Invalid operator for std::string");
-    }
     throw RuntimeError("ExprUnaryArithmetic: undefined");
   }
 };
@@ -213,93 +511,87 @@ struct ExprBinaryArithmetic : ExprBase
       throw RuntimeError(ErrorNotInit("right", opStr()));
     }
 
-    // If just one value is strongly typed as a number, and the other can be casted to one, do arithmetic. If both are not strongly typed, continue. In the case of `+`, non-strongly typed values will result in concatenation.
-    bool are_numbers = (rhs_v.isNumber() && lhs_v.isNumber()) ||
-                       ((rhs_v.tryCast<double>().has_value() && lhs_v.isNumber()) !=
-                        (rhs_v.isNumber() && lhs_v.tryCast<double>().has_value()));
-    if(are_numbers)
+    if(op == concat)
     {
-      auto lv = lhs_v.cast<double>();
-      auto rv = rhs_v.cast<double>();
-
-      switch(op)
+      if((lhs_v.isString() || lhs_v.isNumber()) && (rhs_v.isString() || rhs_v.isNumber()))
       {
-        case plus:
-          return Any(lv + rv);
-        case minus:
-          return Any(lv - rv);
-        case times:
-          return Any(lv * rv);
-        case div:
-          return Any(lv / rv);
-        default: {
-        }
+        return Any(detail::ConcatOperandString(lhs_v) +
+                   detail::ConcatOperandString(rhs_v));
       }
+      const auto& bad = (lhs_v.isString() || lhs_v.isNumber()) ? rhs_v : lhs_v;
+      throw RuntimeError(StrCat("Operand [", detail::ShownOperand(bad),
+                                "] of operator [..] is neither a string nor a number"));
+    }
 
-      if(op == bit_and || op == bit_or || op == bit_xor)
-      {
-        try
-        {
-          int64_t li = lhs_v.cast<int64_t>();
-          int64_t ri = rhs_v.cast<int64_t>();
-          switch(op)
-          {
-            case bit_and:
-              return Any(static_cast<double>(li & ri));
-            case bit_or:
-              return Any(static_cast<double>(li | ri));
-            case bit_xor:
-              return Any(static_cast<double>(li ^ ri));
-            default: {
-            }
-          }
-        }
-        catch(...)
-        {
-          throw RuntimeError("Binary operators are not allowed if "
-                             "one of the operands is not an integer");
-        }
-      }
+    // `+` joins two strings until PickNikRobotics/moveit_pro#24181 removes it.
+    if(op == plus && lhs_v.isString() && rhs_v.isString())
+    {
+      return Any(lhs_v.cast<std::string>() + rhs_v.cast<std::string>());
+    }
 
-      if(op == logic_or || op == logic_and)
+    if(op == bit_and || op == bit_or || op == bit_xor)
+    {
+      const int64_t li = detail::BitwiseOperand(lhs_v, opStr());
+      const int64_t ri = detail::BitwiseOperand(rhs_v, opStr());
+      switch(op)
       {
-        try
-        {
-          auto lb = lhs_v.cast<bool>();
-          auto rb = rhs_v.cast<bool>();
-          switch(op)
-          {
-            case logic_or:
-              return Any(static_cast<double>(lb || rb));
-            case logic_and:
-              return Any(static_cast<double>(lb && rb));
-            default: {
-            }
-          }
-        }
-        catch(...)
-        {
-          throw RuntimeError("Logic operators are not allowed if "
-                             "one of the operands is not castable to bool");
-        }
+        case bit_and:
+          return Any(static_cast<double>(li & ri));
+        case bit_or:
+          return Any(static_cast<double>(li | ri));
+        default:
+          return Any(static_cast<double>(li ^ ri));
       }
     }
-    else if(rhs_v.isString() && lhs_v.isString() && op == plus)
+
+    const auto lv = detail::ArithmeticOperand(lhs_v);
+    if(!lv)
     {
-      return Any(lhs_v.cast<std::string>() + rhs_v.cast<std::string>());
+      throw RuntimeError(detail::NotANumberError(lhs_v, opStr()));
     }
-    else if(op == concat && ((rhs_v.isString() && lhs_v.isString()) ||
-                             (rhs_v.isString() && lhs_v.isNumber()) ||
-                             (rhs_v.isNumber() && lhs_v.isString())))
+    const auto rv = detail::ArithmeticOperand(rhs_v);
+    if(!rv)
     {
-      return Any(lhs_v.cast<std::string>() + rhs_v.cast<std::string>());
+      throw RuntimeError(detail::NotANumberError(rhs_v, opStr()));
     }
-    else
+    switch(op)
     {
-      throw RuntimeError("Operation not permitted");
+      case plus:
+        return Any(*lv + *rv);
+      case minus:
+        return Any(*lv - *rv);
+      case times:
+        return Any(*lv * *rv);
+      case div:
+        return Any(*lv / *rv);
+      default: {
+      }
+    }
+
+    if(op == logic_or || op == logic_and)
+    {
+      try
+      {
+        auto lb = (lhs_v.isNumber() ? lhs_v : Any(*lv)).cast<bool>();
+        auto rb = (rhs_v.isNumber() ? rhs_v : Any(*rv)).cast<bool>();
+        switch(op)
+        {
+          case logic_or:
+            return Any(static_cast<double>(lb || rb));
+          case logic_and:
+            return Any(static_cast<double>(lb && rb));
+          default: {
+          }
+        }
+      }
+      catch(...)
+      {
+        throw RuntimeError("Logic operators are not allowed if "
+                           "one of the operands is not castable to bool");
+      }
     }
 
-    return {};  // unreachable
+    throw RuntimeError("Operation not permitted");
   }
 };
 
@@ -402,8 +694,8 @@ struct ExprComparison : ExprBase
 
       if(lhs_v.isNumber() && rhs_v.isNumber())
       {
-        auto lv = lhs_v.cast<double>();
-        auto rv = rhs_v.cast<double>();
+        auto lv = detail::NumberToDouble(lhs_v);
+        auto rv = detail::NumberToDouble(rhs_v);
         if(!SwitchImpl(lv, rv, ops[i]))
         {
           return False;
@@ -413,7 +705,37 @@ struct ExprComparison : ExprBase
       {
         auto lv = lhs_v.cast<SimpleString>();
         auto rv = rhs_v.cast<SimpleString>();
-        if(!SwitchImpl(lv, rv, ops[i]))
+        // Two strings that are both numbers, for example from SubTree ports, compare as numbers,
+        // exactly: integers as int64, others as long double, which IsSame compares without the
+        // tolerance it applies to double. Strings compare as text only if one isn't a number.
+        const auto lview = detail::StringView(lv);
+        const auto rview = detail::StringView(rv);
+        const auto li = detail::ParseWholeInteger(lview);
+        const auto ri = detail::ParseWholeInteger(rview);
+        const auto ln = detail::ParseWholeNumber(lview);
+        const auto rn = detail::ParseWholeNumber(rview);
+        bool holds = false;
+        if(li && ri)
+        {
+          holds = SwitchImpl(*li, *ri, ops[i]);
+        }
+        else if(ln && rn && std::abs(*ln) <= detail::kMaxExactDouble &&
+                std::abs(*rn) <= detail::kMaxExactDouble)
+        {
+          holds = SwitchImpl(static_cast<long double>(*ln), static_cast<long double>(*rn),
+                             ops[i]);
+        }
+        else if(ln && rn)
+        {
+          throw RuntimeError(StrCat("Numbers ['", lv.toStdString(), "'] and ['",
+                                    rv.toStdString(),
+                                    "'] are too large to compare exactly"));
+        }
+        else
+        {
+          holds = SwitchImpl(lv, rv, ops[i]);
+        }
+        if(!holds)
         {
           return False;
         }
@@ -421,7 +743,7 @@ struct ExprComparison : ExprBase
       else if(lhs_v.isString() && rhs_v.isNumber())
       {
         auto lv = StringToDouble(lhs_v, env);
-        auto rv = rhs_v.cast<double>();
+        auto rv = detail::NumberToDouble(rhs_v);
         if(!SwitchImpl(lv, rv, ops[i]))
         {
           return False;
@@ -429,7 +751,7 @@ struct ExprComparison : ExprBase
       }
       else if(lhs_v.isNumber() && rhs_v.isString())
       {
-        auto lv = lhs_v.cast<double>();
+        auto lv = detail::NumberToDouble(lhs_v);
         auto rv = StringToDouble(rhs_v, env);
         if(!SwitchImpl(lv, rv, ops[i]))
         {
@@ -460,9 +782,23 @@ struct ExprIf : ExprBase
   Any evaluate(Environment& env) const override
   {
     const auto& v = condition->evaluate(env);
-    bool valid = (v.isType<SimpleString>() && v.cast<SimpleString>().size() > 0) ||
-                 (v.cast<double>() != 0.0);
-    if(valid)
+    double number = 0;
+    if(v.isString())
+    {
+      const auto parsed =
+          detail::ArithmeticString(detail::StringView(v.cast<SimpleString>()));
+      if(!parsed)
+      {
+        throw RuntimeError(
+            StrCat("Condition [", detail::ShownOperand(v), "] of [?:] is not a number"));
+      }
+      number = *parsed;
+    }
+    else
+    {
+      number = detail::NumberToDouble(v);
+    }
+    if(number != 0.0)
     {
       return then->evaluate(env);
     }
@@ -580,7 +916,15 @@ struct ExprAssignment : ExprBase
         }
         else if(dst_ptr->isNumber())
         {
-          auto num_value = StringToDouble(value, env);
+          double num_value = 0;
+          try
+          {
+            num_value = StringToDouble(value, env);
+          }
+          catch(const RuntimeError& err)
+          {
+            throw RuntimeError(StrCat(errorPrefix(), err.what()));
+          }
           *dst_ptr = Any(num_value);
         }
         else
@@ -619,16 +963,28 @@ struct ExprAssignment : ExprBase
     // temporary use
     Any temp_variable = *dst_ptr;
 
-    if(value.isNumber())
+    // `+=` joins two strings until PickNikRobotics/moveit_pro#24181 removes it.
+    if(op == assign_plus && temp_variable.isString() && value.isString())
+    {
+      temp_variable = Any(temp_variable.cast<std::string>() + value.cast<std::string>());
+    }
+    else
     {
-      if(!temp_variable.isNumber())
+      const auto current = detail::ArithmeticOperand(temp_variable);
+      if(!current)
+      {
+        throw RuntimeError(StrCat(errorPrefix(), "Its value is not a number, so [",
+                                  opStr(), "] can't be applied"));
+      }
+      const auto operand = detail::ArithmeticOperand(value);
+      if(!operand)
       {
-        throw RuntimeError("This Assignment operator can't be used "
-                           "with a non-numeric type");
+        throw RuntimeError(
+            StrCat(errorPrefix(), detail::NotANumberError(value, opStr())));
       }
 
-      auto lv = temp_variable.cast<double>();
-      auto rv = value.cast<double>();
+      const auto lv = *current;
+      const auto rv = *operand;
       switch(op)
       {
         case assign_plus:
@@ -647,21 +1003,16 @@ struct ExprAssignment : ExprBase
         }
       }
     }
-    else if(value.isString())
+
+    if(temp_variable.isNumber() && dst_ptr->isString())
     {
-      if(op == assign_plus)
-      {
-        auto lv = temp_variable.cast<std::string>();
-        auto rv = value.cast<std::string>();
-        temp_variable = Any(lv + rv);
-      }
-      else
-      {
-        throw RuntimeError("Operator not supported for strings");
-      }
+      // The entry held a numeric string, so it keeps holding a string.
+      *dst_ptr = Any(detail::ConcatOperandString(temp_variable));
+    }
+    else
+    {
+      temp_variable.copyInto(*dst_ptr);
     }
-
-    temp_variable.copyInto(*dst_ptr);
     entry->sequence_id++;
     entry->stamp = std::chrono::steady_clock::now().time_since_epoch();
     return *dst_ptr;
diff --git a/tests/gtest_subtree.cpp b/tests/gtest_subtree.cpp
index f543de7bf..5adf48620 100644
--- a/tests/gtest_subtree.cpp
+++ b/tests/gtest_subtree.cpp
@@ -406,6 +406,41 @@ TEST(SubTree, ScriptingTypingIssue_StringConcatWorks)
   EXPECT_EQ(blackboard->get<std::string>("y"), "1234");
 }
 
+// https://github.com/PickNikRobotics/moveit_pro/issues/24179
+TEST(SubTree, ScriptingTypingIssue_SubtractNumericStringPort)
+{
+  static const char* xml_text = R"(
+
+<root BTCPP_format="4" >
+    <BehaviorTree ID="MainTree">
+        <Sequence>
+            <SubTree ID="mySubtree" in_value="5" out_value="{y}" />
+        </Sequence>
+    </BehaviorTree>
+
+    <BehaviorTree ID="mySubtree">
+      <Script code = "out_value := in_value - '1'" />
+    </BehaviorTree>
+  <TreeNodesModel>
+    <SubTree ID="mySubtree">
+      <input_port name="in_value" />
+      <output_port name="out_value" />
+    </SubTree>
+  </TreeNodesModel>
+</root> )";
+
+  BehaviorTreeFactory factory;
+  factory.registerBehaviorTreeFromText(xml_text);
+
+  auto blackboard = BT::Blackboard::create();
+  Tree tree = factory.createTree("MainTree", blackboard);
+
+  auto status = tree.tickWhileRunning();
+  ASSERT_EQ(status, NodeStatus::SUCCESS);
+
+  EXPECT_EQ(blackboard->get<int>("y"), 4);
+}
+
 class NaughtyNav2Node : public BT::SyncActionNode
 {
 public:
diff --git a/tests/script_parser_test.cpp b/tests/script_parser_test.cpp
index 64ed0b1c2..db504f87b 100644
--- a/tests/script_parser_test.cpp
+++ b/tests/script_parser_test.cpp
@@ -754,3 +754,185 @@ TEST(ParserTest, MultipleStatements)
   auto result = Parse("a:=10; b:=20; a+b");
   EXPECT_EQ(result.value().cast<double>(), 30.0);
 }
+
+// https://github.com/PickNikRobotics/moveit_pro/issues/24179
+// Numbers that arrive as strings (for example through SubTree ports) take part in arithmetic
+// only when the whole string is a number, and `..` joins any two strings or numbers.
+TEST(ParserTest, UntypedNumericOperands)
+{
+  BT::Ast::Environment env = { BT::Blackboard::create(), {} };
+  auto Get = [&env](const char* text) { return GetScriptResult(env, text); };
+  auto Error = [&env](const char* text) {
+    auto result = BT::ParseScriptAndExecute(env, text);
+    return result.has_value() ? std::string() : result.error();
+  };
+
+  // Arithmetic on numeric strings, other than `+`.
+  EXPECT_EQ(Get("a := '1'; b := '2'; a - b").cast<double>(), -1.0);
+  EXPECT_EQ(Get("a := '1'; b := '2'; a * b").cast<double>(), 2.0);
+  EXPECT_EQ(Get("a := '1'; b := '2'; a / b").cast<double>(), 0.5);
+  EXPECT_EQ(Get("'-2' * '1.5'").cast<double>(), -3.0);
+  EXPECT_EQ(Get("'1e3' - 1").cast<double>(), 999.0);
+  EXPECT_EQ(Get("'12' + 3").cast<double>(), 15.0);
+  EXPECT_EQ(Get("n1 := 1; n2 := 2; n1 + n2").cast<double>(), 3.0);
+
+  // `+` on two strings still concatenates until it is removed in 11.0.0.
+  EXPECT_EQ(Get("a := '1'; b := '2'; a + b").cast<std::string>(), "12");
+  EXPECT_EQ(Get("'a' + 'b'").cast<std::string>(), "ab");
+
+  // Spaces around a number don't matter, and the usual decimal spellings are numbers.
+  EXPECT_EQ(Get("' 5' * 2").cast<double>(), 10.0);
+  EXPECT_EQ(Get("'5 ' * 2").cast<double>(), 10.0);
+  EXPECT_EQ(Get("'\t7\n' * 1").cast<double>(), 7.0);
+  EXPECT_EQ(Get("'.5' * 2").cast<double>(), 1.0);
+  EXPECT_EQ(Get("'5.' * 2").cast<double>(), 10.0);
+  EXPECT_EQ(Get("'1e+5' - 0").cast<double>(), 100000.0);
+
+  // A string that is only partly a number is not a number.
+  for(const char* script :
+      { "'3 apples' + 4", "'5000ms' / 1000", "'' - 1", "' ' - 1", "'0x10' - 1",
+        "'+5' - 1", "'1e' - 1", "'1.2.3' - 1", "'within ' + 5000", "'nan' + 1",
+        "'inf' - 1", "'1e999' - 1", "'1e-400' - 0", "-'abc'" })
+  {
+    const auto error = Error(script);
+    EXPECT_NE(error.find("not a number"), std::string::npos) << script << ": " << error;
+  }
+  EXPECT_NE(Error("'within ' + 5000").find("[..]"), std::string::npos);
+  EXPECT_NE(Error("'3 apples' + 4").find("['3 apples']"), std::string::npos);
+  EXPECT_NE(Error("5 - 'x'").find("['x'] of operator [-]"), std::string::npos);
+  EXPECT_NE(Error("-'abc'").find("of a unary operator"), std::string::npos);
+  env.vars->set("list", std::vector<int>{ 1 });
+  EXPECT_NE(Error("'a' .. list").find("neither a string nor a number"),
+            std::string::npos);
+
+  // Bitwise operators read an integer string exactly, beyond the 2^53 a double holds.
+  EXPECT_EQ(Get("'6' & '3'").cast<int>(), 2);
+  EXPECT_EQ(Get("'9007199254740993' & 1").cast<int>(), 1);
+  env.vars->set("big", int64_t(9007199254740993));
+  EXPECT_EQ(Get("big & 1").cast<int>(), 1);
+  // A double can't hold it exactly, so other operators report an error instead of throwing.
+  for(const char* script : { "big + 1", "-big", "!big", "big == 1", "big < 5",
+                             "q := 1; q += big", "big ? 1 : 2" })
+  {
+    EXPECT_FALSE(BT::ParseScriptAndExecute(env, script).has_value()) << script;
+  }
+  EXPECT_EQ(Get("~big").cast<int64_t>(), -9007199254740994);
+  EXPECT_EQ(Get("~'9007199254740993'").cast<int64_t>(), -9007199254740994);
+  // Up to 2^53 integer text is exact.
+  EXPECT_EQ(Get("'9007199254740992' - 0").cast<int64_t>(), 9007199254740992);
+  EXPECT_EQ(Get("'-9007199254740992' + 0").cast<int64_t>(), -9007199254740992);
+  EXPECT_EQ(Get("'007' + 1").cast<double>(), 8.0);
+  EXPECT_EQ(Get("'0.0e-400' - 0").cast<double>(), 0.0);
+  // Integer text a double would round is an error in arithmetic, as for an int64 entry.
+  for(const char* script :
+      { "'9007199254740993' + 0", "-'9007199254740993'", "' 9007199254740993 ' * 1",
+        "'9223372036854775808' & 1", "'1e20' & 1", "'99999999999999999999' - 1",
+        "'-1e-400' - 0" })
+  {
+    EXPECT_FALSE(BT::ParseScriptAndExecute(env, script).has_value()) << script;
+  }
+
+  // Unary operators.
+  EXPECT_EQ(Get("-'5'").cast<double>(), -5.0);
+  EXPECT_EQ(Get("!'0'").cast<int>(), 1);
+  EXPECT_EQ(Get("~'6'").cast<int>(), -7);
+
+  // `..` joins numbers too, without trailing zeros.
+  EXPECT_EQ(Get("n1 .. n2").cast<std::string>(), "12");
+  EXPECT_EQ(Get("sum := 1 + 1; sum .. ''").cast<std::string>(), "2");
+  EXPECT_EQ(Get("0.5 .. ''").cast<std::string>(), "0.5");
+  EXPECT_EQ(Get("-0.5 .. ''").cast<std::string>(), "-0.5");
+  EXPECT_EQ(Get("1e15 .. ''").cast<std::string>(), "1000000000000000");
+  EXPECT_EQ(Get("9007199254740992.0 .. ''").cast<std::string>(), "9007199254740992");
+  EXPECT_EQ(Get("(0.1 + 0.2) .. ''").cast<std::string>(), "0.30000000000000004");
+  EXPECT_EQ(Get("1e300 .. ''").cast<std::string>(), "1e+300");
+  EXPECT_EQ(Get("0.0001 .. ''").cast<std::string>(), "0.0001");
+  EXPECT_EQ(Get("-0.0 .. ''").cast<std::string>(), "0");
+  EXPECT_EQ(Get("'x' .. -3").cast<std::string>(), "x-3");
+  EXPECT_EQ(Get("'within ' .. 5000 .. ' ms'").cast<std::string>(), "within 5000 ms");
+  env.vars->set("half", 0.5f);
+  EXPECT_EQ(Get("'x' .. half").cast<std::string>(), "x0.5");
+
+  // Compound assignment on an entry holding a numeric string keeps it a string.
+  EXPECT_EQ(Get("c := '1'; c += 1; c").cast<std::string>(), "2");
+  EXPECT_TRUE(env.vars->getEntry("c")->value.isString());
+  EXPECT_EQ(Get("d := '10'; d -= 4; d").cast<std::string>(), "6");
+  EXPECT_NE(Error("e := 'apples'; e += 1").find("not a number"), std::string::npos);
+  EXPECT_EQ(Get("f := 'ab'; f += 'cd'; f").cast<std::string>(), "abcd");
+
+  // A numeric string on the right of a compound assignment to a number entry is a number.
+  EXPECT_EQ(Get("n := 1; n += '2'; n").cast<double>(), 3.0);
+  EXPECT_EQ(Get("n -= '1'; n").cast<double>(), 2.0);
+  const auto compound_error = Error("n += 'x'");
+  EXPECT_NE(compound_error.find("['x'] of operator [+=]"), std::string::npos)
+      << compound_error;
+  EXPECT_NE(compound_error.find("[..]"), std::string::npos) << compound_error;
+  EXPECT_EQ(Get("g := '10'; g -= '4'; g").cast<std::string>(), "6");
+
+  // The same whether the entry was set from C++ untyped or declared as a string.
+  env.vars->set("untyped", std::string("1"));
+  EXPECT_EQ(Get("untyped += 1; untyped").cast<std::string>(), "2");
+  env.vars->createEntry("typed", BT::TypeInfo::Create<std::string>());
+  env.vars->set("typed", std::string("1"));
+  EXPECT_EQ(Get("typed += 1; typed").cast<std::string>(), "2");
+
+  // Assigning a string to a number entry created by a script uses the same rule. (Entries typed
+  // from C++ convert with their port converter instead.)
+  EXPECT_EQ(Get("num := 1; num = '7'; num").cast<double>(), 7.0);
+  const auto assign_error = Error("num = '3 apples'");
+  EXPECT_NE(assign_error.find("entry [num]"), std::string::npos) << assign_error;
+  EXPECT_NE(assign_error.find("not a number"), std::string::npos) << assign_error;
+
+  // Comparisons use the same rule, and two numeric strings compare as numbers.
+  EXPECT_EQ(Get("'3' == 3").cast<int>(), 1);
+  EXPECT_EQ(Get("'10' > '9'").cast<int>(), 1);
+  EXPECT_EQ(Get("'3' == '3.0'").cast<int>(), 1);
+  EXPECT_EQ(Get("'abc' < 'abd'").cast<int>(), 1);
+  EXPECT_EQ(Get("'10' < 'abc'").cast<int>(), 1);
+  EXPECT_EQ(Get("'007' == '7'").cast<int>(), 1);
+  // Exactly, so different numbers never compare equal.
+  EXPECT_EQ(Get("'1730000000000000001' == '1730000000000000002'").cast<int>(), 0);
+  EXPECT_EQ(Get("'1730000000000000001' < '1730000000000000002'").cast<int>(), 1);
+  EXPECT_EQ(Get("'0.00000001' == '0'").cast<int>(), 0);
+  // Numbers beyond what int64 or a double hold exactly can't be compared.
+  for(const char* script : { "'99999999999999999998' == '99999999999999999999'", "'200000"
+                                                                                 "0000000"
+                                                                                 "000000'"
+                                                                                 " < "
+                                                                                 "'3."
+                                                                                 "5'" })
+  {
+    EXPECT_FALSE(BT::ParseScriptAndExecute(env, script).has_value()) << script;
+  }
+
+  // The condition of ?: uses the same rule.
+  EXPECT_EQ(Get("'1' ? 10 : 20").cast<int>(), 10);
+  EXPECT_EQ(Get("' 0' ? 10 : 20").cast<int>(), 20);
+  for(const char* script : { "'3 apples' ? 10 : 20", "'0x10' ? 10 : 20", "'' ? 10 : 20",
+                             "'true' ? 10 : 20", "'9007199254740993' ? 10 : 20" })
+  {
+    EXPECT_FALSE(BT::ParseScriptAndExecute(env, script).has_value()) << script;
+  }
+  EXPECT_EQ(Get("'2.5' < 3").cast<int>(), 1);
+  for(const char* script : { "'3 apples' == 3", "'+5' == 5", "'nan' < 1" })
+  {
+    EXPECT_FALSE(BT::ParseScriptAndExecute(env, script).has_value()) << script;
+  }
+}
+
+// The stream fallbacks used where the standard library has no floating-point from_chars or
+// to_chars.
+TEST(ParserTest, NumberStreamFallbacks)
+{
+  using BT::Ast::detail::StreamFormatNumber;
+  using BT::Ast::detail::StreamParseNumber;
+
+  EXPECT_EQ(StreamParseNumber("1.5"), 1.5);
+  EXPECT_EQ(StreamParseNumber("-2e3"), -2000.0);
+  EXPECT_FALSE(StreamParseNumber("12abc").has_value());
+  EXPECT_FALSE(StreamParseNumber("1e999").has_value());
+
+  EXPECT_EQ(StreamFormatNumber(0.1), "0.1");
+  EXPECT_EQ(StreamFormatNumber(0.1 + 0.2), "0.30000000000000004");
+  EXPECT_EQ(StreamParseNumber(StreamFormatNumber(1e300)), 1e300);
+}