feat: Complete exclude_newer policy

.github/workflows/brew.yml

@@ -19,6 +19,7 @@ jobs:
           brew install --overwrite
           fmt libarchive libsolv lz4 openssl@3 reproc simdjson xz yaml-cpp zstd
           cli11 nlohmann-json spdlog tl-expected pkgconfig python msgpack
+          howard-hinnant-date
 
       - name: Configure to build mamba
         run: >

.github/workflows/static_build.yml

@@ -85,6 +85,23 @@ jobs:
               )
           )
           PY
+      - name: Add howardhinnant_date-static host dependency for osx
+        if: ${{ matrix.platform == 'osx' }}
+        run: |
+          cd micromamba-feedstock/
+          python3 - <<'PY'
+          from pathlib import Path
+          meta = Path("recipe/meta.yaml")
+          lines = meta.read_text().splitlines()
+          if any("howardhinnant_date-static" in line for line in lines):
+              raise SystemExit(0)
+          out = []
+          for line in lines:
+              out.append(line)
+              if line.strip().startswith("- lz4-c-static"):
+                  out.append("    - howardhinnant_date-static")
+          meta.write_text("\n".join(out) + "\n")
+          PY
       - name: Checkout mamba branch
         uses: actions/checkout@v7
         with:

dev/environment-dev.yml

@@ -25,6 +25,8 @@ dependencies:
   - spdlog >=1.16.0
   - yaml-cpp >=0.8.0
   - sel(win): winreg
+  # Replacement of `std::chrono::parse` (P0355R7) missing in libc++, see: https://github.com/llvm/llvm-project/issues/166051
+  - sel(osx): howardhinnant_date
   # libmamba test dependencies
   - catch2
   # micromamba dependencies

dev/environment-micromamba-static.yml

@@ -38,6 +38,8 @@ dependencies:
   - zlib
   - libnghttp2-static
   - lz4-c-static
+  # Replacement of `std::chrono::parse` (P0355R7) missing in libc++, see: https://github.com/llvm/llvm-project/issues/166051
+  - sel(osx): howardhinnant_date-static
   # libmamba test dependencies
   - catch2
   # micromamba dependencies

dev/micromamba_windows_allowed_dlls.tsv

@@ -26,5 +26,6 @@ api-ms-win-crt-string-l1-1-0.dll	UCRT (ucrt)	UCRT forwarder: C string and memory
 api-ms-win-crt-time-l1-1-0.dll	UCRT (ucrt)	UCRT forwarder: time and date (time, localtime, strftime, …).
 api-ms-win-crt-utility-l1-1-0.dll	UCRT (ucrt)	UCRT forwarder: utility routines (qsort, bsearch, system, …).
 MSVCP140.dll	MSVC runtime (vc14_runtime)	Microsoft C++ standard library runtime (/MD builds).
+msvcp140_atomic_wait.dll	MSVC runtime (vc14_runtime)	C++20 std::atomic wait/notify from the MSVC STL; required at runtime by std::chrono::parse (exclude_newer date/datetime parsing).
 VCRUNTIME140.dll	MSVC runtime (vc14_runtime)	Microsoft C runtime helpers (exceptions, EH scaffolding).
 VCRUNTIME140_1.dll	MSVC runtime (vc14_runtime)	Additional MSVC C++ exception-handling support on x64.

libmamba/CMakeLists.txt

@@ -9,6 +9,45 @@ cmake_policy(SET CMP0025 NEW) # Introduced in cmake 3.0
 cmake_policy(SET CMP0077 NEW) # Introduced in cmake 3.13
 project(libmamba)
 
+include(CheckCXXSourceCompiles)
+
+# std::chrono::parse (P0355) is not yet available on all platforms (e.g. libc++ on macOS).
+# https://github.com/llvm/llvm-project/issues/166051
+if(NOT DEFINED MAMBA_HAVE_STD_CHRONO_PARSE)
+    # CMAKE_REQUIRED_FLAGS is a string (not a CMake list); list(APPEND) would inject ';'.
+    set(CMAKE_REQUIRED_FLAGS_BACKUP "${CMAKE_REQUIRED_FLAGS}")
+    if(MSVC)
+        set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} /std:c++20")
+    else()
+        set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++20")
+    endif()
+    check_cxx_source_compiles(
+        "
+#include <chrono>
+#include <sstream>
+int main()
+{
+    std::istringstream is{ \"2020-01-01\" };
+    std::chrono::sys_days d{};
+    is >> std::chrono::parse( \"%F\", d );
+    return is.fail() ? 1 : 0;
+}
+"
+        MAMBA_HAVE_STD_CHRONO_PARSE
+    )
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_BACKUP}")
+endif()
+
+if(MAMBA_HAVE_STD_CHRONO_PARSE)
+    message(STATUS "libmamba: using std::chrono::parse for date/datetime parsing")
+else()
+    find_package(date CONFIG REQUIRED)
+    message(
+        STATUS
+            "libmamba: using Howard Hinnant date for date/datetime parsing (std::chrono::parse unavailable)"
+    )
+endif()
+
 set(LIBMAMBA_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 set(LIBMAMBA_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
 set(LIBMAMBA_DATA_DIR ${CMAKE_CURRENT_SOURCE_DIR}/data)
@@ -228,6 +267,7 @@ set(
     ${LIBMAMBA_SOURCE_DIR}/core/env_lockfile_mambajs.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/environments_manager.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/error_handling.cpp
+    ${LIBMAMBA_SOURCE_DIR}/core/exclude_newer.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/execution.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/fsutil.cpp
     ${LIBMAMBA_SOURCE_DIR}/core/history.cpp
@@ -384,6 +424,7 @@ set(
     ${LIBMAMBA_INCLUDE_DIR}/mamba/core/env_lockfile.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/core/environments_manager.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/core/error_handling.hpp
+    ${LIBMAMBA_INCLUDE_DIR}/mamba/core/exclude_newer.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/core/execution.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/core/fsutil.hpp
     ${LIBMAMBA_INCLUDE_DIR}/mamba/core/history.hpp
@@ -736,6 +777,11 @@ macro(libmamba_create_target target_name linkage output_name)
         target_link_libraries(${target_name} PUBLIC Threads::Threads)
     endif()
 
+    if(NOT MAMBA_HAVE_STD_CHRONO_PARSE)
+        target_compile_definitions(${target_name} PUBLIC MAMBA_USE_HOWARD_HINNANT_DATE)
+        target_link_libraries(${target_name} PUBLIC date::date date::date-tz)
+    endif()
+
     list(APPEND libmamba_targets ${target_name})
     add_library(mamba::${target_name} ALIAS ${target_name})
 endmacro()
@@ -812,6 +858,12 @@ install(
     PATTERN "*.h"
 )
 
+if(NOT MAMBA_HAVE_STD_CHRONO_PARSE)
+    set(LIBMAMBA_USE_HOWARD_HINNANT_DATE ON)
+else()
+    set(LIBMAMBA_USE_HOWARD_HINNANT_DATE OFF)
+endif()
+
 # Configure 'mambaConfig.cmake' for a build tree
 set(MAMBA_CONFIG_CODE "####### Expanded from \@MAMBA_CONFIG_CODE\@ #######\n")
 set(

libmamba/include/mamba/api/configuration.hpp

@@ -633,6 +633,20 @@ namespace mamba
             node[name] = values;
         }
 
+        template <>
+        inline void ConfigurableImpl<std::vector<std::pair<std::string, std::string>>>::dump_json(
+            nlohmann::json& node,
+            const std::string& name
+        ) const
+        {
+            nlohmann::json object = nlohmann::json::object();
+            for (const auto& [key, value] : m_value)
+            {
+                object[key] = value;
+            }
+            node[name] = object;
+        }
+
         template <class T>
         void ConfigurableImpl<T>::set_rc_value(const T& value, const std::string& source)
         {

libmamba/include/mamba/api/configuration_impl.hpp

@@ -3,6 +3,7 @@
 
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include <yaml-cpp/yaml.h>
@@ -170,6 +171,45 @@ namespace mamba
         {
             return true;
         }
+
+        // Map-shaped config (e.g. exclude_newer_package): stored as vector of pairs for
+        // duplicate-key / order control, but configured as a YAML/JSON object — not a sequence.
+        // Must not use Source<vector<T>>::deserialize, which wraps the value in `[...]`.
+        template <>
+        struct Source<std::vector<std::pair<std::string, std::string>>>
+        {
+            using value_type = std::vector<std::pair<std::string, std::string>>;
+
+            static std::vector<std::string> default_value(const value_type& /* init */)
+            {
+                return { "default" };
+            }
+
+            static void merge(
+                const std::map<std::string, value_type>& values,
+                const std::vector<std::string>& sources,
+                value_type& value,
+                std::vector<std::string>& source
+            )
+            {
+                source = sources;
+                value = values.at(sources.front());
+            }
+
+            static value_type deserialize(const std::string& value)
+            {
+                if (value.empty())
+                {
+                    return {};
+                }
+                return YAML::Load(value).as<value_type>();
+            }
+
+            static bool is_sequence()
+            {
+                return false;
+            }
+        };
     }
 }
 
@@ -199,6 +239,37 @@ namespace YAML
         }
     };
 
+    template <>
+    struct convert<std::vector<std::pair<std::string, std::string>>>
+    {
+        static Node encode(const std::vector<std::pair<std::string, std::string>>& rhs)
+        {
+            // Empty default Node is Null; print-config / YAML consumers need an empty Map.
+            Node node(NodeType::Map);
+            node.SetStyle(YAML::EmitterStyle::Block);
+            for (const auto& [key, value] : rhs)
+            {
+                node[key] = value;
+            }
+            return node;
+        }
+
+        static bool decode(const Node& node, std::vector<std::pair<std::string, std::string>>& rhs)
+        {
+            if (!node.IsMap())
+            {
+                return false;
+            }
+            rhs.clear();
+            rhs.reserve(node.size());
+            for (const auto& entry : node)
+            {
+                rhs.emplace_back(entry.first.as<std::string>(), entry.second.as<std::string>());
+            }
+            return true;
+        }
+    };
+
     template <>
     struct convert<mamba::VerificationLevel>
     {

libmamba/include/mamba/core/context.hpp

@@ -10,6 +10,7 @@
 #include <map>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "mamba/core/context_params.hpp"
@@ -131,6 +132,20 @@ namespace mamba
         // solver options
         solver::Request::Flags solver_flags = {};
 
+        /**
+         * Exclude packages published more recently than this duration or date.
+         *
+         * See Configurable ``exclude_newer``; resolved into ``ExcludeNewerPolicy`` at solve time.
+         */
+        std::string exclude_newer;
+
+        /**
+         * Per-package overrides for ``exclude_newer`` (JSON dictionary on CLI / env vars).
+         *
+         * See Configurable ``exclude_newer_package``.
+         */
+        std::vector<std::pair<std::string, std::string>> exclude_newer_package;
+
         // add start menu shortcuts on Windows (not implemented on Linux / macOS)
         bool shortcuts = true;
 

libmamba/include/mamba/core/detail/chrono_parse.hpp

@@ -0,0 +1,49 @@
+// Copyright (c) 2026, QuantStack and Mamba Contributors
+//
+// Distributed under the terms of the BSD 3-Clause License.
+//
+// The full license is in the file LICENSE, distributed with this software.
+
+#pragma once
+
+#include <chrono>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <string_view>
+
+#if defined(MAMBA_USE_HOWARD_HINNANT_DATE)
+#include <date/date.h>
+#include <date/tz.h>
+#endif
+
+namespace mamba::detail
+{
+    /**
+     * Parse ``value`` with ``std::chrono::parse`` or ``date::from_stream`` using ``fmt``.
+     *
+     * When ``MAMBA_USE_HOWARD_HINNANT_DATE`` is set (libc++ lacks P0355;
+     * https://github.com/llvm/llvm-project/issues/166051), ``date::from_stream`` is used.
+     *
+     * TODO: Drop the Howard Hinnant ``date`` fallback once ``std::chrono::parse`` is
+     * available on all supported platforms (notably macOS/libc++).
+     *
+     * Returns ``std::nullopt`` when parsing fails or trailing characters remain.
+     */
+    template <typename T>
+    [[nodiscard]] auto parse_chrono(std::string_view value, const char* fmt) -> std::optional<T>
+    {
+        std::istringstream stream{ std::string(value) };
+        T out{};
+#if defined(MAMBA_USE_HOWARD_HINNANT_DATE)
+        date::from_stream(stream, fmt, out);
+#else
+        stream >> std::chrono::parse(fmt, out);
+#endif
+        if (stream.fail() || stream.peek() != std::istringstream::traits_type::eof())
+        {
+            return std::nullopt;
+        }
+        return out;
+    }
+}  // namespace mamba::detail