Would it be completely unreasonable to allow `fundrawtransaction` to use unsafe outputs?

I understand this means the resulting transaction may be invalidated whenever the unsafe output I'm relying one disappears (e.g. because the transaction that produced it was RBF-ed) but in my case that's ok, I'll react to that and re-publish the tree of child transactions accordingly.

But let me know if you think that's too much of a footgun for users, in that case I'll architect my solution differently.
int m_depth{999};
    /** The aggregated count of unconfirmed ancestors of all UTXOs in this
     * group. Not deduplicated and may overestimate when ancestors are shared. */
    size_t m_ancestors{0};
    
    size_t m_descendants{0};
    
    CAmount effective_value{0};
    
    CAmount fee{0};
    
    CFeeRate m_effective_feerate{0};
    
    CAmount long_term_fee{0};
    /** The feerate for spending a created change output eventually (i.e. not urgently, and thus at
     * a lower feerate). Calculated using long term fee estimate. This is used to decide whether
     * it could be economical to create a change output. */
    CFeeRate m_long_term_feerate{0};
    OutputGroup() {}
    OutputGroup(const CFeeRate& effective_feerate, const CFeeRate& long_term_feerate) :
        m_effective_feerate(effective_feerate),
        m_long_term_feerate(long_term_feerate)
    {}
    void Insert(const CInputCoin& output, int depth, bool from_me, size_t ancestors, size_t descendants, bool positive_only);
    bool EligibleForSpending(const CoinEligibilityFilter& eligibility_filter) const;
};
bool SelectCoinsBnB(std::vector<OutputGroup>& utxo_pool, const CAmount& target_value, const CAmount& cost_of_change, std::set<CInputCoin>& out_set, CAmount& value_ret, CAmount not_input_fees);
bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet);
#endif