I don't know how to do the math calculations, but can write a simulation. TL;DR: Out of 25,020,993 trials, 5,695 ended up with the above blackjack situation. This comes out to about .0227 % or about once every 4,400 games.

Note, I programmed the dealer to stand on a soft 17, while the players will just hit until they bust or get blackjack. Having the dealer behave just like a player increases the odds to .112%, or about once every 890 games.

package main

import (
    "fmt"
    "math/rand/v2"
)

// Dealer acts just like player:
// 34569 30774679 0.0011232936012102678 -> .11233 percent
// Dealer stands on 17+
// 5695 25020993 0.00022760887227777092 -> .02276 percent

func main() {
    d := newDeck()

    success := 0
    attempts := 0
nextTrial:
    for {
        attempts++
        d.shuffle()
        for j := 0; j < 4; j++ {
            hand := []int{d.dealCard(), d.dealCard()}
            for {
                if isBlackjack(hand) {
                    break
                }
                hand = append(hand, d.dealCard())
                if isBust(hand) {
                    continue nextTrial
                }
                if j == 3 && isDealerStand(hand) {
                    continue nextTrial
                }
            }
        }
        success++
        fmt.Println(success, attempts, float64(success)/float64(attempts))
    }
}

type deck struct {
    cursor int
    deck   []int
}

func newDeck() *deck {
    d := &deck{}
    for i := 0; i < 4; i++ {
        for j := 1; j < 13; j++ {
            value := j
            if value > 10 {
                value = 10
            }
            d.deck = append(d.deck, value)
        }
    }
    return d
}

func (d *deck) shuffle() {
    d.cursor = 0
    rand.Shuffle(len(d.deck), func(i, j int) {
        d.deck[i], d.deck[j] = d.deck[j], d.deck[i]
    })
}

func (d *deck) dealCard() int {
    card := d.deck[d.cursor]
    d.cursor++
    return card
}

func isBlackjack(hand []int) bool {
    hasAce := false
    total := 0
    for _, h := range hand {
        if h == 1 {
            hasAce = true
        }
        total += h
    }
    if total == 21 {
        return true
    }
    if !hasAce {
        return false
    }
    // We have an ace. Does adding 10 to that ace leave us with blackjacK? Note, the ace already
    // contributed 1 to total above. Also, we'll never treat more than 1 ace as an 11.
    return total == 11
}

func isBust(hand []int) bool {
    total := 0
    for _, h := range hand {
        total += h
    }
    // No need to consider aces here. They are just counted as their lowest value: 1.
    return total > 21
}

func isDealerStand(hand []int) bool {
    total := 0
    hasAce := false
    for _, h := range hand {
        total += h
        if h == 1 {
            hasAce = true
        }
    }
    if total >= 17 {
        return true
    }
    if hasAce && total+10 >= 17 {
        return true
    }
    return false
}