func (r *SyncResult) Fail(err error, msg string) {
	r.Error, r.Message = err, msg
}

// PodSyncResult is the summary result of SyncPod() and KillPod()
type PodSyncResult struct {
	// Result of different sync actions
	SyncResults []*SyncResult
	// Error encountered in SyncPod() and KillPod() that is not already included in SyncResults
	SyncError error
}

		if err := kl.mirrorPodClient.CreateMirrorPod(pod); err != nil {
			klog.ErrorS(err, "Failed creating a mirror pod", "pod", klog.KObj(pod))
		}
		mirrorPod, _ := kl.podManager.GetMirrorPodByPod(pod)
		if isTerminal, err = kl.SyncPod(ctx, kubetypes.SyncPodUpdate, pod, mirrorPod, status); err != nil {
			return fmt.Errorf("error syncing pod %q: %v", format.Pod(pod), err)
		}
		if retry >= runOnceMaxRetries {

const (
	_ SyncMarker = iota

	// Public markers (known to go/types importers).

	// Low-level coding markers.
	SyncEOF
	SyncBool
	SyncInt64
	SyncUint64
	SyncString
	SyncValue
	SyncVal
	SyncRelocs
	SyncReloc
	SyncUseReloc

	// Higher-level object and type markers.
	SyncPublic
	SyncPos
	SyncPosBase
	SyncObject
	SyncObject1
	SyncPkg
	SyncPkgDef
	SyncMethod
	SyncType
	SyncTypeIdx

	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[SyncEOF-1]
	_ = x[SyncBool-2]
	_ = x[SyncInt64-3]
	_ = x[SyncUint64-4]
	_ = x[SyncString-5]
	_ = x[SyncValue-6]
	_ = x[SyncVal-7]
	_ = x[SyncRelocs-8]
	_ = x[SyncReloc-9]
	_ = x[SyncUseReloc-10]
	_ = x[SyncPublic-11]
	_ = x[SyncPos-12]
	_ = x[SyncPosBase-13]
	_ = x[SyncObject-14]
	_ = x[SyncObject1-15]
	_ = x[SyncPkg-16]

			// or the proxier is fully synced.
			continue
		}

		if currentTime.Sub(hs.oldestPendingQueuedMap[ipFamily]) < hs.healthTimeout {
			// there's an unprocessed update queued for this proxier, but it's not late yet.
			continue
		}
		return false, proxierLastUpdated
	}
	return true, lastUpdated
}

// SyncNode syncs the node and determines if it is eligible or not. Eligible is

NAME       CLUSTER      CDS          LDS         EDS         RDS          ECDS         ISTIOD      VERSION
proxy1     cluster1     STALE        SYNCED      SYNCED      NOT SENT     SYNCED       istiod1     1.20
proxy2     cluster2     STALE        SYNCED      STALE       SYNCED       STALE        istiod2     1.19
proxy3     cluster3     NOT SENT     ERROR       STALE       NOT SENT     NOT SENT     istiod3     1.20

		o.name = fmt.Sprintf("Join[%v]", ptr.TypeName[T]())
	}
	synced := make(chan struct{})
	c := slices.Map(cs, func(e Collection[T]) internalCollection[T] {
		return e.(internalCollection[T])
	})
	go func() {
		for _, c := range c {
			if !c.Synced().WaitUntilSynced(o.stop) {
				return
			}
		}
		close(synced)
		log.Infof("%v synced", o.name)
	}()

NAME       CLUSTER      CDS       LDS        EDS        RDS          ECDS         ISTIOD      VERSION
proxy1     cluster1     STALE     SYNCED     SYNCED     NOT SENT     NOT SENT     istiod1     1.20

	_ Syncer = channelSyncer{}
	_ Syncer = pollSyncer{}
)

type channelSyncer struct {
	name   string
	synced <-chan struct{}
}

func (c channelSyncer) WaitUntilSynced(stop <-chan struct{}) bool {
	return waitForCacheSync(c.name, stop, c.synced)
}

func (c channelSyncer) HasSynced() bool {
	select {
	case <-c.synced:
		return true
	default:
		return false
	}
}

type pollSyncer struct {
	name string

var _ internalCollection[controllers.Object] = &informer[controllers.Object]{}

func (i *informer[I]) _internalHandler() {}

func (i *informer[I]) Synced() Syncer {
	return channelSyncer{
		name:   i.collectionName,
		synced: i.synced,
	}
}

// nolint: unused // (not true, its to implement an interface)
func (i *informer[I]) dump() {
	i.log.Errorf(">>> BEGIN DUMP")
	for _, obj := range i.inf.List(metav1.NamespaceAll, klabels.Everything()) {