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

@@ -70,6 +70,23 @@ jobs:
         run: |
           cd micromamba-feedstock/
           sed -i '' '/conda_forge_output_validation/d' conda-forge.yml
+      - name: Add howardhinnant_date 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" 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")
+          meta.write_text("\n".join(out) + "\n")
+          PY
       - name: Checkout mamba branch
         uses: actions/checkout@v7
         with:

dev/environment-dev.yml

@@ -21,6 +21,7 @@ dependencies:
   - libmsgpack-c
   - nlohmann_json
   - reproc-cpp >=14.2.4.post0
+  - sel(osx): howardhinnant_date
   - simdjson >=3.3.0
   - spdlog >=1.16.0
   - yaml-cpp >=0.8.0

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,44 @@ 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)
+    set(CMAKE_REQUIRED_FLAGS_BACKUP "${CMAKE_REQUIRED_FLAGS}")
+    if(MSVC)
+        list(APPEND CMAKE_REQUIRED_FLAGS "/std:c++20")
+    else()
+        list(APPEND 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)
@@ -227,6 +265,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
@@ -382,6 +421,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
@@ -720,6 +760,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()
@@ -796,6 +841,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/core/context.hpp

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "mamba/core/context_params.hpp"
+#include "mamba/core/exclude_newer.hpp"
 #include "mamba/core/logging.hpp"
 #include "mamba/core/palette.hpp"
 #include "mamba/core/subdir_parameters.hpp"
@@ -130,6 +131,7 @@ namespace mamba
 
         // solver options
         solver::Request::Flags solver_flags = {};
+        ExcludeNewerPolicy exclude_newer_policy;
 
         // 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,46 @@
+// 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.
+     *
+     * 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

libmamba/include/mamba/core/exclude_newer.hpp

@@ -0,0 +1,164 @@
+// 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.
+
+#ifndef MAMBA_CORE_EXCLUDE_NEWER_HPP
+#define MAMBA_CORE_EXCLUDE_NEWER_HPP
+
+#include <chrono>
+#include <cstdint>
+#include <map>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+namespace mamba
+{
+    /**
+     * Resolved per-package ``exclude_newer`` cutoffs.
+     *
+     * Cutoffs are stored as Unix epoch seconds (``std::uint64_t``) for compatibility with
+     * conda repodata timestamps and ``Database::Settings``. Parsing uses
+     * ``std::chrono::sys_seconds`` internally; see ``resolve_exclude_newer_cutoff``.
+     *
+     * When a package name is present:
+     * - ``std::nullopt`` exempts the package from the global policy (``false`` in config)
+     * - a timestamp value applies a package-specific cutoff
+     *
+     * Packages not listed fall back to the global cutoff.
+     */
+    using ExcludeNewerPackageCutoffs = std::unordered_map<std::string, std::optional<std::uint64_t>>;
+
+    /**
+     * Resolved and raw ``exclude_newer`` policy from configuration.
+     *
+     * Holds both unresolved config strings and resolved Unix-second cutoffs used by the solver.
+     */
+    struct ExcludeNewerPolicy
+    {
+        /**
+         * Raw ``exclude_newer`` configuration values from CLI or configuration file.
+         *
+         * Background and cross-ecosystem tracking:
+         * https://github.com/conda/conda/issues/15759
+         */
+        std::string exclude_newer;
+
+        /**
+         * Raw per-package ``exclude_newer`` overrides from configuration.
+         *
+         * Values are resolved to timestamps (or exemption) via
+         * ``resolve_exclude_newer_package_cutoffs``.
+         */
+        std::map<std::string, std::string> exclude_newer_package;
+
+        /**
+         * Resolved global cutoff timestamp in seconds.
+         */
+        std::optional<std::uint64_t> global = std::nullopt;
+
+        /**
+         * Resolved per-package timestamp cutoffs.
+         */
+        ExcludeNewerPackageCutoffs per_package = {};
+
+        /** Return whether no ``exclude_newer`` configuration is set. */
+        [[nodiscard]] auto empty() const -> bool
+        {
+            return exclude_newer.empty() && exclude_newer_package.empty();
+        }
+
+        /**
+         * Return the effective cutoff for ``package_name``.
+         *
+         * Per-package entries take precedence over the global cutoff. A mapped ``std::nullopt``
+         * means the package is exempt.
+         */
+        [[nodiscard]] auto cutoff_for(std::string_view package_name) const
+            -> std::optional<std::uint64_t>;
+
+        /**
+         * Return whether ``pkg_timestamp`` is newer than the effective cutoff for ``package_name``.
+         *
+         * Exempt packages (no cutoff) are never excluded.
+         */
+        [[nodiscard]] auto
+        excludes(std::string_view package_name, std::uint64_t pkg_timestamp) const -> bool;
+    };
+
+    /**
+     * Resolve raw per-package ``exclude_newer`` configuration values.
+     *
+     * @param exclude_newer_package Map of package name to config value (duration, date, or
+     * ``false``).
+     * @param now_seconds Reference time for relative durations, in Unix seconds.
+     *
+     * @throws mamba_error when a non-``false`` value cannot be parsed.
+     */
+    [[nodiscard]] auto resolve_exclude_newer_package_cutoffs(
+        const std::map<std::string, std::string>& exclude_newer_package,
+        std::uint64_t now_seconds
+    ) -> ExcludeNewerPackageCutoffs;
+
+    /**
+     * Resolve a global ``exclude_newer`` configuration value to an absolute Unix
+     * timestamp cutoff in seconds.
+     *
+     * The public API exposes ``std::uint64_t`` seconds for compatibility with repodata
+     * timestamps. Internally, date and datetime values are parsed with
+     * ``std::chrono::parse`` when the standard library provides it, otherwise with
+     * Howard Hinnant's ``date`` library until libc++ implements P0355
+     * (https://github.com/llvm/llvm-project/issues/166051). Duration strings
+     * (``7d``, ``P7D``, plain seconds) use custom parsers because the standard library
+     * does not provide ISO 8601 duration parsing.
+     *
+     * Matches conda's ``exclude_newer`` semantics:
+     * - Durations (``7d``, ``P7D``, plain seconds) resolve to ``now - duration``
+     * - Date-only values (``YYYY-MM-DD``) resolve to the start of the next UTC day
+     * - Datetimes resolve to the given instant (naive values are UTC)
+     * - Zero durations (``0``, ``0d``, ``P0D``) resolve to ``now``
+     *
+     * @param value Raw configuration string.
+     * @param now_seconds Reference time for relative durations, in Unix seconds.
+     * @param package_name When resolving a per-package override, used in parse-failure warnings.
+     *
+     * Returns ``std::nullopt`` when ``value`` is empty/whitespace-only.
+     *
+     * @throws mamba_error when the value cannot be parsed.
+     */
+    [[nodiscard]] auto resolve_exclude_newer_cutoff(
+        std::string_view value,
+        std::uint64_t now_seconds,
+        std::string_view package_name = {}
+    ) -> std::optional<std::uint64_t>;
+
+    namespace detail
+    {
+        /**
+         * Parse an ISO 8601 duration (``P…Y…M…W…DT…H…M…S``) to seconds.
+         *
+         * Returns ``std::nullopt`` when ``value`` is not an ISO 8601 duration.
+         *
+         * @throws mamba_error when the value starts with ``P`` but has no components.
+         */
+        [[nodiscard]] auto parse_iso8601_duration_seconds(std::string_view value)
+            -> std::optional<std::chrono::seconds>;
+
+        /**
+         * Parse a compact duration (``(n)y(n)M(n)w(n)d(n)h(n)m(n)s``, e.g. ``7d``, ``3d12h``)
+         * to seconds.
+         *
+         * Returns ``std::nullopt`` when ``value`` is not a compact duration.
+         */
+        [[nodiscard]] auto parse_compact_duration_seconds(std::string_view value)
+            -> std::optional<std::chrono::seconds>;
+    }
+
+}  // namespace mamba
+
+#include "mamba/core/detail/chrono_parse.hpp"
+
+#endif