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.
{
        CMutableTransaction tx1 {*this->tx};
        CMutableTransaction tx2 {*_tx.tx};
        for (auto& txin : tx1.vin) txin.scriptSig = CScript();
        for (auto& txin : tx2.vin) txin.scriptSig = CScript();
        return CTransaction(tx1) == CTransaction(tx2);
}
 Rebroadcast transactions from the . We do this on a random timer
 to slightly obfuscate which transactions come from our .
 eally, we'd only resend transactions that we think should have been
 mined in the most recent block. Any transaction that wasn't in the top
 blockweight of transactions in the mempool shouldn't have been mined,
 and so is probably just sitting in the mempool waiting to be confirmed.
 Rebroadcasting does nothing to speed up confirmation and only damages
 privacy.
void CWallet::ResendWalletTransactions()
{
     During reindex, importing and IBD, old  transactions become
     unconfirmed. Don't resend them as that would spam other nodes.
    if (!chain().isReadyToBroadcast()) return;
     Do this infrequently and randomly to avoid giving away
     that these are our transactions.
    if (GetTime() < nNextResend || !fBroadcastTransactions) return;
    bool fFirst = (nNextResend == 0);
     resend 12-36 hours from now, ~1 day on average.