StoreKit 2: New offer code NOT in Transaction.currentEntitlements()

This is production issue with a user completely stuck:

• User entered an offer code for 1 year free --> validated under iOS > Apple Account > subscriptions: it correctly shows a 1 year free trial
• But the transaction is not listed in his Transaction.currentEntitlements()
• Even after a restore (App.sync())
• The Apple Account has always been the same (no mix)
• This is with the new offer codes introduced in 2026

Also, user wanted to pay the subscription himself in order to unlock the situation, he cannot because of the 'active' offer.

Tried giving him another code, but it's refused by the system because there is only one active.

Urgent help would be greatly appreciated.

func readEntitlements(fromDeferredTransaction: Bool = false) async {
    var purchasedNonConsumables: [Product] = []
    var purchasedSubscriptions: [Product] = []
    var purchasedNonRenewableSubscriptions: [Product] = []
    var activeSubTransactions: [Transaction] = []

    //Iterate through all of the user's purchased products.
    for await result in Transaction.currentEntitlements { // currentEntitlements is a StoreKit2 useful feature that only gives us the relevant transactions (not the old & expired ones)
        do {
            //Check whether the transaction is verified. If it isn’t, catch `failedVerification` error.
            let transaction = try checkVerified(result)

            //Check the `productType` of the transaction and get the corresponding product from the store.
            switch transaction.productType {
            case .nonConsumable:
                if let nc = availableNonConsumables.first(where: { $0.id == transaction.productID }) {
                    purchasedNonConsumables.append(nc)
                }
            case .nonRenewable:
                if let nonRenewable = availableNonRenewableSubscriptions.first(where: { $0.id == transaction.productID }) {
                    let currentDate = Date()
                    let expirationDate = Calendar(identifier: .gregorian).date(byAdding: DateComponents(year: 1),
                                                               to: transaction.purchaseDate)!

                    if currentDate < expirationDate {
                        purchasedNonRenewableSubscriptions.append(nonRenewable)
                    }
                }
            case .autoRenewable:
                if transaction.revocationDate == nil {
                    activeSubTransactions.append(transaction)
                }
                if let subscription = availableSubscriptions.first(where: { $0.id == transaction.productID }) {
                    DLog("Found valid entitlement. Subscription with exp date = \(String(describing: transaction.expirationDate))")
                    purchasedSubscriptions.append(subscription)
                } else {
                    DLog("Entitled to \(transaction.productID) but its Product is not loaded (product fetch failed/incomplete). Access will be granted from the transaction.")
                }
            default:
                break
            }
        } catch {
            print()
        }
    }

    //Update the store information with the purchased products.
    self.purchasedNonConsumables = purchasedNonConsumables
    self.purchasedNonRenewableSubscriptions = purchasedNonRenewableSubscriptions

    //Update the store information with auto-renewable subscription products.
    self.purchasedSubscriptions = purchasedSubscriptions

    //Authoritative entitlement transactions (independent of the product fetch succeeding).
    self.activeSubTransactions = activeSubTransactions
    subscriptionGroupStatus = try? await availableSubscriptions.first?.subscription?.status.first?.state
    
    // Callback
    IAPManager.shared.updateProStatus(isSureThatUserIsOnline: fromDeferredTransaction)
}