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.
if (nChangePosInOut == -1)
                        {
                             Ins
                            nChangePosInOut = GetRandInt(txNew.vout.size()+1);
                        }
                        else if ((unsigned int)nChangePosInOut > txNew.vout.size())
                        {
                            error = _("Change index out of range");
                            return false;
                        }
                        std::vector<CTxOut>::iterator position = txNew.vout.begin()+nChangePosInOut;
                        txNew.vout.insert(position, newTxOut);
                    }
                } else {
                    nChangePosInOut = -1;
                }
                 Dum
                
                for (const auto& coin : setCoins) {
                    txNew.vin.push_back(CTxIn(coin.outpoint,CScript()));
                }
                tx_sizes = CalculateMaximumSignedTxSize(CTransaction(txNew), this, coin_control.fAllowWatchOnly);
                nBytes = tx_sizes.first;
                if (nBytes < 0) {
                    error = _("Signing transaction failed");
                    return false;
                }
                nFeeNeeded = coin_selection_params.m_effective_feerate.GetFee(nBytes);
                if (nFeeRet >= nFeeNeeded) {
                     Red