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.
Because of  lock being hold, block connection notifications are going to
     be pending on the validation-side until lock release. It's likely to have
     block processing duplicata (if rescan block range overlaps with notification one)
     but we guarantee at least than  state is correct after notifications delivery.
     This is temporary until rescan and notifications delivery are unified under same
     interface.
    Instance->m_chain_notifications_handler = Instance->chain().handleNotifications(Instance);
    int rescan_height = 0;
    if (!gArgs.GetBoolArg("-rescan", false))
    {
        WalletBatch batch(Instance->GetDatabase());
        CBlockLocator locator;
        if (batch.ReadBestBlock(locator)) {
            if (const std::optional<int> fork_height = chain.findLocatorFork(locator)) {
                rescan_height = *fork_height;
            }
        }
    }
    const std::optional<int> tip_height = chain.getHeight();
    if (tip_height) {
        Instance->m_last_block_processed = chain.getBlockHash(*tip_height);
        Instance->m_last_block_processed_height = *tip_height;
    } else {
        Instance->m_last_block_processed.SetNull();
        Instance->m_last_block_processed_height = -1;
    }
    if (tip_height && *tip_height != rescan_height)
    {
         We ca
         This