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.
return outpoint < rhs.outpoint;
    }
    bool operator!=(const CInputCoin& rhs) const {
        return outpoint != rhs.outpoint;
    }
    bool operator==(const CInputCoin& rhs) const {
        return outpoint == rhs.outpoint;
    }
};
/** Parameters for filtering which OutputGroups we may use in coin selection.
 * We start by being very selective and requiring multiple confirmations and
 * then get more permissive if we cannot fund the transaction. */
struct CoinEligibilityFilter
{
    /** Minimum number of confirmations for outputs that we sent to ourselves.
     * We may use unconfirmed UTXOs sent from ourselves, e.g. change outputs. */
    const int conf_mine;
    /** Minimum number of confirmations for outputs received from a different
     * wallet. We never spend unconfirmed foreign outputs as we cannot rely on these funds yet. */
    const int conf_theirs;
    
    const uint64_t max_ancestors;
    
    const uint64_t max_descendants;
    
    const bool m_include_partial_groups{false};
    CoinEligibilityFilter(int conf_mine, int conf_theirs, uint64_t max_ancestors) : conf_mine(conf_mine), conf_theirs(conf_theirs), max_ancestors(max_ancestors), max_descendants(max_ancestors) {}