Fewer surprises is the entire method.

OutboxSync.swift

actor OutboxSync {
    private let store: OutboxStore
    private let api: APIClient

    init(store: OutboxStore, api: APIClient) {
        self.store = store
        self.api = api
    }

    /// Sends queued writes in the order they were made.
    /// The idempotency key means a retry after a dropped
    /// connection can never create a duplicate record.
    func drain() async throws {
        for entry in try await store.pending() {
            try Task.checkCancellation()

            let outcome = await api.send(entry.payload, key: entry.id)
            switch outcome {
            case .delivered:
                try await store.markDelivered(entry.id)
            case .retryLater(let delay):
                try await store.scheduleRetry(entry.id, after: delay)
                return // Keep the order. Resume from here next pass.
            case .rejected(let reason):
                try await store.quarantine(entry.id, reason: reason)
            }
        }
    }
}

OutboxWorker.kt

class OutboxWorker(
    context: Context,
    params: WorkerParameters,
    private val store: OutboxStore,
    private val api: ApiClient,
) : CoroutineWorker(context, params) {

    // WorkManager runs this when the network returns,
    // even if the user closed the app hours ago.
    override suspend fun doWork(): Result {
        for (entry in store.pending()) {
            when (val outcome = api.send(entry.payload, entry.id)) {
                is Outcome.Delivered ->
                    store.markDelivered(entry.id)

                is Outcome.RetryLater ->
                    return Result.retry() // Keeps the queue in order.

                is Outcome.Rejected ->
                    store.quarantine(entry.id, outcome.reason)
            }
        }
        return Result.success()
    }
}

OutboxSync.cs

public sealed class OutboxSync(IOutboxStore store, IApiClient api)
{
    /// <summary>
    /// Sends queued writes in order. A rejected record is set aside
    /// for review, so one bad row never blocks the rest of the day.
    /// </summary>
    public async Task DrainAsync(CancellationToken ct)
    {
        await foreach (var entry in store.PendingAsync(ct))
        {
            var outcome = await api.SendAsync(entry.Payload, entry.Id, ct);

            switch (outcome)
            {
                case Delivered:
                    await store.MarkDeliveredAsync(entry.Id, ct);
                    break;
                case RetryLater retry:
                    await store.ScheduleRetryAsync(entry.Id, retry.Delay, ct);
                    return; // Keep the order. Resume from here next pass.
                case Rejected rejected:
                    await store.QuarantineAsync(entry.Id, rejected.Reason, ct);
                    break;
            }
        }
    }
}