Repository: kubernetes-sigs/kueue

Issue:
Flaky Test: TopologyAwareScheduling for RayJob when Creating a RayJob Should place pods based on the ranks-ordering
<!-- Please use this template while reporting a bug and provide as much info as possible. Not doing so may result in your bug not being addressed in a timely manner. Thanks!

If the matter is security related, please disclose it privately via https://kubernetes.io/security/
-->


**What happened**:
Failed the `End To End TAS Suite: kindest/node:v1.31.1: [It] TopologyAwareScheduling for RayJob when Creating a RayJob Should place pods based on the ranks-ordering` in periodic CI

```shell
{Timed out after 300.000s.
The function passed to Eventually failed at /home/prow/go/src/kubernetes-sigs/kueue/test/e2e/tas/rayjob_test.go:203 with:
Expected
    <[]v1.Pod | len:4, cap:4>: [
        {
            TypeMeta: {Kind: "", APIVersion: ""},
            ObjectMeta: {
                Name: "ranks-ray-raycluster-gpzrs-head-mm657",
                GenerateName: "ranks-ray-raycluster-gpzrs-head-",
                Namespace: "e2e-tas-rayjob-lgmbj",
                SelfLink: "",
                UID: "cbf00188-3d57-4dce-a72c-3c6827775792",
                ResourceVersion: "4265",
                Generation: 0,
                CreationTimestamp: {
                    Time: 2025-03-05T22:40:41Z,
                },
                DeletionTimestamp: nil,
                DeletionGracePeriodSeconds: nil,
                Labels: {
                    "kueue.x-k8s.io/tas": "true",
                    "ray.io/group": "headgroup",
                    "ray.io/identifier": "ranks-ray-raycluster-gpzrs-head",
                    "ray.io/is-ray-node": "yes",
                    "app.kubernetes.io/created-by": "kuberay-operator",
                    "kueue.x-k8s.io/podset": "head",
                    "ray.io/cluster": "ranks-ray-raycluster-gpzrs",
                    "ray.io/node-type": "head",
                    "app.kubernetes.io/name": "kuberay",
                },
                Annotations: {
                    "kueue.x-k8s.io/podset-preferred-topology": "cloud.provider.com/topology-rack",
                    "kueue.x-k8s.io/workload": "rayjob-ranks-ray-8120c",
                    "ray.io/ft-enabled": "false",
                },
                OwnerReferences: [
                    {
                        APIVersion: "ray.io/v1",
                        Kind: "RayCluster",
                        Name: "ranks-ray-raycluster-gpzrs",
                        UID: "0616b0a6-e920-481b-9516-db1f0880f2b1",
                        Controller: true,
                        BlockOwnerDeletion: true,
                    },
                ],
                Finalizers: nil,
                ManagedFields: [
                    {
                        Manager: "kuberay-operator",
                        Operation: "Update",
                        APIVersion: "v1",
                        Time: {
                            Time: 2025-03-05T22:40:41Z,
                        },
                        FieldsType: "FieldsV1",
                        FieldsV1: {
                            Raw: "{\"f:metadata\":{\"f:annotations\":{\".\":{},\"f:kueue.x-k8s.io/podset-preferred-topology\":{},\"f:kueue.x-k8s.io/workload\":{},\"f:ray.io/ft-enabled\":{}},\"f:generateName\":{},\"f:labels\":{\".\":{},\"f:app.kubernetes.io/created-by\":{},\"f:app.kubernetes.io/name\":{},\"f:kueue.x-k8s.io/podset\":{},\"f:kueue.x-k8s.io/tas\":{},\"f:ray.io/cluster\":{},\"f:ray.io/group\":{},\"f:ray.io/identifier\":{},\"f:ray.io/is-ray-node\":{},\"f:ray.io/node-type\":{}},\"f:ownerReferences\":{\".\":{},\"k:{\\\"uid\\\":\\\"0616b0a6-e920-481b-9516-db1f0880f2b1\\\"}\":{}}},\"f:spec\":{\"f:containers\":{\"k:{\\\"name\\\":\\\"head-container\\\"}\":{\".\":{},\"f:args\":{},\"f:command\":{},\"f:env\":{\".\":{},\"k:{\\\"name\\\":\\\"KUBERAY_GEN_RAY_START_CMD\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_ADDRESS\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_CLOUD_INSTANCE_ID\\\"}\":{\".\":{},\"f:name\":{},\"f:valueFrom\":{\".\":{},\"f:fieldRef\":{}}},\"k:{\\\"name\\\":\\\"RAY_CLUSTER_NAME\\\"}\":{\".\":{},\"f:name\":{},\"f:valueFrom\":{\".\":{},\"f:fieldRef\":{}}},\"k:{\\\"name\\\":\\\"RAY_DASHBOARD_ENABLE_K8S_DISK_USAGE\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_NODE_TYPE_NAME\\\"}\":{\".\":{},\"f:name\":{},\"f:valueFrom\":{\".\":{},\"f:fieldRef\":{}}},\"k:{\\\"name\\\":\\\"RAY_PORT\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_USAGE_STATS_EXTRA_TAGS\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_USAGE_STATS_KUBERAY_IN_USE\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"REDIS_PASSWORD\\\"}\":{\".\":{},\"f...

Gomega truncated this representation as it exceeds 'format.MaxLength'.
Consider having the object provide a custom 'GomegaStringer' representation
or adjust the parameters in Gomega's 'format' package.

Learn more here: https://onsi.github.io/gomega/#adjusting-output

to have length 5 failed [FAILED] Timed out after 300.000s.
The function passed to Eventually failed at /home/prow/go/src/kubernetes-sigs/kueue/test/e2e/tas/rayjob_test.go:203 with:
Expected
    <[]v1.Pod | len:4, cap:4>: [
        {
            TypeMeta: {Kind: "", APIVersion: ""},
            ObjectMeta: {
                Name: "ranks-ray-raycluster-gpzrs-head-mm657",
                GenerateName: "ranks-ray-raycluster-gpzrs-head-",
                Namespace: "e2e-tas-rayjob-lgmbj",
                SelfLink: "",
                UID: "cbf00188-3d57-4dce-a72c-3c6827775792",
                ResourceVersion: "4265",
                Generation: 0,
                CreationTimestamp: {
                    Time: 2025-03-05T22:40:41Z,
                },
                DeletionTimestamp: nil,
                DeletionGracePeriodSeconds: nil,
                Labels: {
                    "kueue.x-k8s.io/tas": "true",
                    "ray.io/group": "headgroup",
                    "ray.io/identifier": "ranks-ray-raycluster-gpzrs-head",
                    "ray.io/is-ray-node": "yes",
                    "app.kubernetes.io/created-by": "kuberay-operator",
                    "kueue.x-k8s.io/podset": "head",
                    "ray.io/cluster": "ranks-ray-raycluster-gpzrs",
                    "ray.io/node-type": "head",
                    "app.kubernetes.io/name": "kuberay",
                },
                Annotations: {
                    "kueue.x-k8s.io/podset-preferred-topology": "cloud.provider.com/topology-rack",
                    "kueue.x-k8s.io/workload": "rayjob-ranks-ray-8120c",
                    "ray.io/ft-enabled": "false",
                },
                OwnerReferences: [
                    {
                        APIVersion: "ray.io/v1",
                        Kind: "RayCluster",
                        Name: "ranks-ray-raycluster-gpzrs",
                        UID: "0616b0a6-e920-481b-9516-db1f0880f2b1",
                        Controller: true,
                        BlockOwnerDeletion: true,
                    },
                ],
                Finalizers: nil,
                ManagedFields: [
                    {
                        Manager: "kuberay-operator",
                        Operation: "Update",
                        APIVersion: "v1",
                        Time: {
                            Time: 2025-03-05T22:40:41Z,
                        },
                        FieldsType: "FieldsV1",
                        FieldsV1: {
                            Raw: "{\"f:metadata\":{\"f:annotations\":{\".\":{},\"f:kueue.x-k8s.io/podset-preferred-topology\":{},\"f:kueue.x-k8s.io/workload\":{},\"f:ray.io/ft-enabled\":{}},\"f:generateName\":{},\"f:labels\":{\".\":{},\"f:app.kubernetes.io/created-by\":{},\"f:app.kubernetes.io/name\":{},\"f:kueue.x-k8s.io/podset\":{},\"f:kueue.x-k8s.io/tas\":{},\"f:ray.io/cluster\":{},\"f:ray.io/group\":{},\"f:ray.io/identifier\":{},\"f:ray.io/is-ray-node\":{},\"f:ray.io/node-type\":{}},\"f:ownerReferences\":{\".\":{},\"k:{\\\"uid\\\":\\\"0616b0a6-e920-481b-9516-db1f0880f2b1\\\"}\":{}}},\"f:spec\":{\"f:containers\":{\"k:{\\\"name\\\":\\\"head-container\\\"}\":{\".\":{},\"f:args\":{},\"f:command\":{},\"f:env\":{\".\":{},\"k:{\\\"name\\\":\\\"KUBERAY_GEN_RAY_START_CMD\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_ADDRESS\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_CLOUD_INSTANCE_ID\\\"}\":{\".\":{},\"f:name\":{},\"f:valueFrom\":{\".\":{},\"f:fieldRef\":{}}},\"k:{\\\"name\\\":\\\"RAY_CLUSTER_NAME\\\"}\":{\".\":{},\"f:name\":{},\"f:valueFrom\":{\".\":{},\"f:fieldRef\":{}}},\"k:{\\\"name\\\":\\\"RAY_DASHBOARD_ENABLE_K8S_DISK_USAGE\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_NODE_TYPE_NAME\\\"}\":{\".\":{},\"f:name\":{},\"f:valueFrom\":{\".\":{},\"f:fieldRef\":{}}},\"k:{\\\"name\\\":\\\"RAY_PORT\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_USAGE_STATS_EXTRA_TAGS\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"RAY_USAGE_STATS_KUBERAY_IN_USE\\\"}\":{\".\":{},\"f:name\":{},\"f:value\":{}},\"k:{\\\"name\\\":\\\"REDIS_PASSWORD\\\"}\":{\".\":{},\"f...

Gomega truncated this representation as it exceeds 'format.MaxLength'.
Consider having the object provide a custom 'GomegaStringer' representation
or adjust the parameters in Gomega's 'format' package.

Learn more here: https://onsi.github.io/gomega/#adjusting-output

to have length 5
In [It] at: /home/prow/go/src/kubernetes-sigs/kueue/test/e2e/tas/rayjob_test.go:207 @ 03/05/25 22:45:41.951
}
```

**What you expected to happen**:
No errors

**How to reproduce it (as minimally and precisely as possible)**:

https://prow.k8s.io/view/gs/kubernetes-ci-logs/logs/periodic-kueue-test-e2e-tas-main/1897412525620727808

<img width="1261" alt="Image" src="https://github.com/user-attachments/assets/514c7460-678d-4d9c-b04f-c6df0a12789a" />

**Anything else we need to know?**:

**Environment**:
- Kubernetes version (use `kubectl version`):
- Kueue version (use `git describe --tags --dirty --always`):
- Cloud provider or hardware configuration:
- OS (e.g: `cat /etc/os-release`):
- Kernel (e.g. `uname -a`):
- Install tools:
- Others:

Hints from issue comments:
@mbobrovskyi: cc: @mszadkow @mimowo: btw, the error log is truncated. I suppose one of the pods failed for some reason (and was replaced - this is why we had 5 pods). To investigate this one could follow steps similar to https://github.com/kubernetes-sigs/kueue/issues/4495. 

However, another improvement would be to increase the MaxLength for the output - currently it is too short to fit even a single Pod with status - and the status would be the most relevant case here. 

I will open a dedicated issue for that.@mimowo: Opened: https://github.com/kubernetes-sigs/kueue/issues/4509@mszadkow: /assign@mszadkow: This timeout again after the increase to 5 minutes...that's weird, we need to have better insight when it fails, agree@mimowo: I think the key thing is that for some reason there was 5 pods, so probably one failed and was replaced. Try to identify the failed pod, then inspect its container logs, and logs of kubelet related to the pod (assuming the pod failure is the reason here).@mimowo: This seems like another occurrence, but on 0.10 branch: https://prow.k8s.io/view/gs/kubernetes-ci-logs/logs/periodic-kueue-test-e2e-tas-release-0-10/1898862090471346176@mszadkow: Ack, actively investigating this@mimowo: fyi, one more: https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_kueue/4524/pull-kueue-test-e2e-tas-main/1899040138269298688. Seems quite often recently@mbobrovskyi: one more: https://prow.k8s.io/view/gs/kubernetes-ci-logs/pr-logs/pull/kubernetes-sigs_kueue/4585/pull-kueue-test-e2e-tas-main/1900113461916995584@mszadkow: For this one I think we might want to change the approach.
This submitter job created by rayJob might be short lived and fall into the gap of interval.
What if we check ray cluster nodes, but later verify rayJob status, that should change after the submitter is finished anyway.
This could make it less flaky for tests while we still prove sanity of the RayJob with tas@mimowo: I looked into the Ray failures too

First, the tests fail expecting 5 pods, but they only observe 4. Looking at the API server logs we can confirm that RayOperator only created 4:

```
> cat api.log | grep e2e-tas-rayjob-lgmbj/pods | grep POST | grep 201
2025-03-05T22:40:41.977203895Z stderr F I0305 22:40:41.976983       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods" latency="11.586316ms" userAgent="kuberay-operator/v1.2.2" audit-ID="33e27fd2-d22d-4c4d-9b46-d4efeca06f05" srcIP="172.18.0.5:37344" apf_pl="workload-low" apf_fs="service-accounts" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="11.024848ms" resp=201
2025-03-05T22:40:42.025410431Z stderr F I0305 22:40:42.025081       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods" latency="8.426362ms" userAgent="kuberay-operator/v1.2.2" audit-ID="4d674538-ad9c-45f4-b055-dff0bd1db0a2" srcIP="172.18.0.5:37344" apf_pl="workload-low" apf_fs="service-accounts" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="8.135949ms" resp=201
2025-03-05T22:40:42.035689969Z stderr F I0305 22:40:42.035397       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods" latency="8.717217ms" userAgent="kuberay-operator/v1.2.2" audit-ID="42111a1c-315b-47bc-a77a-aeefaa2310c2" srcIP="172.18.0.5:37344" apf_pl="workload-low" apf_fs="service-accounts" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="8.339393ms" resp=201
2025-03-05T22:40:42.124730152Z stderr F I0305 22:40:42.124491       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods" latency="8.2536ms" userAgent="kuberay-operator/v1.2.2" audit-ID="fab4d7eb-ff9a-40cc-8cb1-d75d56f50c29" srcIP="172.18.0.5:37344" apf_pl="workload-low" apf_fs="service-accounts" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="7.949246ms" resp=201
2025-03-05T22:40:42.999711374Z stderr F I0305 22:40:42.999502       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods/ranks-ray-raycluster-gpzrs-head-mm657/binding" latency="3.6966ms" userAgent="kube-scheduler/v1.31.1 (linux/amd64) kubernetes/948afe5/scheduler" audit-ID="1af828d9-206a-4a8a-babe-407f9529889f" srcIP="172.18.0.4:40688" apf_pl="workload-high" apf_fs="kube-scheduler" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="3.282724ms" resp=201
2025-03-05T22:40:42.999746864Z stderr F I0305 22:40:42.999677       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods/ranks-ray-raycluster-gpzrs-workers-group-0-worker-d97p4/binding" latency="3.335175ms" userAgent="kube-scheduler/v1.31.1 (linux/amd64) kubernetes/948afe5/scheduler" audit-ID="402af477-ddef-48ea-9fcf-19f58cf7eb3f" srcIP="172.18.0.4:40688" apf_pl="workload-high" apf_fs="kube-scheduler" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="2.960229ms" resp=201
2025-03-05T22:40:43.000747168Z stderr F I0305 22:40:43.000337       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods/ranks-ray-raycluster-gpzrs-workers-group-0-worker-4g6fc/binding" latency="2.859619ms" userAgent="kube-scheduler/v1.31.1 (linux/amd64) kubernetes/948afe5/scheduler" audit-ID="fe2da5fa-309d-4575-91d1-40d63398db2b" srcIP="172.18.0.4:40688" apf_pl="workload-high" apf_fs="kube-scheduler" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="2.503914ms" resp=201
2025-03-05T22:40:43.002457031Z stderr F I0305 22:40:43.002218       1 httplog.go:134] "HTTP" verb="POST" URI="/api/v1/namespaces/e2e-tas-rayjob-lgmbj/pods/ranks-ray-raycluster-gpzrs-workers-group-0-worker-zqfwn/binding" latency="4.112935ms" userAgent="kube-scheduler/v1.31.1 (linux/amd64) kubernetes/948afe5/scheduler" audit-ID="54c48759-ad7b-4b77-b91e-a565ded1429b" srcIP="172.18.0.4:40688" apf_pl="workload-high" apf_fs="kube-scheduler" apf_iseats=1 apf_fseats=2 apf_additionalLatency="5ms" apf_execution_time="3.769201ms" resp=201
```
Also `> cat api.log | grep e2e-tas-rayjob-lgmbj/jobs | grep POST | grep 201` returns empty indicating the Submitter Job was never created.

To give more context I grepped the kuberay operator logs which show some errors:
```
> cat ray.log | grep e2e-tas-rayjob-lgmbj               
2025-03-05T22:40:41.691025738Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.690Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"5a22cd41-3f27-4aa3-8a54-d8e1735be202","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.691074429Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.690Z","logger":"controllers.RayJob","msg":"Add a finalizer","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"5a22cd41-3f27-4aa3-8a54-d8e1735be202","finalizer":"ray.io/rayjob-finalizer"}
2025-03-05T22:40:41.730733001Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.730Z","logger":"controllers.RayJob","msg":"JobDeploymentStatusNew","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"5a22cd41-3f27-4aa3-8a54-d8e1735be202","RayJob":"ranks-ray"}
2025-03-05T22:40:41.730743501Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.730Z","logger":"controllers.RayJob","msg":"initRayJobStatusIfNeed","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"5a22cd41-3f27-4aa3-8a54-d8e1735be202","shouldUpdateStatus":true,"RayJob":"ranks-ray","jobId":"","rayClusterName":"","jobStatus":""}
2025-03-05T22:40:41.730750971Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.730Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"5a22cd41-3f27-4aa3-8a54-d8e1735be202","oldRayJobStatus":{"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}},"newRayJobStatus":{"jobId":"ranks-ray-cmmqx","rayClusterName":"ranks-ray-raycluster-sr57x","jobDeploymentStatus":"Initializing","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}}}
2025-03-05T22:40:41.730781381Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.730Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"5a22cd41-3f27-4aa3-8a54-d8e1735be202","old JobStatus":"","new JobStatus":"","old JobDeploymentStatus":"","new JobDeploymentStatus":"Initializing"}
2025-03-05T22:40:41.74035455Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.740Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.74038324Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.740Z","logger":"controllers.RayJob","msg":"JobDeploymentStatusNew","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90","RayJob":"ranks-ray"}
2025-03-05T22:40:41.74039279Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.740Z","logger":"controllers.RayJob","msg":"initRayJobStatusIfNeed","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90","shouldUpdateStatus":true,"RayJob":"ranks-ray","jobId":"","rayClusterName":"","jobStatus":""}
2025-03-05T22:40:41.740412Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.740Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90","oldRayJobStatus":{"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}},"newRayJobStatus":{"jobId":"ranks-ray-qcdv2","rayClusterName":"ranks-ray-raycluster-669x2","jobDeploymentStatus":"Initializing","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}}}
2025-03-05T22:40:41.74041605Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.740Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90","old JobStatus":"","new JobStatus":"","old JobDeploymentStatus":"","new JobDeploymentStatus":"Initializing"}
2025-03-05T22:40:41.747129491Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.746Z","logger":"controllers.RayJob","msg":"Failed to update RayJob status","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90","error":"Operation cannot be fulfilled on rayjobs.ray.io \"ranks-ray\": the object has been modified; please apply your changes to the latest version and try again"}
2025-03-05T22:40:41.747149781Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.747Z","logger":"controllers.RayJob","msg":"Warning: Reconciler returned both a non-zero result and a non-nil error. The result will always be ignored if the error is non-nil and the non-nil error causes reqeueuing with exponential backoff. For more details, see: https://pkg.go.dev/sigs.k8s.io/controller-runtime/pkg/reconcile#Reconciler","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90"}
2025-03-05T22:40:41.747178671Z stderr F {"level":"error","ts":"2025-03-05T22:40:41.747Z","logger":"controllers.RayJob","msg":"Reconciler error","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"82ef785a-2582-44f0-87d6-d131e2ddee90","error":"Operation cannot be fulfilled on rayjobs.ray.io \"ranks-ray\": the object has been modified; please apply your changes to the latest version and try again","stacktrace":"sigs.k8s.io/controller-runtime/pkg/internal/controller.(*Controller).reconcileHandler\n\t/home/runner/go/pkg/mod/sigs.k8s.io/controller-runtime@v0.17.5/pkg/internal/controller/controller.go:329\nsigs.k8s.io/controller-runtime/pkg/internal/controller.(*Controller).processNextWorkItem\n\t/home/runner/go/pkg/mod/sigs.k8s.io/controller-runtime@v0.17.5/pkg/internal/controller/controller.go:266\nsigs.k8s.io/controller-runtime/pkg/internal/controller.(*Controller).Start.func2.2\n\t/home/runner/go/pkg/mod/sigs.k8s.io/controller-runtime@v0.17.5/pkg/internal/controller/controller.go:227"}
2025-03-05T22:40:41.747340263Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.747Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"9ea0d50f-11cb-4f19-b0f9-67d9fae463b5","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"Initializing","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.747351023Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.747Z","logger":"controllers.RayJob","msg":"Try to transition the status from `Initializing` to `Suspending`","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"9ea0d50f-11cb-4f19-b0f9-67d9fae463b5","RayJob":"ranks-ray"}
2025-03-05T22:40:41.747357754Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.747Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"9ea0d50f-11cb-4f19-b0f9-67d9fae463b5","oldRayJobStatus":{"jobId":"ranks-ray-cmmqx","rayClusterName":"ranks-ray-raycluster-sr57x","jobDeploymentStatus":"Initializing","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}},"newRayJobStatus":{"jobId":"ranks-ray-cmmqx","rayClusterName":"ranks-ray-raycluster-sr57x","jobDeploymentStatus":"Suspending","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}}}
2025-03-05T22:40:41.747373524Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.747Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"9ea0d50f-11cb-4f19-b0f9-67d9fae463b5","old JobStatus":"","new JobStatus":"","old JobDeploymentStatus":"Initializing","new JobDeploymentStatus":"Suspending"}
2025-03-05T22:40:41.816458069Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.816Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"1b4aac45-a7ca-4c4e-937d-db5893fa9ce8","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"Initializing","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.81648789Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.816Z","logger":"controllers.RayJob","msg":"Try to transition the status from `Initializing` to `Suspending`","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"1b4aac45-a7ca-4c4e-937d-db5893fa9ce8","RayJob":"ranks-ray"}
2025-03-05T22:40:41.81649374Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.816Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"1b4aac45-a7ca-4c4e-937d-db5893fa9ce8","oldRayJobStatus":{"jobId":"ranks-ray-cmmqx","rayClusterName":"ranks-ray-raycluster-sr57x","jobDeploymentStatus":"Initializing","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}},"newRayJobStatus":{"jobId":"ranks-ray-cmmqx","rayClusterName":"ranks-ray-raycluster-sr57x","jobDeploymentStatus":"Suspending","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}}}
2025-03-05T22:40:41.81649839Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.816Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"1b4aac45-a7ca-4c4e-937d-db5893fa9ce8","old JobStatus":"","new JobStatus":"","old JobDeploymentStatus":"Initializing","new JobDeploymentStatus":"Suspending"}
2025-03-05T22:40:41.82394229Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.823Z","logger":"controllers.RayJob","msg":"Failed to update RayJob status","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"1b4aac45-a7ca-4c4e-937d-db5893fa9ce8","error":"Operation cannot be fulfilled on rayjobs.ray.io \"ranks-ray\": the object has been modified; please apply your changes to the latest version and try again"}
2025-03-05T22:40:41.82396275Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.823Z","logger":"controllers.RayJob","msg":"Warning: Reconciler returned both a non-zero result and a non-nil error. The result will always be ignored if the error is non-nil and the non-nil error causes reqeueuing with exponential backoff. For more details, see: https://pkg.go.dev/sigs.k8s.io/controller-runtime/pkg/reconcile#Reconciler","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"1b4aac45-a7ca-4c4e-937d-db5893fa9ce8"}
2025-03-05T22:40:41.823982881Z stderr F {"level":"error","ts":"2025-03-05T22:40:41.823Z","logger":"controllers.RayJob","msg":"Reconciler error","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"1b4aac45-a7ca-4c4e-937d-db5893fa9ce8","error":"Operation cannot be fulfilled on rayjobs.ray.io \"ranks-ray\": the object has been modified; please apply your changes to the latest version and try again","stacktrace":"sigs.k8s.io/controller-runtime/pkg/internal/controller.(*Controller).reconcileHandler\n\t/home/runner/go/pkg/mod/sigs.k8s.io/controller-runtime@v0.17.5/pkg/internal/controller/controller.go:329\nsigs.k8s.io/controller-runtime/pkg/internal/controller.(*Controller).processNextWorkItem\n\t/home/runner/go/pkg/mod/sigs.k8s.io/controller-runtime@v0.17.5/pkg/internal/controller/controller.go:266\nsigs.k8s.io/controller-runtime/pkg/internal/controller.(*Controller).Start.func2.2\n\t/home/runner/go/pkg/mod/sigs.k8s.io/controller-runtime@v0.17.5/pkg/internal/controller/controller.go:227"}
2025-03-05T22:40:41.824197244Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.824Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"f07521e0-7c67-4257-b8d3-8dc5f4dea4f5","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"Suspending","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.824208124Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.824Z","logger":"controllers.RayJob","msg":"The associated RayCluster for RayJob has been already deleted and it can not be found","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"f07521e0-7c67-4257-b8d3-8dc5f4dea4f5","RayCluster":{"name":"ranks-ray-raycluster-sr57x","namespace":"e2e-tas-rayjob-lgmbj"},"RayJob":"ranks-ray"}
2025-03-05T22:40:41.824212334Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.824Z","logger":"controllers.RayJob","msg":"deleteClusterResources","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"f07521e0-7c67-4257-b8d3-8dc5f4dea4f5","isClusterDeleted":true}
2025-03-05T22:40:41.824235294Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.824Z","logger":"controllers.RayJob","msg":"The submitter Kubernetes Job has been already deleted","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"f07521e0-7c67-4257-b8d3-8dc5f4dea4f5","RayJob":"ranks-ray","Kubernetes Job":""}
2025-03-05T22:40:41.824245074Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.824Z","logger":"controllers.RayJob","msg":"deleteSubmitterJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"f07521e0-7c67-4257-b8d3-8dc5f4dea4f5","isJobDeleted":true}
2025-03-05T22:40:41.824268085Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.824Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"f07521e0-7c67-4257-b8d3-8dc5f4dea4f5","oldRayJobStatus":{"jobId":"ranks-ray-cmmqx","rayClusterName":"ranks-ray-raycluster-sr57x","jobDeploymentStatus":"Suspending","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}},"newRayJobStatus":{"jobDeploymentStatus":"Suspended","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}}}
2025-03-05T22:40:41.824272795Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.824Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"f07521e0-7c67-4257-b8d3-8dc5f4dea4f5","old JobStatus":"","new JobStatus":"","old JobDeploymentStatus":"Suspending","new JobDeploymentStatus":"Suspended"}
2025-03-05T22:40:41.915895512Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.915Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"e3781e9d-5a57-4d4c-b995-ee8a346246e1","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"Suspended","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.915933503Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.915Z","logger":"controllers.RayJob","msg":"The status is 'Suspended', but the suspend flag is false. Transition the status to 'New'.","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"e3781e9d-5a57-4d4c-b995-ee8a346246e1"}
2025-03-05T22:40:41.915943313Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.915Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"e3781e9d-5a57-4d4c-b995-ee8a346246e1","oldRayJobStatus":{"jobDeploymentStatus":"Suspended","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}},"newRayJobStatus":{"startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}}}
2025-03-05T22:40:41.915947083Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.915Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"e3781e9d-5a57-4d4c-b995-ee8a346246e1","old JobStatus":"","new JobStatus":"","old JobDeploymentStatus":"Suspended","new JobDeploymentStatus":""}
2025-03-05T22:40:41.928126647Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.927Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"d716e4ba-f93f-427b-935c-dfae9eec7d52","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.928151017Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.927Z","logger":"controllers.RayJob","msg":"JobDeploymentStatusNew","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"d716e4ba-f93f-427b-935c-dfae9eec7d52","RayJob":"ranks-ray"}
2025-03-05T22:40:41.928156777Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.927Z","logger":"controllers.RayJob","msg":"initRayJobStatusIfNeed","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"d716e4ba-f93f-427b-935c-dfae9eec7d52","shouldUpdateStatus":true,"RayJob":"ranks-ray","jobId":"","rayClusterName":"","jobStatus":""}
2025-03-05T22:40:41.928162858Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.927Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"d716e4ba-f93f-427b-935c-dfae9eec7d52","oldRayJobStatus":{"startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}},"newRayJobStatus":{"jobId":"ranks-ray-vzvd2","rayClusterName":"ranks-ray-raycluster-gpzrs","jobDeploymentStatus":"Initializing","startTime":"2025-03-05T22:40:41Z","succeeded":0,"failed":0,"rayClusterStatus":{"desiredCPU":"0","desiredMemory":"0","desiredGPU":"0","desiredTPU":"0","head":{}}}}
2025-03-05T22:40:41.928183918Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.928Z","logger":"controllers.RayJob","msg":"updateRayJobStatus","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"d716e4ba-f93f-427b-935c-dfae9eec7d52","old JobStatus":"","new JobStatus":"","old JobDeploymentStatus":"","new JobDeploymentStatus":"Initializing"}
2025-03-05T22:40:41.939842544Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.939Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"ace14a20-d46a-48ce-b78b-e792f4a93afc","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"Initializing","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.939879045Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.939Z","logger":"controllers.RayJob","msg":"try to find existing RayCluster instance","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"ace14a20-d46a-48ce-b78b-e792f4a93afc","name":"ranks-ray-raycluster-gpzrs"}
2025-03-05T22:40:41.939882965Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.939Z","logger":"controllers.RayJob","msg":"RayCluster not found","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"ace14a20-d46a-48ce-b78b-e792f4a93afc","RayJob":"ranks-ray","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"}}
2025-03-05T22:40:41.939886725Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.939Z","logger":"controllers.RayJob","msg":"RayCluster not found, creating RayCluster!","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"ace14a20-d46a-48ce-b78b-e792f4a93afc","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"}}
2025-03-05T22:40:41.959965164Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.959Z","logger":"controllers.RayJob","msg":"Found the associated RayCluster for RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"ace14a20-d46a-48ce-b78b-e792f4a93afc","RayJob":"ranks-ray","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"}}
2025-03-05T22:40:41.960283748Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.960Z","logger":"controllers.RayJob","msg":"Wait for the RayCluster.Status.State to be ready before submitting the job.","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"ace14a20-d46a-48ce-b78b-e792f4a93afc","RayCluster":"ranks-ray-raycluster-gpzrs","State":""}
2025-03-05T22:40:41.96039025Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.960Z","logger":"controllers.RayCluster","msg":"Reconciling Ingress","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2"}
2025-03-05T22:40:41.960543902Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.960Z","logger":"controllers.RayJob","msg":"RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"efb844e5-185c-4b5a-9702-eaf3d34be173","name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj","JobStatus":"","JobDeploymentStatus":"Initializing","SubmissionMode":"K8sJobMode"}
2025-03-05T22:40:41.960555872Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.960Z","logger":"controllers.RayJob","msg":"try to find existing RayCluster instance","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"efb844e5-185c-4b5a-9702-eaf3d34be173","name":"ranks-ray-raycluster-gpzrs"}
2025-03-05T22:40:41.960561152Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.960Z","logger":"controllers.RayJob","msg":"Found the associated RayCluster for RayJob","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"efb844e5-185c-4b5a-9702-eaf3d34be173","RayJob":"ranks-ray","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"}}
2025-03-05T22:40:41.960836436Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.960Z","logger":"controllers.RayJob","msg":"Wait for the RayCluster.Status.State to be ready before submitting the job.","RayJob":{"name":"ranks-ray","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"efb844e5-185c-4b5a-9702-eaf3d34be173","RayCluster":"ranks-ray-raycluster-gpzrs","State":""}
2025-03-05T22:40:41.964783758Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.964Z","logger":"controllers.RayCluster","msg":"Created service for RayCluster","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2","name":"ranks-ray-raycluster-gpzrs-head-svc"}
2025-03-05T22:40:41.964833089Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.964Z","logger":"controllers.RayCluster","msg":"reconcilePods","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2","Found 0 head Pods; creating a head Pod for the RayCluster.":"ranks-ray-raycluster-gpzrs"}
2025-03-05T22:40:41.964956361Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.964Z","logger":"controllers.RayCluster","msg":"head pod labels","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2","labels":{"app.kubernetes.io/created-by":"kuberay-operator","app.kubernetes.io/name":"kuberay","kueue.x-k8s.io/podset":"head","kueue.x-k8s.io/tas":"true","ray.io/cluster":"ranks-ray-raycluster-gpzrs","ray.io/group":"headgroup","ray.io/identifier":"ranks-ray-raycluster-gpzrs-head","ray.io/is-ray-node":"yes","ray.io/node-type":"head"}}
2025-03-05T22:40:41.964969311Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.964Z","logger":"controllers.RayCluster","msg":"generateRayStartCommand","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2","nodeType":"head","rayStartParams":{"block":"true","dashboard-agent-listen-port":"52365","dashboard-host":"0.0.0.0","metrics-export-port":"8080"},"Ray container resource":{"limits":{"cpu":"100m"},"requests":{"cpu":"100m"}}}
2025-03-05T22:40:41.964974551Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.964Z","logger":"controllers.RayCluster","msg":"generateRayStartCommand","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2","rayStartCmd":"ray start --head  --num-cpus=1  --dashboard-host=0.0.0.0  --metrics-export-port=8080  --block  --dashboard-agent-listen-port=52365 "}
2025-03-05T22:40:41.964990721Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.964Z","logger":"controllers.RayCluster","msg":"BuildPod","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2","rayNodeType":"head","generatedCmd":"ulimit -n 65536; ray start --head  --num-cpus=1  --dashboard-host=0.0.0.0  --metrics-export-port=8080  --block  --dashboard-agent-listen-port=52365 "}
2025-03-05T22:40:41.965002051Z stderr F {"level":"info","ts":"2025-03-05T22:40:41.964Z","logger":"controllers.RayCluster","msg":"Probes injection feature flag","RayCluster":{"name":"ranks-ray-raycluster-gpzrs","namespace":"e2e-tas-rayjob-lgmbj"},"reconcileID":"40c15835-bf09-4127-bb0b-cbc807ce37c2","enabled":true}
```

So some interesting logs are **The associated RayCluster for RayJob has been already deleted and it can not be found**, or **The submitter Kubernetes Job has been already deleted** at `2025-03-05T22:40:41.824` even though the kube-apiserver logs don't show any DELETE requests to the Ray APIs in this perdiod. Maybe there is some racing with the creation events not being delivered on time?

So, I expect this is actually a bug / flake in KubeRay 1.2.2. 

cc @andrewsykim have you seen something like this? If so, is this fixed in 1.3.x?@mimowo: cc @tenzen-y @tenzen-y: Thank you for investigating this one. If this actually KubeRay side bug, we can skip this case until this fixes are shipped from KubeRay.
@mimowo: > For this one I think we might want to change the approach.

I synced with @andrewsykim who says the issue looks "vaguely familiar", and there is some chance it is already fixed in 1.3. So instead of refactoring or relaxing tests we can just wait a bit. 

cc @mszadkow @tenzen-y: > > For this one I think we might want to change the approach.
> 
> I synced with [@andrewsykim](https://github.com/andrewsykim) who says the issue looks "vaguely familiar", and there is some chance it is already fixed in 1.3. So instead of refactoring or relaxing tests we can just wait a bit.
> 
> cc [@mszadkow](https://github.com/mszadkow)

Thank you for letting me know.

Solution patch:
diff --git a/Makefile-test.mk b/Makefile-test.mk
index 85f55cdc7..77679b5a1 100644
--- a/Makefile-test.mk
+++ b/Makefile-test.mk
@@ -89,7 +89,7 @@ test-integration: gomod-download envtest ginkgo dep-crds kueuectl ginkgo-top ##
 	KUEUE_BIN=$(PROJECT_DIR)/bin \
 	ENVTEST_K8S_VERSION=$(ENVTEST_K8S_VERSION) \
 	API_LOG_LEVEL=$(INTEGRATION_API_LOG_LEVEL) \
-	$(GINKGO) $(INTEGRATION_FILTERS) $(GINKGO_ARGS) -procs=$(INTEGRATION_NPROCS) --race --junit-report=junit.xml --json-report=integration.json --output-dir=$(ARTIFACTS) -v $(INTEGRATION_TARGET)
+	$(GINKGO) $(INTEGRATION_FILTERS) $(GINKGO_ARGS) $(GOFLAGS) -procs=$(INTEGRATION_NPROCS) --race --junit-report=junit.xml --json-report=integration.json --output-dir=$(ARTIFACTS) -v $(INTEGRATION_TARGET)
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/integration.json > $(ARTIFACTS)/integration-top.yaml
 
 .PHONY: test-multikueue-integration
@@ -99,7 +99,7 @@ test-multikueue-integration: gomod-download envtest ginkgo dep-crds kueuectl gin
 	KUEUE_BIN=$(PROJECT_DIR)/bin \
 	ENVTEST_K8S_VERSION=$(ENVTEST_K8S_VERSION) \
 	API_LOG_LEVEL=$(INTEGRATION_API_LOG_LEVEL) \
-	$(GINKGO) $(INTEGRATION_FILTERS) $(GINKGO_ARGS) -procs=$(INTEGRATION_NPROCS_MULTIKUEUE) --race --junit-report=multikueue-junit.xml --json-report=multikueue-integration.json --output-dir=$(ARTIFACTS) -v $(INTEGRATION_TARGET_MULTIKUEUE)
+	$(GINKGO) $(INTEGRATION_FILTERS) $(GINKGO_ARGS) $(GOFLAGS) -procs=$(INTEGRATION_NPROCS_MULTIKUEUE) --race --junit-report=multikueue-junit.xml --json-report=multikueue-integration.json --output-dir=$(ARTIFACTS) -v $(INTEGRATION_TARGET_MULTIKUEUE)
 	$(PROJECT_DIR)/bin/ginkgo-top -i $(ARTIFACTS)/multikueue-integration.json > $(ARTIFACTS)/multikueue-integration-top.yaml
 
 CREATE_KIND_CLUSTER ?= true
diff --git a/apis/kueue/v1alpha1/cohort_types.go b/apis/kueue/v1alpha1/cohort_types.go
index 994afed3e..c8355b975 100644
--- a/apis/kueue/v1alpha1/cohort_types.go
+++ b/apis/kueue/v1alpha1/cohort_types.go
@@ -34,11 +34,7 @@ type CohortSpec struct {
 	// Cohort, including ClusterQueues, until the cycle is
 	// removed.  We prevent further admission while the cycle
 	// exists.
-	//
-	//+kubebuilder:validation:MaxLength=253
-	//+kubebuilder:validation:Pattern="^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$"
-	//
-	Parent string `json:"parent,omitempty"`
+	Parent kueuebeta.CohortReference `json:"parent,omitempty"`
 
 	// ResourceGroups describes groupings of Resources and
 	// Flavors.  Each ResourceGroup defines a list of Resources
diff --git a/apis/kueue/v1beta1/clusterqueue_types.go b/apis/kueue/v1beta1/clusterqueue_types.go
index 0a5b9cd84..289fdb02c 100644
--- a/apis/kueue/v1beta1/clusterqueue_types.go
+++ b/apis/kueue/v1beta1/clusterqueue_types.go
@@ -39,6 +39,14 @@ const (
 	ClusterQueueActiveReasonReady                                           = "Ready"
 )
 
+// CohortReference is the name of the Cohort.
+//
+// Validation of a cohort name is equivalent to that of object names:
+// subdomain in DNS (RFC 1123).
+// +kubebuilder:validation:MaxLength=253
+// +kubebuilder:validation:Pattern="^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$"
+type CohortReference string
+
 // ClusterQueueSpec defines the desired state of ClusterQueue
 // +kubebuilder:validation:XValidation:rule="!has(self.cohort) && has(self.resourceGroups) ? self.resourceGroups.all(rg, rg.flavors.all(f, f.resources.all(r, !has(r.borrowingLimit)))) : true", message="borrowingLimit must be nil when cohort is empty"
 type ClusterQueueSpec struct {
@@ -63,12 +71,7 @@ type ClusterQueueSpec struct {
 	//
 	// A cohort is a name that links CQs together, but it doesn't reference any
 	// object.
-	//
-	// Validation of a cohort name is equivalent to that of object names:
-	// subdomain in DNS (RFC 1123).
-	// +kubebuilder:validation:MaxLength=253
-	// +kubebuilder:validation:Pattern="^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$"
-	Cohort string `json:"cohort,omitempty"`
+	Cohort CohortReference `json:"cohort,omitempty"`
 
 	// QueueingStrategy indicates the queueing strategy of the workloads
 	// across the queues in this ClusterQueue.
diff --git a/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml b/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml
index 8c897921b..fdb3ebe8b 100644
--- a/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml
+++ b/charts/kueue/templates/crd/kueue.x-k8s.io_clusterqueues.yaml
@@ -126,9 +126,6 @@ spec:
 
                   A cohort is a name that links CQs together, but it doesn't reference any
                   object.
-
-                  Validation of a cohort name is equivalent to that of object names:
-                  subdomain in DNS (RFC 1123).
                 maxLength: 253
                 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
                 type: string
diff --git a/charts/kueue/values.yaml b/charts/kueue/values.yaml
index 5418db198..06360e595 100644
--- a/charts/kueue/values.yaml
+++ b/charts/kueue/values.yaml
@@ -137,7 +137,7 @@ metricsService:
     - name: metrics
       port: 8443
       protocol: TCP
-      targetPort: metrics
+      targetPort: 8443
   type: ClusterIP
   annotations: {}
 webhookService:
diff --git a/client-go/applyconfiguration/kueue/v1beta1/clusterqueuespec.go b/client-go/applyconfiguration/kueue/v1beta1/clusterqueuespec.go
index 0c55acf5c..52564a1f9 100644
--- a/client-go/applyconfiguration/kueue/v1beta1/clusterqueuespec.go
+++ b/client-go/applyconfiguration/kueue/v1beta1/clusterqueuespec.go
@@ -26,7 +26,7 @@ import (
 // with apply.
 type ClusterQueueSpecApplyConfiguration struct {
 	ResourceGroups          []ResourceGroupApplyConfiguration          `json:"resourceGroups,omitempty"`
-	Cohort                  *string                                    `json:"cohort,omitempty"`
+	Cohort                  *kueuev1beta1.CohortReference              `json:"cohort,omitempty"`
 	QueueingStrategy        *kueuev1beta1.QueueingStrategy             `json:"queueingStrategy,omitempty"`
 	NamespaceSelector       *v1.LabelSelectorApplyConfiguration        `json:"namespaceSelector,omitempty"`
 	FlavorFungibility       *FlavorFungibilityApplyConfiguration       `json:"flavorFungibility,omitempty"`
@@ -59,7 +59,7 @@ func (b *ClusterQueueSpecApplyConfiguration) WithResourceGroups(values ...*Resou
 // WithCohort sets the Cohort field in the declarative configuration to the given value
 // and returns the receiver, so that objects can be built by chaining "With" function invocations.
 // If called multiple times, the Cohort field is set to the value of the last call.
-func (b *ClusterQueueSpecApplyConfiguration) WithCohort(value string) *ClusterQueueSpecApplyConfiguration {
+func (b *ClusterQueueSpecApplyConfiguration) WithCohort(value kueuev1beta1.CohortReference) *ClusterQueueSpecApplyConfiguration {
 	b.Cohort = &value
 	return b
 }
diff --git a/cmd/kueuectl/app/create/create_clusterqueue.go b/cmd/kueuectl/app/create/create_clusterqueue.go
index 9af3496b3..9d5dbc08a 100644
--- a/cmd/kueuectl/app/create/create_clusterqueue.go
+++ b/cmd/kueuectl/app/create/create_clusterqueue.go
@@ -269,7 +269,7 @@ func (o *ClusterQueueOptions) createClusterQueue() *v1beta1.ClusterQueue {
 		TypeMeta:   metav1.TypeMeta{APIVersion: v1beta1.SchemeGroupVersion.String(), Kind: "ClusterQueue"},
 		ObjectMeta: metav1.ObjectMeta{Name: o.Name},
 		Spec: v1beta1.ClusterQueueSpec{
-			Cohort:            o.Cohort,
+			Cohort:            v1beta1.CohortReference(o.Cohort),
 			QueueingStrategy:  o.QueueingStrategy,
 			NamespaceSelector: &o.NamespaceSelector,
 			Preemption: &v1beta1.ClusterQueuePreemption{
diff --git a/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml b/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml
index c1d9ea011..efde49856 100644
--- a/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml
+++ b/config/components/crd/bases/kueue.x-k8s.io_clusterqueues.yaml
@@ -111,9 +111,6 @@ spec:
 
                   A cohort is a name that links CQs together, but it doesn't reference any
                   object.
-
-                  Validation of a cohort name is equivalent to that of object names:
-                  subdomain in DNS (RFC 1123).
                 maxLength: 253
                 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$
                 type: string
diff --git a/go.mod b/go.mod
index dcbb980d7..ea169bbe7 100644
--- a/go.mod
+++ b/go.mod
@@ -9,17 +9,17 @@ require (
 	github.com/json-iterator/go v1.1.12
 	github.com/kubeflow/mpi-operator v0.6.0
 	github.com/kubeflow/training-operator v1.9.0
-	github.com/onsi/ginkgo/v2 v2.22.2
+	github.com/onsi/ginkgo/v2 v2.23.0
 	github.com/onsi/gomega v1.36.2
 	github.com/open-policy-agent/cert-controller v0.12.0
 	github.com/project-codeflare/appwrapper v1.0.6
-	github.com/prometheus/client_golang v1.21.0
+	github.com/prometheus/client_golang v1.21.1
 	github.com/prometheus/client_model v0.6.1
 	github.com/ray-project/kuberay/ray-operator v1.2.2
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/pflag v1.0.6
 	go.uber.org/zap v1.27.0
-	gomodules.xyz/jsonpatch/v2 v2.4.0
+	gomodules.xyz/jsonpatch/v2 v2.5.0
 	k8s.io/api v0.32.2
 	k8s.io/apimachinery v0.32.2
 	k8s.io/apiserver v0.32.2
@@ -36,7 +36,7 @@ require (
 	sigs.k8s.io/controller-runtime v0.20.2
 	sigs.k8s.io/jobset v0.8.0
 	sigs.k8s.io/lws v0.5.1
-	sigs.k8s.io/structured-merge-diff/v4 v4.5.0
+	sigs.k8s.io/structured-merge-diff/v4 v4.6.0
 	sigs.k8s.io/yaml v1.4.0
 )
 
@@ -122,17 +122,17 @@ require (
 	go.opentelemetry.io/proto/otlp v1.3.1 // indirect
 	go.uber.org/atomic v1.11.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/crypto v0.33.0 // indirect
 	golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 // indirect
-	golang.org/x/mod v0.22.0 // indirect
-	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/mod v0.23.0 // indirect
+	golang.org/x/net v0.35.0 // indirect
 	golang.org/x/oauth2 v0.24.0 // indirect
-	golang.org/x/sync v0.10.0 // indirect
-	golang.org/x/sys v0.29.0 // indirect
-	golang.org/x/term v0.28.0 // indirect
-	golang.org/x/text v0.21.0 // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/term v0.29.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
 	golang.org/x/time v0.7.0 // indirect
-	golang.org/x/tools v0.29.0 // indirect
+	golang.org/x/tools v0.30.0 // indirect
 	google.golang.org/genproto v0.0.0-20240528184218-531527333157 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20240826202546-f6391c0de4c7 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20240826202546-f6391c0de4c7 // indirect
diff --git a/go.sum b/go.sum
index dab92ecb7..282a1898c 100644
--- a/go.sum
+++ b/go.sum
@@ -150,8 +150,8 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f h1:y5//uYreIhSUg3J1GEMiLbxo1LJaP8RfCpH6pymGZus=
 github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f/go.mod h1:ZdcZmHo+o7JKHSa8/e818NopupXU1YMK5fe1lsApnBw=
-github.com/onsi/ginkgo/v2 v2.22.2 h1:/3X8Panh8/WwhU/3Ssa6rCKqPLuAkVY2I0RoyDLySlU=
-github.com/onsi/ginkgo/v2 v2.22.2/go.mod h1:oeMosUL+8LtarXBHu/c0bx2D/K9zyQ6uX3cTyztHwsk=
+github.com/onsi/ginkgo/v2 v2.23.0 h1:FA1xjp8ieYDzlgS5ABTpdUDB7wtngggONc8a7ku2NqQ=
+github.com/onsi/ginkgo/v2 v2.23.0/go.mod h1:zXTP6xIp3U8aVuXN8ENK9IXRaTjFnpVB9mGmaSRvxnM=
 github.com/onsi/gomega v1.36.2 h1:koNYke6TVk6ZmnyHrCXba/T/MoLBXFjeC1PtvYgw0A8=
 github.com/onsi/gomega v1.36.2/go.mod h1:DdwyADRjrc825LhMEkD76cHR5+pUnjhUN8GlHlRPHzY=
 github.com/open-policy-agent/cert-controller v0.12.0 h1:RKXlBafMcCh+++I1geJetXo77tAjyb4542DQc/+aZIw=
@@ -169,8 +169,8 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/project-codeflare/appwrapper v1.0.6 h1:byIL9vOFvTAgkAYYQtOcO7DR05Up6iSaH8Gp8UumWi8=
 github.com/project-codeflare/appwrapper v1.0.6/go.mod h1:lNTOQCv4qu05bngU5C6Bl0whXBjP3490FvY4Biy4q7g=
-github.com/prometheus/client_golang v1.21.0 h1:DIsaGmiaBkSangBgMtWdNfxbMNdku5IK6iNhrEqWvdA=
-github.com/prometheus/client_golang v1.21.0/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
+github.com/prometheus/client_golang v1.21.1 h1:DOvXXTqVzvkIewV/CDPFdejpMCGeMcbGCQ8YOmu+Ibk=
+github.com/prometheus/client_golang v1.21.1/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
 github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
 github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
 github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=
@@ -263,54 +263,54 @@ go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
+golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
 golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 h1:e66Fs6Z+fZTbFBAxKfP3PALWBtpfqks2bwGcexMxgtk=
 golang.org/x/exp v0.0.0-20240909161429-701f63a606c0/go.mod h1:2TbTHSBQa924w8M6Xs1QcRcFwyucIwBGpK1p2f1YFFY=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4=
-golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
+golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM=
+golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
-golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
+golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
 golang.org/x/oauth2 v0.24.0 h1:KTBBxWqUa0ykRPLtV69rRto9TLXcqYkeswu48x/gvNE=
 golang.org/x/oauth2 v0.24.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
-golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
-golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/time v0.7.0 h1:ntUhktv3OPE6TgYxXWv9vKvUSJyIFJlyohwbkEwPrKQ=
 golang.org/x/time v0.7.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.29.0 h1:Xx0h3TtM9rzQpQuR4dKLrdglAmCEN5Oi+P74JdhdzXE=
-golang.org/x/tools v0.29.0/go.mod h1:KMQVMRsVxU6nHCFXrBPhDB8XncLNLM0lIy/F14RP588=
+golang.org/x/tools v0.30.0 h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY=
+golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gomodules.xyz/jsonpatch/v2 v2.4.0 h1:Ci3iUJyx9UeRx7CeFN8ARgGbkESwJK+KB9lLcWxY/Zw=
-gomodules.xyz/jsonpatch/v2 v2.4.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY=
+gomodules.xyz/jsonpatch/v2 v2.5.0 h1:JELs8RLM12qJGXU4u/TO3V25KW8GreMKl9pdkk14RM0=
+gomodules.xyz/jsonpatch/v2 v2.5.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY=
 google.golang.org/genproto v0.0.0-20240528184218-531527333157 h1:u7WMYrIrVvs0TF5yaKwKNbcJyySYf+HAIFXxWltJOXE=
 google.golang.org/genproto v0.0.0-20240528184218-531527333157/go.mod h1:ubQlAQnzejB8uZzszhrTCU2Fyp6Vi7ZE5nn0c3W8+qQ=
 google.golang.org/genproto/googleapis/api v0.0.0-20240826202546-f6391c0de4c7 h1:YcyjlL1PRr2Q17/I0dPk2JmYS5CDXfcdb2Z3YRioEbw=
@@ -383,7 +383,9 @@ sigs.k8s.io/kustomize/kyaml v0.18.1 h1:WvBo56Wzw3fjS+7vBjN6TeivvpbW9GmRaWZ9CIVmt
 sigs.k8s.io/kustomize/kyaml v0.18.1/go.mod h1:C3L2BFVU1jgcddNBE1TxuVLgS46TjObMwW5FT9FcjYo=
 sigs.k8s.io/lws v0.5.1 h1:eaeMNkP0manRluQZLN32atoULaGrzP611gSLdFaHZs4=
 sigs.k8s.io/lws v0.5.1/go.mod h1:qprXSTTFnfmPZY3V3sUfk6ZPmAodsdoKS8XVElJ9kN0=
-sigs.k8s.io/structured-merge-diff/v4 v4.5.0 h1:nbCitCK2hfnhyiKo6uf2HxUPTCodY6Qaf85SbDIaMBk=
-sigs.k8s.io/structured-merge-diff/v4 v4.5.0/go.mod h1:N8f93tFZh9U6vpxwRArLiikrE5/2tiu1w1AGfACIGE4=
+sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016 h1:kXv6kKdoEtedwuqMmkqhbkgvYKeycVbC8+iPCP9j5kQ=
+sigs.k8s.io/randfill v0.0.0-20250304075658-069ef1bbf016/go.mod h1:XeLlZ/jmk4i1HRopwe7/aU3H5n1zNUcX6TM94b3QxOY=
+sigs.k8s.io/structured-merge-diff/v4 v4.6.0 h1:IUA9nvMmnKWcj5jl84xn+T5MnlZKThmUW1TdblaLVAc=
+sigs.k8s.io/structured-merge-diff/v4 v4.6.0/go.mod h1:dDy58f92j70zLsuZVuUX5Wp9vtxXpaZnkPGWeqDfCps=
 sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
 sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
diff --git a/hack/internal/tools/go.mod b/hack/internal/tools/go.mod
index 2c39552fb..d1f1b630c 100644
--- a/hack/internal/tools/go.mod
+++ b/hack/internal/tools/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/gohugoio/hugo v0.145.0
 	github.com/golangci/golangci-lint v1.64.6
 	github.com/mikefarah/yq/v4 v4.45.1
-	github.com/onsi/ginkgo/v2 v2.22.2
+	github.com/onsi/ginkgo/v2 v2.23.0
 	gopkg.in/yaml.v3 v3.0.1
 	gotest.tools/gotestsum v1.12.0
 	helm.sh/helm/v3 v3.17.1
diff --git a/hack/internal/tools/go.sum b/hack/internal/tools/go.sum
index 36742667e..f2ec59c1f 100644
--- a/hack/internal/tools/go.sum
+++ b/hack/internal/tools/go.sum
@@ -195,8 +195,8 @@ github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
 github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
-github.com/onsi/ginkgo/v2 v2.22.2 h1:/3X8Panh8/WwhU/3Ssa6rCKqPLuAkVY2I0RoyDLySlU=
-github.com/onsi/ginkgo/v2 v2.22.2/go.mod h1:oeMosUL+8LtarXBHu/c0bx2D/K9zyQ6uX3cTyztHwsk=
+github.com/onsi/ginkgo/v2 v2.23.0 h1:FA1xjp8ieYDzlgS5ABTpdUDB7wtngggONc8a7ku2NqQ=
+github.com/onsi/ginkgo/v2 v2.23.0/go.mod h1:zXTP6xIp3U8aVuXN8ENK9IXRaTjFnpVB9mGmaSRvxnM=
 github.com/onsi/gomega v1.36.2 h1:koNYke6TVk6ZmnyHrCXba/T/MoLBXFjeC1PtvYgw0A8=
 github.com/onsi/gomega v1.36.2/go.mod h1:DdwyADRjrc825LhMEkD76cHR5+pUnjhUN8GlHlRPHzY=
 github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
diff --git a/pkg/cache/cache.go b/pkg/cache/cache.go
index d6172a602..1869fe036 100644
--- a/pkg/cache/cache.go
+++ b/pkg/cache/cache.go
@@ -102,7 +102,7 @@ type Cache struct {
 	podsReadyCond sync.Cond
 
 	client              client.Client
-	assumedWorkloads    map[string]string
+	assumedWorkloads    map[string]kueue.ClusterQueueReference
 	resourceFlavors     map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor
 	podsReadyTracking   bool
 	admissionChecks     map[string]AdmissionCheck
@@ -121,7 +121,7 @@ func New(client client.Client, opts ...Option) *Cache {
 	}
 	c := &Cache{
 		client:              client,
-		assumedWorkloads:    make(map[string]string),
+		assumedWorkloads:    make(map[string]kueue.ClusterQueueReference),
 		resourceFlavors:     make(map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor),
 		admissionChecks:     make(map[string]AdmissionCheck),
 		podsReadyTracking:   options.podsReadyTracking,
@@ -136,7 +136,7 @@ func New(client client.Client, opts ...Option) *Cache {
 
 func (c *Cache) newClusterQueue(cq *kueue.ClusterQueue) (*clusterQueue, error) {
 	cqImpl := &clusterQueue{
-		Name:                cq.Name,
+		Name:                kueue.ClusterQueueReference(cq.Name),
 		Workloads:           make(map[string]*workload.Info),
 		WorkloadsNotReady:   sets.New[string](),
 		localQueues:         make(map[string]*queue),
@@ -147,7 +147,7 @@ func (c *Cache) newClusterQueue(cq *kueue.ClusterQueue) (*clusterQueue, error) {
 		tasCache:            &c.tasCache,
 	}
 	c.hm.AddClusterQueue(cqImpl)
-	c.hm.UpdateClusterQueueEdge(cq.Name, cq.Spec.Cohort)
+	c.hm.UpdateClusterQueueEdge(kueue.ClusterQueueReference(cq.Name), cq.Spec.Cohort)
 	if err := cqImpl.updateClusterQueue(c.hm.CycleChecker, cq, c.resourceFlavors, c.admissionChecks, nil); err != nil {
 		return nil, err
 	}
@@ -194,7 +194,7 @@ func (c *Cache) PodsReadyForAllAdmittedWorkloads(log logr.Logger) bool {
 func (c *Cache) podsReadyForAllAdmittedWorkloads(log logr.Logger) bool {
 	for _, cq := range c.hm.ClusterQueues() {
 		if len(cq.WorkloadsNotReady) > 0 {
-			log.V(3).Info("There is a ClusterQueue with not ready workloads", "clusterQueue", klog.KRef("", cq.Name))
+			log.V(3).Info("There is a ClusterQueue with not ready workloads", "clusterQueue", klog.KRef("", string(cq.Name)))
 			return false
 		}
 	}
@@ -212,8 +212,8 @@ func (c *Cache) CleanUpOnContext(ctx context.Context) {
 	c.podsReadyCond.Broadcast()
 }
 
-func (c *Cache) updateClusterQueues() sets.Set[string] {
-	cqs := sets.New[string]()
+func (c *Cache) updateClusterQueues() sets.Set[kueue.ClusterQueueReference] {
+	cqs := sets.New[kueue.ClusterQueueReference]()
 
 	for _, cq := range c.hm.ClusterQueues() {
 		prevStatus := cq.Status
@@ -230,10 +230,10 @@ func (c *Cache) updateClusterQueues() sets.Set[string] {
 	return cqs
 }
 
-func (c *Cache) ActiveClusterQueues() sets.Set[string] {
+func (c *Cache) ActiveClusterQueues() sets.Set[kueue.ClusterQueueReference] {
 	c.RLock()
 	defer c.RUnlock()
-	cqs := sets.New[string]()
+	cqs := sets.New[kueue.ClusterQueueReference]()
 	for _, cq := range c.hm.ClusterQueues() {
 		if cq.Status == active {
 			cqs.Insert(cq.Name)
@@ -246,21 +246,21 @@ func (c *Cache) TASCache() *TASCache {
 	return &c.tasCache
 }
 
-func (c *Cache) AddOrUpdateResourceFlavor(rf *kueue.ResourceFlavor) sets.Set[string] {
+func (c *Cache) AddOrUpdateResourceFlavor(rf *kueue.ResourceFlavor) sets.Set[kueue.ClusterQueueReference] {
 	c.Lock()
 	defer c.Unlock()
 	c.resourceFlavors[kueue.ResourceFlavorReference(rf.Name)] = rf
 	return c.updateClusterQueues()
 }
 
-func (c *Cache) DeleteResourceFlavor(rf *kueue.ResourceFlavor) sets.Set[string] {
+func (c *Cache) DeleteResourceFlavor(rf *kueue.ResourceFlavor) sets.Set[kueue.ClusterQueueReference] {
 	c.Lock()
 	defer c.Unlock()
 	delete(c.resourceFlavors, kueue.ResourceFlavorReference(rf.Name))
 	return c.updateClusterQueues()
 }
 
-func (c *Cache) AddOrUpdateTopologyForFlavor(topology *kueuealpha.Topology, flv *kueue.ResourceFlavor) sets.Set[string] {
+func (c *Cache) AddOrUpdateTopologyForFlavor(topology *kueuealpha.Topology, flv *kueue.ResourceFlavor) sets.Set[kueue.ClusterQueueReference] {
 	c.Lock()
 	defer c.Unlock()
 	levels := utiltas.Levels(topology)
@@ -269,14 +269,14 @@ func (c *Cache) AddOrUpdateTopologyForFlavor(topology *kueuealpha.Topology, flv
 	return c.updateClusterQueues()
 }
 
-func (c *Cache) DeleteTopologyForFlavor(flv kueue.ResourceFlavorReference) sets.Set[string] {
+func (c *Cache) DeleteTopologyForFlavor(flv kueue.ResourceFlavorReference) sets.Set[kueue.ClusterQueueReference] {
 	c.Lock()
 	defer c.Unlock()
 	c.tasCache.Delete(flv)
 	return c.updateClusterQueues()
 }
 
-func (c *Cache) AddOrUpdateAdmissionCheck(ac *kueue.AdmissionCheck) sets.Set[string] {
+func (c *Cache) AddOrUpdateAdmissionCheck(ac *kueue.AdmissionCheck) sets.Set[kueue.ClusterQueueReference] {
 	c.Lock()
 	defer c.Unlock()
 
@@ -296,14 +296,14 @@ func (c *Cache) AddOrUpdateAdmissionCheck(ac *kueue.AdmissionCheck) sets.Set[str
 	return c.updateClusterQueues()
 }
 
-func (c *Cache) DeleteAdmissionCheck(ac *kueue.AdmissionCheck) sets.Set[string] {
+func (c *Cache) DeleteAdmissionCheck(ac *kueue.AdmissionCheck) sets.Set[kueue.ClusterQueueReference] {
 	c.Lock()
 	defer c.Unlock()
 	delete(c.admissionChecks, ac.Name)
 	return c.updateClusterQueues()
 }
 
-func (c *Cache) AdmissionChecksForClusterQueue(cqName string) []AdmissionCheck {
+func (c *Cache) AdmissionChecksForClusterQueue(cqName kueue.ClusterQueueReference) []AdmissionCheck {
 	c.RLock()
 	defer c.RUnlock()
 	cq := c.hm.ClusterQueue(cqName)
@@ -319,15 +319,15 @@ func (c *Cache) AdmissionChecksForClusterQueue(cqName string) []AdmissionCheck {
 	return acs
 }
 
-func (c *Cache) ClusterQueueActive(name string) bool {
+func (c *Cache) ClusterQueueActive(name kueue.ClusterQueueReference) bool {
 	return c.clusterQueueInStatus(name, active)
 }
 
-func (c *Cache) ClusterQueueTerminating(name string) bool {
+func (c *Cache) ClusterQueueTerminating(name kueue.ClusterQueueReference) bool {
 	return c.clusterQueueInStatus(name, terminating)
 }
 
-func (c *Cache) ClusterQueueReadiness(name string) (metav1.ConditionStatus, string, string) {
+func (c *Cache) ClusterQueueReadiness(name kueue.ClusterQueueReference) (metav1.ConditionStatus, string, string) {
 	c.RLock()
 	defer c.RUnlock()
 	cq := c.hm.ClusterQueue(name)
@@ -341,7 +341,7 @@ func (c *Cache) ClusterQueueReadiness(name string) (metav1.ConditionStatus, stri
 	return metav1.ConditionFalse, reason, msg
 }
 
-func (c *Cache) clusterQueueInStatus(name string, status metrics.ClusterQueueStatus) bool {
+func (c *Cache) clusterQueueInStatus(name kueue.ClusterQueueReference, status metrics.ClusterQueueStatus) bool {
 	c.RLock()
 	defer c.RUnlock()
 
@@ -352,7 +352,7 @@ func (c *Cache) clusterQueueInStatus(name string, status metrics.ClusterQueueSta
 	return cq.Status == status
 }
 
-func (c *Cache) TerminateClusterQueue(name string) {
+func (c *Cache) TerminateClusterQueue(name kueue.ClusterQueueReference) {
 	c.Lock()
 	defer c.Unlock()
 	if cq := c.hm.ClusterQueue(name); cq != nil {
@@ -364,7 +364,7 @@ func (c *Cache) TerminateClusterQueue(name string) {
 // ClusterQueueEmpty indicates whether there's any active workload admitted by
 // the provided clusterQueue.
 // Return true if the clusterQueue doesn't exist.
-func (c *Cache) ClusterQueueEmpty(name string) bool {
+func (c *Cache) ClusterQueueEmpty(name kueue.ClusterQueueReference) bool {
 	c.RLock()
 	defer c.RUnlock()
 	cq := c.hm.ClusterQueue(name)
@@ -378,7 +378,7 @@ func (c *Cache) AddClusterQueue(ctx context.Context, cq *kueue.ClusterQueue) err
 	c.Lock()
 	defer c.Unlock()
 
-	if oldCq := c.hm.ClusterQueue(cq.Name); oldCq != nil {
+	if oldCq := c.hm.ClusterQueue(kueue.ClusterQueueReference(cq.Name)); oldCq != nil {
 		return errors.New("ClusterQueue already exists")
 	}
 	cqImpl, err := c.newClusterQueue(cq)
@@ -422,12 +422,12 @@ func (c *Cache) AddClusterQueue(ctx context.Context, cq *kueue.ClusterQueue) err
 func (c *Cache) UpdateClusterQueue(cq *kueue.ClusterQueue) error {
 	c.Lock()
 	defer c.Unlock()
-	cqImpl := c.hm.ClusterQueue(cq.Name)
+	cqImpl := c.hm.ClusterQueue(kueue.ClusterQueueReference(cq.Name))
 	if cqImpl == nil {
 		return ErrCqNotFound
 	}
 	oldParent := cqImpl.Parent()
-	c.hm.UpdateClusterQueueEdge(cq.Name, cq.Spec.Cohort)
+	c.hm.UpdateClusterQueueEdge(kueue.ClusterQueueReference(cq.Name), cq.Spec.Cohort)
 	if err := cqImpl.updateClusterQueue(c.hm.CycleChecker, cq, c.resourceFlavors, c.admissionChecks, oldParent); err != nil {
 		return err
 	}
@@ -443,30 +443,32 @@ func (c *Cache) UpdateClusterQueue(cq *kueue.ClusterQueue) error {
 func (c *Cache) DeleteClusterQueue(cq *kueue.ClusterQueue) {
 	c.Lock()
 	defer c.Unlock()
-	curCq := c.hm.ClusterQueue(cq.Name)
+	cqName := kueue.ClusterQueueReference(cq.Name)
+	curCq := c.hm.ClusterQueue(cqName)
 	if curCq == nil {
 		return
 	}
 	if features.Enabled(features.LocalQueueMetrics) {
-		for _, q := range c.hm.ClusterQueue(cq.Name).localQueues {
+		for _, q := range c.hm.ClusterQueue(cqName).localQueues {
 			metrics.ClearLocalQueueCacheMetrics(metrics.LQRefFromLocalQueueKey(q.key))
 		}
 	}
-	c.hm.DeleteClusterQueue(cq.Name)
+	c.hm.DeleteClusterQueue(cqName)
 	metrics.ClearCacheMetrics(cq.Name)
 }
 
 func (c *Cache) AddOrUpdateCohort(apiCohort *kueuealpha.Cohort) error {
 	c.Lock()
 	defer c.Unlock()
-	c.hm.AddCohort(apiCohort.Name)
-	cohort := c.hm.Cohort(apiCohort.Name)
+	cohortName := kueue.CohortReference(apiCohort.Name)
+	c.hm.AddCohort(cohortName)
+	cohort := c.hm.Cohort(cohortName)
 	oldParent := cohort.Parent()
-	c.hm.UpdateCohortEdge(apiCohort.Name, apiCohort.Spec.Parent)
+	c.hm.UpdateCohortEdge(cohortName, apiCohort.Spec.Parent)
 	return cohort.updateCohort(c.hm.CycleChecker, apiCohort, oldParent)
 }
 
-func (c *Cache) DeleteCohort(cohortName string) {
+func (c *Cache) DeleteCohort(cohortName kueue.CohortReference) {
 	c.Lock()
 	defer c.Unlock()
 	c.hm.DeleteCohort(cohortName)
@@ -482,7 +484,7 @@ func (c *Cache) DeleteCohort(cohortName string) {
 func (c *Cache) AddLocalQueue(q *kueue.LocalQueue) error {
 	c.Lock()
 	defer c.Unlock()
-	cq := c.hm.ClusterQueue(string(q.Spec.ClusterQueue))
+	cq := c.hm.ClusterQueue(q.Spec.ClusterQueue)
 	if cq == nil {
 		return nil
 	}
@@ -492,7 +494,7 @@ func (c *Cache) AddLocalQueue(q *kueue.LocalQueue) error {
 func (c *Cache) DeleteLocalQueue(q *kueue.LocalQueue) {
 	c.Lock()
 	defer c.Unlock()
-	cq := c.hm.ClusterQueue(string(q.Spec.ClusterQueue))
+	cq := c.hm.ClusterQueue(q.Spec.ClusterQueue)
 	if cq == nil {
 		return
 	}
@@ -505,11 +507,11 @@ func (c *Cache) UpdateLocalQueue(oldQ, newQ *kueue.LocalQueue) error {
 	}
 	c.Lock()
 	defer c.Unlock()
-	cq := c.hm.ClusterQueue(string(oldQ.Spec.ClusterQueue))
+	cq := c.hm.ClusterQueue(oldQ.Spec.ClusterQueue)
 	if cq != nil {
 		cq.deleteLocalQueue(oldQ)
 	}
-	cq = c.hm.ClusterQueue(string(newQ.Spec.ClusterQueue))
+	cq = c.hm.ClusterQueue(newQ.Spec.ClusterQueue)
 	if cq != nil {
 		return cq.addLocalQueue(newQ)
 	}
@@ -527,7 +529,7 @@ func (c *Cache) addOrUpdateWorkload(w *kueue.Workload) bool {
 		return false
 	}
 
-	clusterQueue := c.hm.ClusterQueue(string(w.Status.Admission.ClusterQueue))
+	clusterQueue := c.hm.ClusterQueue(w.Status.Admission.ClusterQueue)
 	if clusterQueue == nil {
 		return false
 	}
@@ -548,7 +550,7 @@ func (c *Cache) UpdateWorkload(oldWl, newWl *kueue.Workload) error {
 	c.Lock()
 	defer c.Unlock()
 	if workload.HasQuotaReservation(oldWl) {
-		cq := c.hm.ClusterQueue(string(oldWl.Status.Admission.ClusterQueue))
+		cq := c.hm.ClusterQueue(oldWl.Status.Admission.ClusterQueue)
 		if cq == nil {
 			return errors.New("old ClusterQueue doesn't exist")
 		}
@@ -559,7 +561,7 @@ func (c *Cache) UpdateWorkload(oldWl, newWl *kueue.Workload) error {
 	if !workload.HasQuotaReservation(newWl) {
 		return nil
 	}
-	cq := c.hm.ClusterQueue(string(newWl.Status.Admission.ClusterQueue))
+	cq := c.hm.ClusterQueue(newWl.Status.Admission.ClusterQueue)
 	if cq == nil {
 		return errors.New("new ClusterQueue doesn't exist")
 	}
@@ -617,7 +619,7 @@ func (c *Cache) AssumeWorkload(w *kueue.Workload) error {
 		return fmt.Errorf("the workload is already assumed to ClusterQueue %q", assumedCq)
 	}
 
-	cq := c.hm.ClusterQueue(string(w.Status.Admission.ClusterQueue))
+	cq := c.hm.ClusterQueue(w.Status.Admission.ClusterQueue)
 	if cq == nil {
 		return ErrCqNotFound
 	}
@@ -625,7 +627,7 @@ func (c *Cache) AssumeWorkload(w *kueue.Workload) error {
 	if err := cq.addWorkload(w); err != nil {
 		return err
 	}
-	c.assumedWorkloads[k] = string(w.Status.Admission.ClusterQueue)
+	c.assumedWorkloads[k] = w.Status.Admission.ClusterQueue
 	return nil
 }
 
@@ -642,7 +644,7 @@ func (c *Cache) ForgetWorkload(w *kueue.Workload) error {
 		return errWorkloadNotAdmitted
 	}
 
-	cq := c.hm.ClusterQueue(string(w.Status.Admission.ClusterQueue))
+	cq := c.hm.ClusterQueue(w.Status.Admission.ClusterQueue)
 	if cq == nil {
 		return ErrCqNotFound
 	}
@@ -666,7 +668,7 @@ func (c *Cache) Usage(cqObj *kueue.ClusterQueue) (*ClusterQueueUsageStats, error
 	c.RLock()
 	defer c.RUnlock()
 
-	cq := c.hm.ClusterQueue(cqObj.Name)
+	cq := c.hm.ClusterQueue(kueue.ClusterQueueReference(cqObj.Name))
 	if cq == nil {
 		return nil, ErrCqNotFound
 	}
@@ -733,7 +735,7 @@ func (c *Cache) LocalQueueUsage(qObj *kueue.LocalQueue) (*LocalQueueUsageStats,
 	c.RLock()
 	defer c.RUnlock()
 
-	cqImpl := c.hm.ClusterQueue(string(qObj.Spec.ClusterQueue))
+	cqImpl := c.hm.ClusterQueue(qObj.Spec.ClusterQueue)
 	if cqImpl == nil {
 		return &LocalQueueUsageStats{}, nil
 	}
@@ -810,7 +812,7 @@ func (c *Cache) cleanupAssumedState(w *kueue.Workload) {
 	if assumed {
 		// If the workload's assigned ClusterQueue is different from the assumed
 		// one, then we should also clean up the assumed one.
-		if workload.HasQuotaReservation(w) && assumedCQName != string(w.Status.Admission.ClusterQueue) {
+		if workload.HasQuotaReservation(w) && assumedCQName != w.Status.Admission.ClusterQueue {
 			if assumedCQ := c.hm.ClusterQueue(assumedCQName); assumedCQ != nil {
 				assumedCQ.deleteWorkload(w)
 			}
@@ -821,7 +823,7 @@ func (c *Cache) cleanupAssumedState(w *kueue.Workload) {
 
 func (c *Cache) clusterQueueForWorkload(w *kueue.Workload) *clusterQueue {
 	if workload.HasQuotaReservation(w) {
-		return c.hm.ClusterQueue(string(w.Status.Admission.ClusterQueue))
+		return c.hm.ClusterQueue(w.Status.Admission.ClusterQueue)
 	}
 	wKey := workload.Key(w)
 	for _, cq := range c.hm.ClusterQueues() {
@@ -832,10 +834,10 @@ func (c *Cache) clusterQueueForWorkload(w *kueue.Workload) *clusterQueue {
 	return nil
 }
 
-func (c *Cache) ClusterQueuesUsingFlavor(flavor kueue.ResourceFlavorReference) []string {
+func (c *Cache) ClusterQueuesUsingFlavor(flavor kueue.ResourceFlavorReference) []kueue.ClusterQueueReference {
 	c.RLock()
 	defer c.RUnlock()
-	var cqs []string
+	var cqs []kueue.ClusterQueueReference
 
 	for _, cq := range c.hm.ClusterQueues() {
 		if cq.flavorInUse(flavor) {
@@ -845,10 +847,10 @@ func (c *Cache) ClusterQueuesUsingFlavor(flavor kueue.ResourceFlavorReference) [
 	return cqs
 }
 
-func (c *Cache) ClusterQueuesUsingTopology(tName kueue.TopologyReference) []string {
+func (c *Cache) ClusterQueuesUsingTopology(tName kueue.TopologyReference) []kueue.ClusterQueueReference {
 	c.RLock()
 	defer c.RUnlock()
-	var cqs []string
+	var cqs []kueue.ClusterQueueReference
 
 	for _, cq := range c.hm.ClusterQueues() {
 		for _, tRef := range cq.tasFlavors {
@@ -860,10 +862,10 @@ func (c *Cache) ClusterQueuesUsingTopology(tName kueue.TopologyReference) []stri
 	return cqs
 }
 
-func (c *Cache) ClusterQueuesUsingAdmissionCheck(ac string) []string {
+func (c *Cache) ClusterQueuesUsingAdmissionCheck(ac string) []kueue.ClusterQueueReference {
 	c.RLock()
 	defer c.RUnlock()
-	var cqs []string
+	var cqs []kueue.ClusterQueueReference
 
 	for _, cq := range c.hm.ClusterQueues() {
 		if _, found := cq.AdmissionChecks[ac]; found {
@@ -873,11 +875,11 @@ func (c *Cache) ClusterQueuesUsingAdmissionCheck(ac string) []string {
 	return cqs
 }
 
-func (c *Cache) MatchingClusterQueues(nsLabels map[string]string) sets.Set[string] {
+func (c *Cache) MatchingClusterQueues(nsLabels map[string]string) sets.Set[kueue.ClusterQueueReference] {
 	c.RLock()
 	defer c.RUnlock()
 
-	cqs := sets.New[string]()
+	cqs := sets.New[kueue.ClusterQueueReference]()
 	for _, cq := range c.hm.ClusterQueues() {
 		if cq.NamespaceSelector.Matches(labels.Set(nsLabels)) {
 			cqs.Insert(cq.Name)
diff --git a/pkg/cache/clusterqueue.go b/pkg/cache/clusterqueue.go
index 79f48ba40..b79ac2e1f 100644
--- a/pkg/cache/clusterqueue.go
+++ b/pkg/cache/clusterqueue.go
@@ -48,7 +48,7 @@ var (
 // clusterQueue is the internal implementation of kueue.clusterQueue that
 // holds admitted workloads.
 type clusterQueue struct {
-	Name              string
+	Name              kueue.ClusterQueueReference
 	ResourceGroups    []ResourceGroup
 	Workloads         map[string]*workload.Info
 	WorkloadsNotReady sets.Set[string]
@@ -88,7 +88,7 @@ type clusterQueue struct {
 	tasCache *TASCache
 }
 
-func (c *clusterQueue) GetName() string {
+func (c *clusterQueue) GetName() kueue.ClusterQueueReference {
 	return c.Name
 }
 
@@ -485,8 +485,8 @@ func (c *clusterQueue) deleteWorkload(w *kueue.Workload) {
 }
 
 func (c *clusterQueue) reportActiveWorkloads() {
-	metrics.AdmittedActiveWorkloads.WithLabelValues(c.Name).Set(float64(c.admittedWorkloadsCount))
-	metrics.ReservingActiveWorkloads.WithLabelValues(c.Name).Set(float64(len(c.Workloads)))
+	metrics.AdmittedActiveWorkloads.WithLabelValues(string(c.Name)).Set(float64(c.admittedWorkloadsCount))
+	metrics.ReservingActiveWorkloads.WithLabelValues(string(c.Name)).Set(float64(len(c.Workloads)))
 }
 
 func (q *queue) reportActiveWorkloads() {
diff --git a/pkg/cache/clusterqueue_snapshot.go b/pkg/cache/clusterqueue_snapshot.go
index 54bb07a37..a628cd2ac 100644
--- a/pkg/cache/clusterqueue_snapshot.go
+++ b/pkg/cache/clusterqueue_snapshot.go
@@ -34,7 +34,7 @@ import (
 )
 
 type ClusterQueueSnapshot struct {
-	Name              string
+	Name              kueue.ClusterQueueReference
 	ResourceGroups    []ResourceGroup
 	Workloads         map[string]*workload.Info
 	WorkloadsNotReady sets.Set[string]
@@ -157,7 +157,7 @@ func (c *ClusterQueueSnapshot) PotentialAvailable(fr resources.FlavorResource) i
 	return potentialAvailable(c, fr)
 }
 
-func (c *ClusterQueueSnapshot) GetName() string {
+func (c *ClusterQueueSnapshot) GetName() kueue.ClusterQueueReference {
 	return c.Name
 }
 
diff --git a/pkg/cache/cohort.go b/pkg/cache/cohort.go
index 6e693c354..b92540164 100644
--- a/pkg/cache/cohort.go
+++ b/pkg/cache/cohort.go
@@ -20,12 +20,13 @@ import (
 	"k8s.io/apimachinery/pkg/api/resource"
 
 	kueuealpha "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/hierarchy"
 )
 
 // cohort is a set of ClusterQueues that can borrow resources from each other.
 type cohort struct {
-	Name string
+	Name kueue.CohortReference
 	hierarchy.Cohort[*clusterQueue, *cohort]
 
 	resourceNode ResourceNode
@@ -33,7 +34,7 @@ type cohort struct {
 	FairWeight resource.Quantity
 }
 
-func newCohort(name string) *cohort {
+func newCohort(name kueue.CohortReference) *cohort {
 	return &cohort{
 		Name:         name,
 		Cohort:       hierarchy.NewCohort[*clusterQueue, *cohort](),
@@ -52,7 +53,7 @@ func (c *cohort) updateCohort(cycleChecker hierarchy.CycleChecker, apiCohort *ku
 	return updateCohortTreeResources(c, cycleChecker)
 }
 
-func (c *cohort) GetName() string {
+func (c *cohort) GetName() kueue.CohortReference {
 	return c.Name
 }
 
@@ -75,7 +76,7 @@ func (c *cohort) parentHRN() hierarchicalResourceNode {
 
 // implement hierarchy.CycleCheckable interface
 
-func (c *cohort) CCParent() hierarchy.CycleCheckable {
+func (c *cohort) CCParent() hierarchy.CycleCheckable[kueue.CohortReference] {
 	return c.Parent()
 }
 
diff --git a/pkg/cache/cohort_snapshot.go b/pkg/cache/cohort_snapshot.go
index b626483d3..29b02f19b 100644
--- a/pkg/cache/cohort_snapshot.go
+++ b/pkg/cache/cohort_snapshot.go
@@ -19,11 +19,12 @@ package cache
 import (
 	"k8s.io/apimachinery/pkg/api/resource"
 
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/hierarchy"
 )
 
 type CohortSnapshot struct {
-	Name string
+	Name kueue.CohortReference
 
 	ResourceNode ResourceNode
 	hierarchy.Cohort[*ClusterQueueSnapshot, *CohortSnapshot]
@@ -31,7 +32,7 @@ type CohortSnapshot struct {
 	FairWeight resource.Quantity
 }
 
-func (c *CohortSnapshot) GetName() string {
+func (c *CohortSnapshot) GetName() kueue.CohortReference {
 	return c.Name
 }
 
diff --git a/pkg/cache/snapshot.go b/pkg/cache/snapshot.go
index 660376080..e4c4c74b0 100644
--- a/pkg/cache/snapshot.go
+++ b/pkg/cache/snapshot.go
@@ -36,7 +36,7 @@ import (
 type Snapshot struct {
 	hierarchy.Manager[*ClusterQueueSnapshot, *CohortSnapshot]
 	ResourceFlavors          map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor
-	InactiveClusterQueueSets sets.Set[string]
+	InactiveClusterQueueSets sets.Set[kueue.ClusterQueueReference]
 }
 
 // RemoveWorkload removes a workload from its corresponding ClusterQueue and
@@ -59,11 +59,11 @@ func (s *Snapshot) Log(log logr.Logger) {
 	for name, cq := range s.ClusterQueues() {
 		cohortName := "<none>"
 		if cq.HasParent() {
-			cohortName = cq.Parent().Name
+			cohortName = string(cq.Parent().Name)
 		}
 
 		log.Info("Found ClusterQueue",
-			"clusterQueue", klog.KRef("", name),
+			"clusterQueue", klog.KRef("", string(name)),
 			"cohort", cohortName,
 			"resourceGroups", cq.ResourceGroups,
 			"usage", cq.ResourceNode.Usage,
@@ -86,7 +86,7 @@ func (c *Cache) Snapshot(ctx context.Context) (*Snapshot, error) {
 	snap := Snapshot{
 		Manager:                  hierarchy.NewManager(newCohortSnapshot),
 		ResourceFlavors:          make(map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor, len(c.resourceFlavors)),
-		InactiveClusterQueueSets: sets.New[string](),
+		InactiveClusterQueueSets: sets.New[kueue.ClusterQueueReference](),
 	}
 	for _, cohort := range c.hm.Cohorts() {
 		if c.hm.CycleChecker.HasCycle(cohort) {
@@ -158,7 +158,7 @@ func snapshotClusterQueue(c *clusterQueue) *ClusterQueueSnapshot {
 	return cc
 }
 
-func newCohortSnapshot(name string) *CohortSnapshot {
+func newCohortSnapshot(name kueue.CohortReference) *CohortSnapshot {
 	return &CohortSnapshot{
 		Name:   name,
 		Cohort: hierarchy.NewCohort[*ClusterQueueSnapshot, *CohortSnapshot](),
diff --git a/pkg/controller/core/clusterqueue_controller.go b/pkg/controller/core/clusterqueue_controller.go
index 700501bec..a284d7435 100644
--- a/pkg/controller/core/clusterqueue_controller.go
+++ b/pkg/controller/core/clusterqueue_controller.go
@@ -65,7 +65,7 @@ type ClusterQueueReconciler struct {
 	log                                  logr.Logger
 	qManager                             *queue.Manager
 	cache                                *cache.Cache
-	snapshotsQueue                       workqueue.TypedInterface[string]
+	snapshotsQueue                       workqueue.TypedInterface[kueue.ClusterQueueReference]
 	wlUpdateCh                           chan event.GenericEvent
 	rfUpdateCh                           chan event.GenericEvent
 	acUpdateCh                           chan event.GenericEvent
@@ -144,7 +144,7 @@ func NewClusterQueueReconciler(
 		log:                                  ctrl.Log.WithName("cluster-queue-reconciler"),
 		qManager:                             qMgr,
 		cache:                                cache,
-		snapshotsQueue:                       workqueue.NewTyped[string](),
+		snapshotsQueue:                       workqueue.NewTyped[kueue.ClusterQueueReference](),
 		wlUpdateCh:                           make(chan event.GenericEvent, updateChBuffer),
 		rfUpdateCh:                           make(chan event.GenericEvent, updateChBuffer),
 		acUpdateCh:                           make(chan event.GenericEvent, updateChBuffer),
@@ -185,14 +185,14 @@ func (r *ClusterQueueReconciler) Reconcile(ctx context.Context, req ctrl.Request
 			}
 		}
 	} else {
-		if !r.cache.ClusterQueueTerminating(cqObj.Name) {
-			r.cache.TerminateClusterQueue(cqObj.Name)
+		if !r.cache.ClusterQueueTerminating(kueue.ClusterQueueReference(cqObj.Name)) {
+			r.cache.TerminateClusterQueue(kueue.ClusterQueueReference(cqObj.Name))
 		}
 
 		if controllerutil.ContainsFinalizer(&cqObj, kueue.ResourceInUseFinalizerName) {
 			// The clusterQueue is being deleted, remove the finalizer only if
 			// there are no active reserving workloads.
-			if r.cache.ClusterQueueEmpty(cqObj.Name) {
+			if r.cache.ClusterQueueEmpty(kueue.ClusterQueueReference(cqObj.Name)) {
 				controllerutil.RemoveFinalizer(&cqObj, kueue.ResourceInUseFinalizerName)
 				if err := r.client.Update(ctx, &cqObj); err != nil {
 					return ctrl.Result{}, client.IgnoreNotFound(err)
@@ -203,7 +203,7 @@ func (r *ClusterQueueReconciler) Reconcile(ctx context.Context, req ctrl.Request
 	}
 
 	newCQObj := cqObj.DeepCopy()
-	cqCondition, reason, msg := r.cache.ClusterQueueReadiness(newCQObj.Name)
+	cqCondition, reason, msg := r.cache.ClusterQueueReadiness(kueue.ClusterQueueReference(newCQObj.Name))
 	if err := r.updateCqStatusIfChanged(ctx, newCQObj, cqCondition, reason, msg); err != nil {
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
@@ -495,9 +495,9 @@ func (h *cqWorkloadHandler) Generic(_ context.Context, e event.GenericEvent, q w
 }
 
 func (h *cqWorkloadHandler) requestForWorkloadClusterQueue(w *kueue.Workload) *reconcile.Request {
-	var name string
+	var name kueue.ClusterQueueReference
 	if workload.HasQuotaReservation(w) {
-		name = string(w.Status.Admission.ClusterQueue)
+		name = w.Status.Admission.ClusterQueue
 	} else {
 		var ok bool
 		name, ok = h.qManager.ClusterQueueForWorkload(w)
@@ -507,7 +507,7 @@ func (h *cqWorkloadHandler) requestForWorkloadClusterQueue(w *kueue.Workload) *r
 	}
 	return &reconcile.Request{
 		NamespacedName: types.NamespacedName{
-			Name: name,
+			Name: string(name),
 		},
 	}
 }
@@ -526,7 +526,7 @@ func (h *cqNamespaceHandler) Update(ctx context.Context, e event.UpdateEvent, _
 	oldMatchingCqs := h.cache.MatchingClusterQueues(oldNs.Labels)
 	newNs := e.ObjectNew.(*corev1.Namespace)
 	newMatchingCqs := h.cache.MatchingClusterQueues(newNs.Labels)
-	cqs := sets.New[string]()
+	cqs := sets.New[kueue.ClusterQueueReference]()
 	for cq := range newMatchingCqs {
 		if !oldMatchingCqs.Has(cq) {
 			cqs.Insert(cq)
@@ -564,7 +564,7 @@ func (h *cqResourceFlavorHandler) Generic(_ context.Context, e event.GenericEven
 		for _, cq := range cqs {
 			req := reconcile.Request{
 				NamespacedName: types.NamespacedName{
-					Name: cq,
+					Name: string(cq),
 				}}
 			q.Add(req)
 		}
@@ -598,7 +598,7 @@ func (h *cqAdmissionCheckHandler) Generic(_ context.Context, e event.GenericEven
 		for _, cq := range cqs {
 			req := reconcile.Request{
 				NamespacedName: types.NamespacedName{
-					Name: cq,
+					Name: string(cq),
 				}}
 			q.Add(req)
 		}
@@ -627,7 +627,7 @@ func (h *cqTopologyHandler) Generic(_ context.Context, e event.GenericEvent, q w
 	for _, cq := range cqs {
 		req := reconcile.Request{
 			NamespacedName: types.NamespacedName{
-				Name: cq,
+				Name: string(cq),
 			}}
 		q.Add(req)
 	}
@@ -752,7 +752,7 @@ func (r *ClusterQueueReconciler) getWorkloadsStatus(cq *kueue.ClusterQueue) *kue
 	if !r.isVisibilityEnabled() {
 		return nil
 	}
-	pendingWorkloads := r.qManager.GetSnapshot(cq.Name)
+	pendingWorkloads := r.qManager.GetSnapshot(kueue.ClusterQueueReference(cq.Name))
 	if cq.Status.PendingWorkloadsStatus == nil ||
 		cq.Status.PendingWorkloadsStatus.Head == nil ||
 		!equality.Semantic.DeepEqual(cq.Status.PendingWorkloadsStatus.Head, pendingWorkloads) {
@@ -803,16 +803,16 @@ func (r *ClusterQueueReconciler) processNextSnapshot(ctx context.Context) bool {
 
 	startTime := r.clock.Now()
 	defer func() {
-		log.V(5).Info("Finished snapshot job", "clusterQueue", klog.KRef("", cqName), "elapsed", time.Since(startTime))
+		log.V(5).Info("Finished snapshot job", "clusterQueue", klog.KRef("", string(cqName)), "elapsed", time.Since(startTime))
 	}()
 
 	defer r.snapshotsQueue.Done(cqName)
 
 	if r.qManager.UpdateSnapshot(cqName, r.queueVisibilityClusterQueuesMaxCount) {
-		log.V(5).Info("Triggering CQ update due to snapshot change", "clusterQueue", klog.KRef("", cqName))
+		log.V(5).Info("Triggering CQ update due to snapshot change", "clusterQueue", klog.KRef("", string(cqName)))
 		r.snapUpdateCh <- event.GenericEvent{Object: &kueue.ClusterQueue{
 			ObjectMeta: metav1.ObjectMeta{
-				Name: cqName,
+				Name: string(cqName),
 			},
 		}}
 	}
diff --git a/pkg/controller/core/cohort_controller.go b/pkg/controller/core/cohort_controller.go
index 54e398680..c5aad5b83 100644
--- a/pkg/controller/core/cohort_controller.go
+++ b/pkg/controller/core/cohort_controller.go
@@ -31,6 +31,7 @@ import (
 
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1alpha1"
+	"sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/cache"
 	"sigs.k8s.io/kueue/pkg/queue"
 )
@@ -98,8 +99,8 @@ func (r *CohortReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctr
 	if err := r.client.Get(ctx, req.NamespacedName, &cohort); err != nil {
 		if apierrors.IsNotFound(err) {
 			log.V(2).Info("Cohort is being deleted")
-			r.cache.DeleteCohort(req.NamespacedName.Name)
-			r.qManager.DeleteCohort(req.NamespacedName.Name)
+			r.cache.DeleteCohort(v1beta1.CohortReference(req.NamespacedName.Name))
+			r.qManager.DeleteCohort(v1beta1.CohortReference(req.NamespacedName.Name))
 		}
 		return ctrl.Result{}, client.IgnoreNotFound(err)
 	}
diff --git a/pkg/controller/core/workload_controller.go b/pkg/controller/core/workload_controller.go
index f5e160924..a097dde19 100644
--- a/pkg/controller/core/workload_controller.go
+++ b/pkg/controller/core/workload_controller.go
@@ -211,7 +211,7 @@ func (r *WorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 				return ctrl.Result{}, fmt.Errorf("setting eviction: %w", err)
 			}
 			if evicted && wl.Status.Admission != nil {
-				workload.ReportEvictedWorkload(r.recorder, &wl, string(wl.Status.Admission.ClusterQueue), reason, message)
+				workload.ReportEvictedWorkload(r.recorder, &wl, wl.Status.Admission.ClusterQueue, reason, message)
 			}
 			return ctrl.Result{}, nil
 		}
@@ -234,7 +234,7 @@ func (r *WorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 	if cqOk {
 		// because we need to react to API cluster cq events, the list of checks from a cache can lead to race conditions
 		cq := kueue.ClusterQueue{}
-		if err := r.client.Get(ctx, types.NamespacedName{Name: cqName}, &cq); err != nil {
+		if err := r.client.Get(ctx, types.NamespacedName{Name: string(cqName)}, &cq); err != nil {
 			return ctrl.Result{}, err
 		}
 		// If stopped cluster queue is started we need to set the WorkloadRequeued condition to true.
@@ -258,8 +258,8 @@ func (r *WorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 			quotaReservedCondition := apimeta.FindStatusCondition(wl.Status.Conditions, kueue.WorkloadQuotaReserved)
 			quotaReservedWaitTime := r.clock.Since(quotaReservedCondition.LastTransitionTime.Time)
 			r.recorder.Eventf(&wl, corev1.EventTypeNormal, "Admitted", "Admitted by ClusterQueue %v, wait time since reservation was %.0fs", wl.Status.Admission.ClusterQueue, quotaReservedWaitTime.Seconds())
-			metrics.AdmittedWorkload(kueue.ClusterQueueReference(cqName), queuedWaitTime)
-			metrics.AdmissionChecksWaitTime(kueue.ClusterQueueReference(cqName), quotaReservedWaitTime)
+			metrics.AdmittedWorkload(cqName, queuedWaitTime)
+			metrics.AdmissionChecksWaitTime(cqName, quotaReservedWaitTime)
 			if features.Enabled(features.LocalQueueMetrics) {
 				metrics.LocalQueueAdmittedWorkload(metrics.LQRefFromWorkload(&wl), queuedWaitTime)
 				metrics.LocalQueueAdmissionChecksWaitTime(metrics.LQRefFromWorkload(&wl), quotaReservedWaitTime)
@@ -312,13 +312,13 @@ func (r *WorkloadReconciler) Reconcile(ctx context.Context, req ctrl.Request) (c
 			return ctrl.Result{}, client.IgnoreNotFound(err)
 		}
 	case !cqOk:
-		log.V(3).Info("Workload is inadmissible because of missing ClusterQueue", "clusterQueue", klog.KRef("", cqName))
+		log.V(3).Info("Workload is inadmissible because of missing ClusterQueue", "clusterQueue", klog.KRef("", string(cqName)))
 		if workload.UnsetQuotaReservationWithCondition(&wl, kueue.WorkloadInadmissible, fmt.Sprintf("ClusterQueue %s doesn't exist", cqName), r.clock.Now()) {
 			err := workload.ApplyAdmissionStatus(ctx, r.client, &wl, true, r.clock)
 			return ctrl.Result{}, client.IgnoreNotFound(err)
 		}
 	case !r.cache.ClusterQueueActive(cqName):
-		log.V(3).Info("Workload is inadmissible because ClusterQueue is inactive", "clusterQueue", klog.KRef("", cqName))
+		log.V(3).Info("Workload is inadmissible because ClusterQueue is inactive", "clusterQueue", klog.KRef("", string(cqName)))
 		if workload.UnsetQuotaReservationWithCondition(&wl, kueue.WorkloadInadmissible, fmt.Sprintf("ClusterQueue %s is inactive", cqName), r.clock.Now()) {
 			err := workload.ApplyAdmissionStatus(ctx, r.client, &wl, true, r.clock)
 			return ctrl.Result{}, client.IgnoreNotFound(err)
@@ -431,7 +431,7 @@ func (r *WorkloadReconciler) reconcileOnLocalQueueActiveState(ctx context.Contex
 		workload.ResetChecksOnEviction(wl, r.clock.Now())
 		err := workload.ApplyAdmissionStatus(ctx, r.client, wl, true, r.clock)
 		if err == nil {
-			cqName := string(lq.Spec.ClusterQueue)
+			cqName := lq.Spec.ClusterQueue
 			if slices.Contains(r.queues.GetClusterQueueNames(), cqName) {
 				metrics.ReportEvictedWorkloads(cqName, kueue.WorkloadEvictedByLocalQueueStopped)
 				if features.Enabled(features.LocalQueueMetrics) {
@@ -457,9 +457,9 @@ func (r *WorkloadReconciler) reconcileOnLocalQueueActiveState(ctx context.Contex
 	return false, nil
 }
 
-func (r *WorkloadReconciler) reconcileOnClusterQueueActiveState(ctx context.Context, wl *kueue.Workload, cqName string) (bool, error) {
+func (r *WorkloadReconciler) reconcileOnClusterQueueActiveState(ctx context.Context, wl *kueue.Workload, cqName kueue.ClusterQueueReference) (bool, error) {
 	cq := kueue.ClusterQueue{}
-	err := r.client.Get(ctx, types.NamespacedName{Name: cqName}, &cq)
+	err := r.client.Get(ctx, types.NamespacedName{Name: string(cqName)}, &cq)
 	if client.IgnoreNotFound(err) != nil {
 		return false, err
 	}
@@ -476,7 +476,7 @@ func (r *WorkloadReconciler) reconcileOnClusterQueueActiveState(ctx context.Cont
 			log.V(3).Info("Workload is already evicted.")
 			return false, nil
 		}
-		log.V(3).Info("Workload is evicted because the ClusterQueue is stopped", "clusterQueue", klog.KRef("", cqName))
+		log.V(3).Info("Workload is evicted because the ClusterQueue is stopped", "clusterQueue", klog.KRef("", string(cqName)))
 		message := "The ClusterQueue is stopped"
 		workload.SetEvictedCondition(wl, kueue.WorkloadEvictedByClusterQueueStopped, message)
 		workload.ResetChecksOnEviction(wl, r.clock.Now())
@@ -488,13 +488,13 @@ func (r *WorkloadReconciler) reconcileOnClusterQueueActiveState(ctx context.Cont
 	}
 
 	if !cqExists || !cq.DeletionTimestamp.IsZero() {
-		log.V(3).Info("Workload is inadmissible because the ClusterQueue is terminating or missing", "clusterQueue", klog.KRef("", cqName))
+		log.V(3).Info("Workload is inadmissible because the ClusterQueue is terminating or missing", "clusterQueue", klog.KRef("", string(cqName)))
 		_ = workload.UnsetQuotaReservationWithCondition(wl, kueue.WorkloadInadmissible, fmt.Sprintf("ClusterQueue %s is terminating or missing", cqName), r.clock.Now())
 		return true, workload.ApplyAdmissionStatus(ctx, r.client, wl, true, r.clock)
 	}
 
 	if queueStopPolicy != kueue.None {
-		log.V(3).Info("Workload is inadmissible because the ClusterQueue is stopped", "clusterQueue", klog.KRef("", cqName))
+		log.V(3).Info("Workload is inadmissible because the ClusterQueue is stopped", "clusterQueue", klog.KRef("", string(cqName)))
 		_ = workload.UnsetQuotaReservationWithCondition(wl, kueue.WorkloadInadmissible, fmt.Sprintf("ClusterQueue %s is stopped", cqName), r.clock.Now())
 		return true, workload.ApplyAdmissionStatus(ctx, r.client, wl, true, r.clock)
 	}
diff --git a/pkg/controller/jobs/deployment/deployment_webhook.go b/pkg/controller/jobs/deployment/deployment_webhook.go
index 8e58f586f..20e346375 100644
--- a/pkg/controller/jobs/deployment/deployment_webhook.go
+++ b/pkg/controller/jobs/deployment/deployment_webhook.go
@@ -123,8 +123,7 @@ func (wh *Webhook) ValidateUpdate(ctx context.Context, oldObj, newObj runtime.Ob
 	oldQueueName := jobframework.QueueNameForObject(oldDeployment.Object())
 	newQueueName := jobframework.QueueNameForObject(newDeployment.Object())
 
-	allErrs := field.ErrorList{}
-	allErrs = append(allErrs, jobframework.ValidateQueueName(newDeployment.Object())...)
+	allErrs := jobframework.ValidateQueueName(newDeployment.Object())
 	allErrs = append(allErrs, jobframework.ValidateUpdateForWorkloadPriorityClassName(oldDeployment.Object(), newDeployment.Object())...)
 
 	// Prevents updating the queue-name if at least one Pod is not suspended
diff --git a/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go b/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go
index b1be89989..af254b5f3 100644
--- a/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go
+++ b/pkg/controller/jobs/leaderworkerset/leaderworkerset_webhook.go
@@ -176,7 +176,7 @@ func validateTopologyRequest(lws *LeaderWorkerSet) field.ErrorList {
 }
 
 func validateImmutablePodTemplateSpec(newPodTemplateSpec *corev1.PodTemplateSpec, oldPodTemplateSpec *corev1.PodTemplateSpec, fieldPath *field.Path) field.ErrorList {
-	allErrors := field.ErrorList{}
+	var allErrors field.ErrorList
 	if newPodTemplateSpec == nil || oldPodTemplateSpec == nil {
 		allErrors = append(allErrors, apivalidation.ValidateImmutableField(newPodTemplateSpec, oldPodTemplateSpec, fieldPath)...)
 	} else {
diff --git a/pkg/controller/jobs/pod/pod_webhook.go b/pkg/controller/jobs/pod/pod_webhook.go
index 9cac5045e..a8ccf767d 100644
--- a/pkg/controller/jobs/pod/pod_webhook.go
+++ b/pkg/controller/jobs/pod/pod_webhook.go
@@ -350,11 +350,11 @@ func validateUpdateForRetriableInGroupAnnotation(oldPod, newPod *Pod) field.Erro
 		}
 	}
 
-	return field.ErrorList{}
+	return nil
 }
 
 func validatePrebuiltWorkloadName(pod *Pod) field.ErrorList {
-	allErrs := field.ErrorList{}
+	var allErrs field.ErrorList
 	prebuiltWorkloadName, hasPrebuiltWorkload := jobframework.PrebuiltWorkloadFor(pod)
 	groupName := podGroupName(pod.pod)
 	if hasPrebuiltWorkload && groupName != "" && prebuiltWorkloadName != groupName {
diff --git a/pkg/hierarchy/clusterqueue.go b/pkg/hierarchy/clusterqueue.go
index 75f25ad08..bd5a51364 100644
--- a/pkg/hierarchy/clusterqueue.go
+++ b/pkg/hierarchy/clusterqueue.go
@@ -16,7 +16,9 @@ limitations under the License.
 
 package hierarchy
 
-type ClusterQueue[C nodeBase] struct {
+import kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+
+type ClusterQueue[C nodeBase[kueue.CohortReference]] struct {
 	cohort C
 }
 
diff --git a/pkg/hierarchy/cohort.go b/pkg/hierarchy/cohort.go
index 72d66a507..73030b104 100644
--- a/pkg/hierarchy/cohort.go
+++ b/pkg/hierarchy/cohort.go
@@ -16,10 +16,14 @@ limitations under the License.
 
 package hierarchy
 
-import "k8s.io/apimachinery/pkg/util/sets"
+import (
+	"k8s.io/apimachinery/pkg/util/sets"
+
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+)
 
 //lint:ignore U1000 due to https://github.com/dominikh/go-tools/issues/1602.
-type Cohort[CQ, C nodeBase] struct {
+type Cohort[CQ clusterQueueNode[C], C nodeBase[kueue.CohortReference]] struct {
 	parent       C
 	childCohorts sets.Set[C]
 	childCqs     sets.Set[CQ]
@@ -50,7 +54,7 @@ func (c *Cohort[CQ, C]) ChildCount() int {
 	return c.childCohorts.Len() + c.childCqs.Len()
 }
 
-func NewCohort[CQ, C nodeBase]() Cohort[CQ, C] {
+func NewCohort[CQ clusterQueueNode[C], C nodeBase[kueue.CohortReference]]() Cohort[CQ, C] {
 	return Cohort[CQ, C]{
 		childCohorts: sets.New[C](),
 		childCqs:     sets.New[CQ](),
diff --git a/pkg/hierarchy/cycle.go b/pkg/hierarchy/cycle.go
index bb8725dfb..f6baacfa5 100644
--- a/pkg/hierarchy/cycle.go
+++ b/pkg/hierarchy/cycle.go
@@ -16,19 +16,21 @@ limitations under the License.
 
 package hierarchy
 
+import kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+
+type CycleCheckable[T comparable] interface {
+	GetName() T
+	HasParent() bool
+	CCParent() CycleCheckable[T]
+}
+
 // cycleChecker checks for cycles in Cohorts, while memoizing the
 // result.
 type CycleChecker struct {
-	cycles map[string]bool
-}
-
-type CycleCheckable interface {
-	GetName() string
-	HasParent() bool
-	CCParent() CycleCheckable
+	cycles map[kueue.CohortReference]bool
 }
 
-func (c *CycleChecker) HasCycle(cohort CycleCheckable) bool {
+func (c *CycleChecker) HasCycle(cohort CycleCheckable[kueue.CohortReference]) bool {
 	if cycle, seen := c.cycles[cohort.GetName()]; seen {
 		return cycle
 	}
diff --git a/pkg/hierarchy/manager.go b/pkg/hierarchy/manager.go
index 18c6c6e47..7fdc27c1d 100644
--- a/pkg/hierarchy/manager.go
+++ b/pkg/hierarchy/manager.go
@@ -16,26 +16,30 @@ limitations under the License.
 
 package hierarchy
 
-import "maps"
+import (
+	"maps"
+
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+)
 
 // Manager stores Cohorts and ClusterQueues, and maintains the edges
 // between them.
 type Manager[CQ clusterQueueNode[C], C cohortNode[CQ, C]] struct {
-	cohorts       map[string]C
-	clusterQueues map[string]CQ
-	cohortFactory func(string) C
+	cohorts       map[kueue.CohortReference]C
+	clusterQueues map[kueue.ClusterQueueReference]CQ
+	cohortFactory func(kueue.CohortReference) C
 	CycleChecker  CycleChecker
 }
 
 // NewManager creates a new Manager. A newCohort function must
 // be provided to instantiate Cohorts in the case that a
 // ClusterQueue references a Cohort not backed by an API object.
-func NewManager[CQ clusterQueueNode[C], C cohortNode[CQ, C]](newCohort func(string) C) Manager[CQ, C] {
+func NewManager[CQ clusterQueueNode[C], C cohortNode[CQ, C]](newCohort func(kueue.CohortReference) C) Manager[CQ, C] {
 	return Manager[CQ, C]{
-		make(map[string]C),
-		make(map[string]CQ),
+		make(map[kueue.CohortReference]C),
+		make(map[kueue.ClusterQueueReference]CQ),
 		newCohort,
-		CycleChecker{make(map[string]bool)},
+		CycleChecker{make(map[kueue.CohortReference]bool)},
 	}
 }
 
@@ -43,23 +47,23 @@ func (m *Manager[CQ, C]) AddClusterQueue(cq CQ) {
 	m.clusterQueues[cq.GetName()] = cq
 }
 
-func (m *Manager[CQ, C]) ClusterQueue(name string) CQ {
+func (m *Manager[CQ, C]) ClusterQueue(name kueue.ClusterQueueReference) CQ {
 	return m.clusterQueues[name]
 }
 
-func (m *Manager[CQ, C]) ClusterQueuesNames() []string {
-	clusterQueuesNames := make([]string, 0, len(m.clusterQueues))
+func (m *Manager[CQ, C]) ClusterQueuesNames() []kueue.ClusterQueueReference {
+	clusterQueuesNames := make([]kueue.ClusterQueueReference, 0, len(m.clusterQueues))
 	for k := range m.clusterQueues {
 		clusterQueuesNames = append(clusterQueuesNames, k)
 	}
 	return clusterQueuesNames
 }
 
-func (m *Manager[CQ, C]) ClusterQueues() map[string]CQ {
+func (m *Manager[CQ, C]) ClusterQueues() map[kueue.ClusterQueueReference]CQ {
 	return maps.Clone(m.clusterQueues)
 }
 
-func (m *Manager[CQ, C]) UpdateClusterQueueEdge(name, parentName string) {
+func (m *Manager[CQ, C]) UpdateClusterQueueEdge(name kueue.ClusterQueueReference, parentName kueue.CohortReference) {
 	cq := m.clusterQueues[name]
 	m.detachClusterQueueFromParent(cq)
 	if parentName != "" {
@@ -69,14 +73,14 @@ func (m *Manager[CQ, C]) UpdateClusterQueueEdge(name, parentName string) {
 	}
 }
 
-func (m *Manager[CQ, C]) DeleteClusterQueue(name string) {
+func (m *Manager[CQ, C]) DeleteClusterQueue(name kueue.ClusterQueueReference) {
 	if cq, ok := m.clusterQueues[name]; ok {
 		m.detachClusterQueueFromParent(cq)
 		delete(m.clusterQueues, name)
 	}
 }
 
-func (m *Manager[CQ, C]) AddCohort(cohortName string) {
+func (m *Manager[CQ, C]) AddCohort(cohortName kueue.CohortReference) {
 	oldCohort, ok := m.cohorts[cohortName]
 	if ok && oldCohort.isExplicit() {
 		return
@@ -87,15 +91,15 @@ func (m *Manager[CQ, C]) AddCohort(cohortName string) {
 	m.cohorts[cohortName].markExplicit()
 }
 
-func (m *Manager[CQ, C]) Cohort(name string) C {
+func (m *Manager[CQ, C]) Cohort(name kueue.CohortReference) C {
 	return m.cohorts[name]
 }
 
-func (m *Manager[CQ, C]) Cohorts() map[string]C {
+func (m *Manager[CQ, C]) Cohorts() map[kueue.CohortReference]C {
 	return maps.Clone(m.cohorts)
 }
 
-func (m *Manager[CQ, C]) UpdateCohortEdge(name, parentName string) {
+func (m *Manager[CQ, C]) UpdateCohortEdge(name, parentName kueue.CohortReference) {
 	m.resetCycleChecker()
 	cohort := m.cohorts[name]
 	m.detachCohortFromParent(cohort)
@@ -106,7 +110,7 @@ func (m *Manager[CQ, C]) UpdateCohortEdge(name, parentName string) {
 	}
 }
 
-func (m *Manager[CQ, C]) DeleteCohort(name string) {
+func (m *Manager[CQ, C]) DeleteCohort(name kueue.CohortReference) {
 	m.resetCycleChecker()
 	cohort, ok := m.cohorts[name]
 	if !ok {
@@ -155,7 +159,7 @@ func (m *Manager[CQ, C]) detachCohortFromParent(cohort C) {
 	}
 }
 
-func (m *Manager[CQ, C]) getOrCreateCohort(cohortName string) C {
+func (m *Manager[CQ, C]) getOrCreateCohort(cohortName kueue.CohortReference) C {
 	if _, ok := m.cohorts[cohortName]; !ok {
 		m.cohorts[cohortName] = m.cohortFactory(cohortName)
 	}
@@ -169,30 +173,30 @@ func (m *Manager[CQ, C]) cleanupCohort(cohort C) {
 }
 
 func (m *Manager[CQ, C]) resetCycleChecker() {
-	m.CycleChecker = CycleChecker{make(map[string]bool, len(m.cohorts))}
+	m.CycleChecker = CycleChecker{make(map[kueue.CohortReference]bool, len(m.cohorts))}
 }
 
 // A special constructor for using in tests
-func NewManagerForTest[CQ clusterQueueNode[C], C cohortNode[CQ, C]](cohorts map[string]C, clusterQueues map[string]CQ) Manager[CQ, C] {
+func NewManagerForTest[CQ clusterQueueNode[C], C cohortNode[CQ, C]](cohorts map[kueue.CohortReference]C, clusterQueues map[kueue.ClusterQueueReference]CQ) Manager[CQ, C] {
 	return Manager[CQ, C]{
 		cohorts:       cohorts,
 		clusterQueues: clusterQueues,
 	}
 }
 
-type nodeBase interface {
-	GetName() string
+type nodeBase[T comparable] interface {
+	GetName() T
 	comparable
 }
 
-type clusterQueueNode[C nodeBase] interface {
+type clusterQueueNode[C nodeBase[kueue.CohortReference]] interface {
 	Parent() C
 	HasParent() bool
 	setParent(C)
-	nodeBase
+	nodeBase[kueue.ClusterQueueReference]
 }
 
-type cohortNode[CQ, C nodeBase] interface {
+type cohortNode[CQ nodeBase[kueue.ClusterQueueReference], C nodeBase[kueue.CohortReference]] interface {
 	Parent() C
 	HasParent() bool
 	setParent(C)
@@ -206,5 +210,5 @@ type cohortNode[CQ, C nodeBase] interface {
 	ChildCQs() []CQ
 	isExplicit() bool
 	markExplicit()
-	nodeBase
+	nodeBase[kueue.CohortReference]
 }
diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go
index 62f01cab4..9d4e9573f 100644
--- a/pkg/metrics/metrics.go
+++ b/pkg/metrics/metrics.go
@@ -408,9 +408,9 @@ func LocalQueueAdmissionChecksWaitTime(lq LocalQueueReference, waitTime time.Dur
 	localQueueAdmissionChecksWaitTime.WithLabelValues(lq.Name, lq.Namespace).Observe(waitTime.Seconds())
 }
 
-func ReportPendingWorkloads(cqName string, active, inadmissible int) {
-	PendingWorkloads.WithLabelValues(cqName, PendingStatusActive).Set(float64(active))
-	PendingWorkloads.WithLabelValues(cqName, PendingStatusInadmissible).Set(float64(inadmissible))
+func ReportPendingWorkloads(cqName kueue.ClusterQueueReference, active, inadmissible int) {
+	PendingWorkloads.WithLabelValues(string(cqName), PendingStatusActive).Set(float64(active))
+	PendingWorkloads.WithLabelValues(string(cqName), PendingStatusInadmissible).Set(float64(inadmissible))
 }
 
 func ReportLocalQueuePendingWorkloads(lq LocalQueueReference, active, inadmissible int) {
@@ -418,16 +418,16 @@ func ReportLocalQueuePendingWorkloads(lq LocalQueueReference, active, inadmissib
 	LocalQueuePendingWorkloads.WithLabelValues(lq.Name, lq.Namespace, PendingStatusInadmissible).Set(float64(inadmissible))
 }
 
-func ReportEvictedWorkloads(cqName, reason string) {
-	EvictedWorkloadsTotal.WithLabelValues(cqName, reason).Inc()
+func ReportEvictedWorkloads(cqName kueue.ClusterQueueReference, reason string) {
+	EvictedWorkloadsTotal.WithLabelValues(string(cqName), reason).Inc()
 }
 
 func ReportLocalQueueEvictedWorkloads(lq LocalQueueReference, reason string) {
 	LocalQueueEvictedWorkloadsTotal.WithLabelValues(lq.Name, lq.Namespace, reason).Inc()
 }
 
-func ReportPreemption(preemptingCqName, preemptingReason, targetCqName string) {
-	PreemptedWorkloadsTotal.WithLabelValues(preemptingCqName, preemptingReason).Inc()
+func ReportPreemption(preemptingCqName kueue.ClusterQueueReference, preemptingReason string, targetCqName kueue.ClusterQueueReference) {
+	PreemptedWorkloadsTotal.WithLabelValues(string(preemptingCqName), preemptingReason).Inc()
 	ReportEvictedWorkloads(targetCqName, kueue.WorkloadEvictedByPreemption)
 }
 
@@ -470,13 +470,13 @@ func ClearLocalQueueMetrics(lq LocalQueueReference) {
 	LocalQueueEvictedWorkloadsTotal.DeletePartialMatch(prometheus.Labels{"name": lq.Name, "namespace": lq.Namespace})
 }
 
-func ReportClusterQueueStatus(cqName string, cqStatus ClusterQueueStatus) {
+func ReportClusterQueueStatus(cqName kueue.ClusterQueueReference, cqStatus ClusterQueueStatus) {
 	for _, status := range CQStatuses {
 		var v float64
 		if status == cqStatus {
 			v = 1
 		}
-		ClusterQueueByStatus.WithLabelValues(cqName, string(status)).Set(v)
+		ClusterQueueByStatus.WithLabelValues(string(cqName), string(status)).Set(v)
 	}
 }
 
@@ -510,24 +510,24 @@ func ClearLocalQueueCacheMetrics(lq LocalQueueReference) {
 	}
 }
 
-func ReportClusterQueueQuotas(cohort, queue, flavor, resource string, nominal, borrowing, lending float64) {
-	ClusterQueueResourceNominalQuota.WithLabelValues(cohort, queue, flavor, resource).Set(nominal)
-	ClusterQueueResourceBorrowingLimit.WithLabelValues(cohort, queue, flavor, resource).Set(borrowing)
+func ReportClusterQueueQuotas(cohort kueue.CohortReference, queue, flavor, resource string, nominal, borrowing, lending float64) {
+	ClusterQueueResourceNominalQuota.WithLabelValues(string(cohort), queue, flavor, resource).Set(nominal)
+	ClusterQueueResourceBorrowingLimit.WithLabelValues(string(cohort), queue, flavor, resource).Set(borrowing)
 	if features.Enabled(features.LendingLimit) {
-		ClusterQueueResourceLendingLimit.WithLabelValues(cohort, queue, flavor, resource).Set(lending)
+		ClusterQueueResourceLendingLimit.WithLabelValues(string(cohort), queue, flavor, resource).Set(lending)
 	}
 }
 
-func ReportClusterQueueResourceReservations(cohort, queue, flavor, resource string, usage float64) {
-	ClusterQueueResourceReservations.WithLabelValues(cohort, queue, flavor, resource).Set(usage)
+func ReportClusterQueueResourceReservations(cohort kueue.CohortReference, queue, flavor, resource string, usage float64) {
+	ClusterQueueResourceReservations.WithLabelValues(string(cohort), queue, flavor, resource).Set(usage)
 }
 
 func ReportLocalQueueResourceReservations(lq LocalQueueReference, flavor, resource string, usage float64) {
 	LocalQueueResourceReservations.WithLabelValues(lq.Name, lq.Namespace, flavor, resource).Set(usage)
 }
 
-func ReportClusterQueueResourceUsage(cohort, queue, flavor, resource string, usage float64) {
-	ClusterQueueResourceUsage.WithLabelValues(cohort, queue, flavor, resource).Set(usage)
+func ReportClusterQueueResourceUsage(cohort kueue.CohortReference, queue, flavor, resource string, usage float64) {
+	ClusterQueueResourceUsage.WithLabelValues(string(cohort), queue, flavor, resource).Set(usage)
 }
 
 func ReportLocalQueueResourceUsage(lq LocalQueueReference, flavor, resource string, usage float64) {
diff --git a/pkg/queue/cluster_queue.go b/pkg/queue/cluster_queue.go
index 4e5466264..944a75259 100644
--- a/pkg/queue/cluster_queue.go
+++ b/pkg/queue/cluster_queue.go
@@ -52,7 +52,7 @@ var (
 
 type ClusterQueue struct {
 	hierarchy.ClusterQueue[*cohort]
-	name              string
+	name              kueue.ClusterQueueReference
 	heap              heap.Heap[workload.Info]
 	namespaceSelector labels.Selector
 	active            bool
@@ -81,7 +81,7 @@ type ClusterQueue struct {
 	clock clock.Clock
 }
 
-func (c *ClusterQueue) GetName() string {
+func (c *ClusterQueue) GetName() kueue.ClusterQueueReference {
 	return c.name
 }
 
@@ -114,7 +114,7 @@ func newClusterQueueImpl(wo workload.Ordering, clock clock.Clock) *ClusterQueue
 func (c *ClusterQueue) Update(apiCQ *kueue.ClusterQueue) error {
 	c.rwm.Lock()
 	defer c.rwm.Unlock()
-	c.name = apiCQ.Name
+	c.name = kueue.ClusterQueueReference(apiCQ.Name)
 	c.queueingStrategy = apiCQ.Spec.QueueingStrategy
 	nsSelector, err := metav1.LabelSelectorAsSelector(apiCQ.Spec.NamespaceSelector)
 	if err != nil {
diff --git a/pkg/queue/cohort.go b/pkg/queue/cohort.go
index c15a5090b..d9430617f 100644
--- a/pkg/queue/cohort.go
+++ b/pkg/queue/cohort.go
@@ -16,28 +16,31 @@ limitations under the License.
 
 package queue
 
-import "sigs.k8s.io/kueue/pkg/hierarchy"
+import (
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/hierarchy"
+)
 
 // cohort is a set of ClusterQueues that can borrow resources from
 // each other.
 type cohort struct {
-	Name string
+	Name kueue.CohortReference
 	hierarchy.Cohort[*ClusterQueue, *cohort]
 }
 
-func newCohort(name string) *cohort {
+func newCohort(name kueue.CohortReference) *cohort {
 	return &cohort{
 		name,
 		hierarchy.NewCohort[*ClusterQueue, *cohort](),
 	}
 }
 
-func (c *cohort) GetName() string {
+func (c *cohort) GetName() kueue.CohortReference {
 	return c.Name
 }
 
 // CCParent satisfies the CycleCheckable interface.
-func (c *cohort) CCParent() hierarchy.CycleCheckable {
+func (c *cohort) CCParent() hierarchy.CycleCheckable[kueue.CohortReference] {
 	return c.Parent()
 }
 
diff --git a/pkg/queue/dumper.go b/pkg/queue/dumper.go
index 29153754d..6738cfb83 100644
--- a/pkg/queue/dumper.go
+++ b/pkg/queue/dumper.go
@@ -19,6 +19,8 @@ package queue
 import (
 	"github.com/go-logr/logr"
 	"k8s.io/klog/v2"
+
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 )
 
 // LogDump dumps the pending and inadmissible workloads for each ClusterQueue into the log,
@@ -30,7 +32,7 @@ func (m *Manager) LogDump(log logr.Logger) {
 		pending, _ := cq.Dump()
 		inadmissible, _ := cq.DumpInadmissible()
 		log.Info("Found pending and inadmissible workloads in ClusterQueue",
-			"clusterQueue", klog.KRef("", name),
+			"clusterQueue", klog.KRef("", string(name)),
 			"pending", pending,
 			"inadmissible", inadmissible)
 	}
@@ -38,14 +40,14 @@ func (m *Manager) LogDump(log logr.Logger) {
 
 // Dump is a dump of the queues and it's elements (unordered).
 // Only use for testing purposes.
-func (m *Manager) Dump() map[string][]string {
+func (m *Manager) Dump() map[kueue.ClusterQueueReference][]string {
 	m.Lock()
 	defer m.Unlock()
 	clusterQueues := m.hm.ClusterQueues()
 	if len(clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[string][]string, len(clusterQueues))
+	dump := make(map[kueue.ClusterQueueReference][]string, len(clusterQueues))
 	for key, cq := range clusterQueues {
 		if elements, ok := cq.Dump(); ok {
 			dump[key] = elements
@@ -59,14 +61,14 @@ func (m *Manager) Dump() map[string][]string {
 
 // DumpInadmissible is a dump of the inadmissible workloads list.
 // Only use for testing purposes.
-func (m *Manager) DumpInadmissible() map[string][]string {
+func (m *Manager) DumpInadmissible() map[kueue.ClusterQueueReference][]string {
 	m.Lock()
 	defer m.Unlock()
 	clusterQueues := m.hm.ClusterQueues()
 	if len(clusterQueues) == 0 {
 		return nil
 	}
-	dump := make(map[string][]string, len(clusterQueues))
+	dump := make(map[kueue.ClusterQueueReference][]string, len(clusterQueues))
 	for key, cq := range clusterQueues {
 		if elements, ok := cq.DumpInadmissible(); ok {
 			dump[key] = elements
diff --git a/pkg/queue/local_queue.go b/pkg/queue/local_queue.go
index ef8cf23c0..98683a3ed 100644
--- a/pkg/queue/local_queue.go
+++ b/pkg/queue/local_queue.go
@@ -36,7 +36,7 @@ func DefaultQueueKey(namespace string) string {
 // LocalQueue is the internal implementation of kueue.LocalQueue.
 type LocalQueue struct {
 	Key          string
-	ClusterQueue string
+	ClusterQueue kueue.ClusterQueueReference
 
 	items map[string]*workload.Info
 }
@@ -51,7 +51,7 @@ func newLocalQueue(q *kueue.LocalQueue) *LocalQueue {
 }
 
 func (q *LocalQueue) update(apiQueue *kueue.LocalQueue) {
-	q.ClusterQueue = string(apiQueue.Spec.ClusterQueue)
+	q.ClusterQueue = apiQueue.Spec.ClusterQueue
 }
 
 func (q *LocalQueue) AddOrUpdate(info *workload.Info) {
diff --git a/pkg/queue/manager.go b/pkg/queue/manager.go
index 0f42a3f76..643492b0a 100644
--- a/pkg/queue/manager.go
+++ b/pkg/queue/manager.go
@@ -92,7 +92,7 @@ type Manager struct {
 	localQueues   map[string]*LocalQueue
 
 	snapshotsMutex sync.RWMutex
-	snapshots      map[string][]kueue.ClusterQueuePendingWorkload
+	snapshots      map[kueue.ClusterQueueReference][]kueue.ClusterQueuePendingWorkload
 
 	workloadOrdering workload.Ordering
 
@@ -113,7 +113,7 @@ func NewManager(client client.Client, checker StatusChecker, opts ...Option) *Ma
 		statusChecker:  checker,
 		localQueues:    make(map[string]*LocalQueue),
 		snapshotsMutex: sync.RWMutex{},
-		snapshots:      make(map[string][]kueue.ClusterQueuePendingWorkload, 0),
+		snapshots:      make(map[kueue.ClusterQueueReference][]kueue.ClusterQueuePendingWorkload, 0),
 		workloadOrdering: workload.Ordering{
 			PodsReadyRequeuingTimestamp: options.podsReadyRequeuingTimestamp,
 		},
@@ -139,14 +139,16 @@ func (m *Manager) NotifyTopologyUpdateWatchers(oldTopology, newTopology *kueueal
 func (m *Manager) AddOrUpdateCohort(ctx context.Context, cohort *kueuealpha.Cohort) {
 	m.Lock()
 	defer m.Unlock()
-	m.hm.AddCohort(cohort.Name)
-	m.hm.UpdateCohortEdge(cohort.Name, cohort.Spec.Parent)
-	if m.requeueWorkloadsCohort(ctx, m.hm.Cohort(cohort.Name)) {
+	cohortName := kueue.CohortReference(cohort.Name)
+
+	m.hm.AddCohort(cohortName)
+	m.hm.UpdateCohortEdge(cohortName, cohort.Spec.Parent)
+	if m.requeueWorkloadsCohort(ctx, m.hm.Cohort(cohortName)) {
 		m.Broadcast()
 	}
 }
 
-func (m *Manager) DeleteCohort(cohortName string) {
+func (m *Manager) DeleteCohort(cohortName kueue.CohortReference) {
 	m.Lock()
 	defer m.Unlock()
 	m.hm.DeleteCohort(cohortName)
@@ -156,7 +158,7 @@ func (m *Manager) AddClusterQueue(ctx context.Context, cq *kueue.ClusterQueue) e
 	m.Lock()
 	defer m.Unlock()
 
-	if cq := m.hm.ClusterQueue(cq.Name); cq != nil {
+	if cq := m.hm.ClusterQueue(kueue.ClusterQueueReference(cq.Name)); cq != nil {
 		return errClusterQueueAlreadyExists
 	}
 
@@ -165,7 +167,7 @@ func (m *Manager) AddClusterQueue(ctx context.Context, cq *kueue.ClusterQueue) e
 		return err
 	}
 	m.hm.AddClusterQueue(cqImpl)
-	m.hm.UpdateClusterQueueEdge(cq.Name, cq.Spec.Cohort)
+	m.hm.UpdateClusterQueueEdge(kueue.ClusterQueueReference(cq.Name), cq.Spec.Cohort)
 
 	// Iterate through existing queues, as queues corresponding to this cluster
 	// queue might have been added earlier.
@@ -183,7 +185,7 @@ func (m *Manager) AddClusterQueue(ctx context.Context, cq *kueue.ClusterQueue) e
 	}
 
 	queued := m.requeueWorkloadsCQ(ctx, cqImpl)
-	m.reportPendingWorkloads(cq.Name, cqImpl)
+	m.reportPendingWorkloads(kueue.ClusterQueueReference(cq.Name), cqImpl)
 
 	// needs to be iterated over again here incase inadmissible workloads were added by requeueWorkloadsCQ
 	if features.Enabled(features.LocalQueueMetrics) {
@@ -204,7 +206,9 @@ func (m *Manager) AddClusterQueue(ctx context.Context, cq *kueue.ClusterQueue) e
 func (m *Manager) UpdateClusterQueue(ctx context.Context, cq *kueue.ClusterQueue, specUpdated bool) error {
 	m.Lock()
 	defer m.Unlock()
-	cqImpl := m.hm.ClusterQueue(cq.Name)
+	cqName := kueue.ClusterQueueReference(cq.Name)
+
+	cqImpl := m.hm.ClusterQueue(cqName)
 	if cqImpl == nil {
 		return ErrClusterQueueDoesNotExist
 	}
@@ -214,15 +218,15 @@ func (m *Manager) UpdateClusterQueue(ctx context.Context, cq *kueue.ClusterQueue
 	if err := cqImpl.Update(cq); err != nil {
 		return err
 	}
-	m.hm.UpdateClusterQueueEdge(cq.Name, cq.Spec.Cohort)
+	m.hm.UpdateClusterQueueEdge(cqName, cq.Spec.Cohort)
 
 	// TODO(#8): Selectively move workloads based on the exact event.
 	// If any workload becomes admissible or the queue becomes active.
 	if (specUpdated && m.requeueWorkloadsCQ(ctx, cqImpl)) || (!oldActive && cqImpl.Active()) {
-		m.reportPendingWorkloads(cq.Name, cqImpl)
+		m.reportPendingWorkloads(cqName, cqImpl)
 		if features.Enabled(features.LocalQueueMetrics) {
 			for _, q := range m.localQueues {
-				if q.ClusterQueue == cq.Name {
+				if q.ClusterQueue == cqName {
 					m.reportLQPendingWorkloads(q)
 				}
 			}
@@ -235,11 +239,11 @@ func (m *Manager) UpdateClusterQueue(ctx context.Context, cq *kueue.ClusterQueue
 func (m *Manager) DeleteClusterQueue(cq *kueue.ClusterQueue) {
 	m.Lock()
 	defer m.Unlock()
-	cqImpl := m.hm.ClusterQueue(cq.Name)
+	cqImpl := m.hm.ClusterQueue(kueue.ClusterQueueReference(cq.Name))
 	if cqImpl == nil {
 		return
 	}
-	m.hm.DeleteClusterQueue(cq.Name)
+	m.hm.DeleteClusterQueue(kueue.ClusterQueueReference(cq.Name))
 	metrics.ClearClusterQueueMetrics(cq.Name)
 }
 
@@ -288,12 +292,12 @@ func (m *Manager) UpdateLocalQueue(q *kueue.LocalQueue) error {
 	if !ok {
 		return ErrLocalQueueDoesNotExistOrInactive
 	}
-	if qImpl.ClusterQueue != string(q.Spec.ClusterQueue) {
+	if qImpl.ClusterQueue != q.Spec.ClusterQueue {
 		oldCQ := m.hm.ClusterQueue(qImpl.ClusterQueue)
 		if oldCQ != nil {
 			oldCQ.DeleteFromLocalQueue(qImpl)
 		}
-		newCQ := m.hm.ClusterQueue(string(q.Spec.ClusterQueue))
+		newCQ := m.hm.ClusterQueue(q.Spec.ClusterQueue)
 		if newCQ != nil && newCQ.AddFromLocalQueue(qImpl) {
 			m.Broadcast()
 		}
@@ -336,7 +340,7 @@ func (m *Manager) Pending(cq *kueue.ClusterQueue) (int, error) {
 	m.RLock()
 	defer m.RUnlock()
 
-	cqImpl := m.hm.ClusterQueue(cq.Name)
+	cqImpl := m.hm.ClusterQueue(kueue.ClusterQueueReference(cq.Name))
 	if cqImpl == nil {
 		return 0, ErrClusterQueueDoesNotExist
 	}
@@ -354,7 +358,7 @@ func (m *Manager) QueueForWorkloadExists(wl *kueue.Workload) bool {
 // ClusterQueueForWorkload returns the name of the ClusterQueue where the
 // workload should be queued and whether it exists.
 // Returns empty string if the queue doesn't exist.
-func (m *Manager) ClusterQueueForWorkload(wl *kueue.Workload) (string, bool) {
+func (m *Manager) ClusterQueueForWorkload(wl *kueue.Workload) (kueue.ClusterQueueReference, bool) {
 	m.RLock()
 	defer m.RUnlock()
 	q, ok := m.localQueues[workload.QueueKey(wl)]
@@ -483,7 +487,7 @@ func (m *Manager) QueueAssociatedInadmissibleWorkloadsAfter(ctx context.Context,
 // QueueInadmissibleWorkloads moves all inadmissibleWorkloads in
 // corresponding ClusterQueues to heap. If at least one workload queued,
 // we will broadcast the event.
-func (m *Manager) QueueInadmissibleWorkloads(ctx context.Context, cqNames sets.Set[string]) {
+func (m *Manager) QueueInadmissibleWorkloads(ctx context.Context, cqNames sets.Set[kueue.ClusterQueueReference]) {
 	m.Lock()
 	defer m.Unlock()
 	if len(cqNames) == 0 {
@@ -636,7 +640,7 @@ func (m *Manager) reportLQPendingWorkloads(lq *LocalQueue) {
 	metrics.ReportLocalQueuePendingWorkloads(metrics.LQRefFromLocalQueueKey(lq.Key), active, inadmissible)
 }
 
-func (m *Manager) reportPendingWorkloads(cqName string, cq *ClusterQueue) {
+func (m *Manager) reportPendingWorkloads(cqName kueue.ClusterQueueReference, cq *ClusterQueue) {
 	active := cq.PendingActive()
 	inadmissible := cq.PendingInadmissible()
 	if m.statusChecker != nil && !m.statusChecker.ClusterQueueActive(cqName) {
@@ -646,24 +650,24 @@ func (m *Manager) reportPendingWorkloads(cqName string, cq *ClusterQueue) {
 	metrics.ReportPendingWorkloads(cqName, active, inadmissible)
 }
 
-func (m *Manager) GetClusterQueueNames() []string {
+func (m *Manager) GetClusterQueueNames() []kueue.ClusterQueueReference {
 	m.RLock()
 	defer m.RUnlock()
 	return m.hm.ClusterQueuesNames()
 }
 
-func (m *Manager) getClusterQueue(cqName string) *ClusterQueue {
+func (m *Manager) getClusterQueue(cqName kueue.ClusterQueueReference) *ClusterQueue {
 	m.RLock()
 	defer m.RUnlock()
 	return m.hm.ClusterQueue(cqName)
 }
 
-func (m *Manager) getClusterQueueLockless(cqName string) (val *ClusterQueue, ok bool) {
+func (m *Manager) getClusterQueueLockless(cqName kueue.ClusterQueueReference) (val *ClusterQueue, ok bool) {
 	val = m.hm.ClusterQueue(cqName)
 	return val, val != nil
 }
 
-func (m *Manager) PendingWorkloadsInfo(cqName string) []*workload.Info {
+func (m *Manager) PendingWorkloadsInfo(cqName kueue.ClusterQueueReference) []*workload.Info {
 	cq := m.getClusterQueue(cqName)
 	if cq == nil {
 		return nil
@@ -673,7 +677,7 @@ func (m *Manager) PendingWorkloadsInfo(cqName string) []*workload.Info {
 
 // ClusterQueueFromLocalQueue returns ClusterQueue name and whether it's found,
 // given a QueueKey(namespace/localQueueName) as the parameter
-func (m *Manager) ClusterQueueFromLocalQueue(localQueueKey string) (string, bool) {
+func (m *Manager) ClusterQueueFromLocalQueue(localQueueKey string) (kueue.ClusterQueueReference, bool) {
 	m.RLock()
 	defer m.RUnlock()
 	if lq, ok := m.localQueues[localQueueKey]; ok {
@@ -688,7 +692,7 @@ func QueueKey(namespace, name string) string {
 
 // UpdateSnapshot computes the new snapshot and replaces if it differs from the
 // previous version. It returns true if the snapshot was actually updated.
-func (m *Manager) UpdateSnapshot(cqName string, maxCount int32) bool {
+func (m *Manager) UpdateSnapshot(cqName kueue.ClusterQueueReference, maxCount int32) bool {
 	cq := m.getClusterQueue(cqName)
 	if cq == nil {
 		return false
@@ -714,13 +718,13 @@ func (m *Manager) UpdateSnapshot(cqName string, maxCount int32) bool {
 	return false
 }
 
-func (m *Manager) setSnapshot(cqName string, workloads []kueue.ClusterQueuePendingWorkload) {
+func (m *Manager) setSnapshot(cqName kueue.ClusterQueueReference, workloads []kueue.ClusterQueuePendingWorkload) {
 	m.snapshotsMutex.Lock()
 	defer m.snapshotsMutex.Unlock()
 	m.snapshots[cqName] = workloads
 }
 
-func (m *Manager) GetSnapshot(cqName string) []kueue.ClusterQueuePendingWorkload {
+func (m *Manager) GetSnapshot(cqName kueue.ClusterQueueReference) []kueue.ClusterQueuePendingWorkload {
 	m.snapshotsMutex.RLock()
 	defer m.snapshotsMutex.RUnlock()
 	return m.snapshots[cqName]
@@ -729,5 +733,5 @@ func (m *Manager) GetSnapshot(cqName string) []kueue.ClusterQueuePendingWorkload
 func (m *Manager) DeleteSnapshot(cq *kueue.ClusterQueue) {
 	m.snapshotsMutex.Lock()
 	defer m.snapshotsMutex.Unlock()
-	delete(m.snapshots, cq.Name)
+	delete(m.snapshots, kueue.ClusterQueueReference(cq.Name))
 }
diff --git a/pkg/queue/status_checker.go b/pkg/queue/status_checker.go
index 9b6d62719..a71b67cf9 100644
--- a/pkg/queue/status_checker.go
+++ b/pkg/queue/status_checker.go
@@ -16,8 +16,10 @@ limitations under the License.
 
 package queue
 
+import kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+
 // StatusChecker checks status of clusterQueue.
 type StatusChecker interface {
 	// ClusterQueueActive returns whether the clusterQueue is active.
-	ClusterQueueActive(name string) bool
+	ClusterQueueActive(name kueue.ClusterQueueReference) bool
 }
diff --git a/pkg/scheduler/fair_sharing_iterator.go b/pkg/scheduler/fair_sharing_iterator.go
index 0ed35f2f1..6bb993117 100644
--- a/pkg/scheduler/fair_sharing_iterator.go
+++ b/pkg/scheduler/fair_sharing_iterator.go
@@ -24,6 +24,7 @@ import (
 	"k8s.io/klog/v2"
 	ctrl "sigs.k8s.io/controller-runtime"
 
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/cache"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/util/priority"
@@ -66,7 +67,7 @@ func (f *fairSharingIterator) pop() *entry {
 	if !cq.HasParent() {
 		entry := f.cqToEntry[cq]
 		f.log.V(3).Info("Returning workload from ClusterQueue without Cohort",
-			"clusterQueue", klog.KRef("", cq.GetName()),
+			"clusterQueue", klog.KRef("", string(cq.GetName())),
 			"workload", klog.KObj(entry.Obj))
 		delete(f.cqToEntry, cq)
 		return entry
@@ -75,7 +76,7 @@ func (f *fairSharingIterator) pop() *entry {
 	// CQ is part of a Cohort. We run a tournament, to select the
 	// most fair workload at each level.
 	root := cq.Parent().Root()
-	log := f.log.WithValues("rootCohort", klog.KRef("", root.GetName()))
+	log := f.log.WithValues("rootCohort", klog.KRef("", string(root.GetName())))
 
 	log.V(5).Info("Computing DominantResourceShare for tournament")
 	f.entryComparer.computeDRS(root, f.cqToEntry)
@@ -84,8 +85,8 @@ func (f *fairSharingIterator) pop() *entry {
 	entry := runTournament(root, f.entryComparer, f.cqToEntry)
 
 	log = log.WithValues(
-		"cohort", klog.KRef("", entry.clusterQueueSnapshot.Parent().GetName()),
-		"clusterQueue", klog.KRef("", entry.clusterQueueSnapshot.GetName()),
+		"cohort", klog.KRef("", string(entry.clusterQueueSnapshot.Parent().GetName())),
+		"clusterQueue", klog.KRef("", string(entry.clusterQueueSnapshot.GetName())),
 		"winningWorkload", klog.KObj(entry.Obj))
 
 	log.V(3).Info("Determined tournament winner")
@@ -154,7 +155,7 @@ func runTournament(cohort *cache.CohortSnapshot, ec entryComparer, cqToEntry map
 }
 
 type drsKey struct {
-	parentCohort string
+	parentCohort kueue.CohortReference
 	workloadKey  string
 }
 
@@ -163,7 +164,7 @@ type entryComparer struct {
 	workloadOrdering workload.Ordering
 }
 
-func (e *entryComparer) less(a, b *entry, parentCohort string) bool {
+func (e *entryComparer) less(a, b *entry, parentCohort kueue.CohortReference) bool {
 	aDrs := e.drsValues[drsKey{parentCohort: parentCohort, workloadKey: workload.Key(a.Obj)}]
 	bDrs := e.drsValues[drsKey{parentCohort: parentCohort, workloadKey: workload.Key(b.Obj)}]
 	// 1: DRF
diff --git a/pkg/scheduler/logging.go b/pkg/scheduler/logging.go
index fd9253728..5a623e481 100644
--- a/pkg/scheduler/logging.go
+++ b/pkg/scheduler/logging.go
@@ -32,7 +32,7 @@ func logAdmissionAttemptIfVerbose(log logr.Logger, e *entry) {
 	}
 	args := []any{
 		"workload", klog.KObj(e.Obj),
-		"clusterQueue", klog.KRef("", e.ClusterQueue),
+		"clusterQueue", klog.KRef("", string(e.ClusterQueue)),
 		"status", e.status,
 		"reason", e.inadmissibleMsg,
 	}
diff --git a/pkg/scheduler/preemption/preemption.go b/pkg/scheduler/preemption/preemption.go
index 1d0718cec..0a2d41123 100644
--- a/pkg/scheduler/preemption/preemption.go
+++ b/pkg/scheduler/preemption/preemption.go
@@ -38,6 +38,7 @@ import (
 	config "sigs.k8s.io/kueue/apis/config/v1beta1"
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/cache"
+	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/metrics"
 	"sigs.k8s.io/kueue/pkg/resources"
 	"sigs.k8s.io/kueue/pkg/scheduler/flavorassigner"
@@ -96,7 +97,7 @@ func (p *Preemptor) OverrideApply(f func(context.Context, *kueue.Workload, strin
 	p.applyPreemption = f
 }
 
-func candidatesOnlyFromQueue(candidates []*workload.Info, clusterQueue string) []*workload.Info {
+func candidatesOnlyFromQueue(candidates []*workload.Info, clusterQueue kueue.ClusterQueueReference) []*workload.Info {
 	result := make([]*workload.Info, 0, len(candidates))
 	for _, wi := range candidates {
 		if wi.ClusterQueue == clusterQueue {
@@ -106,7 +107,7 @@ func candidatesOnlyFromQueue(candidates []*workload.Info, clusterQueue string) [
 	return result
 }
 
-func candidatesFromCQOrUnderThreshold(candidates []*workload.Info, clusterQueue string, threshold int32) []*workload.Info {
+func candidatesFromCQOrUnderThreshold(candidates []*workload.Info, clusterQueue kueue.ClusterQueueReference, threshold int32) []*workload.Info {
 	result := make([]*workload.Info, 0, len(candidates))
 	for _, wi := range candidates {
 		if wi.ClusterQueue == clusterQueue || priority.Priority(wi.Obj) < threshold {
@@ -204,6 +205,24 @@ var HumanReadablePreemptionReasons = map[string]string{
 	kueue.InCohortReclamationReason:           "reclamation within the cohort",
 	kueue.InCohortFairSharingReason:           "fair sharing within the cohort",
 	kueue.InCohortReclaimWhileBorrowingReason: "reclamation within the cohort while borrowing",
+	"": "UNKNOWN",
+}
+
+func preemptionMessage(preemptor *kueue.Workload, reason string) string {
+	var wUID, jUID string
+	if preemptor == nil || preemptor.UID == "" {
+		wUID = "UNKNOWN"
+	} else {
+		wUID = string(preemptor.UID)
+	}
+	uid, ok := preemptor.Labels[constants.JobUIDLabel]
+	if !ok || uid == "" {
+		jUID = "UNKNOWN"
+	} else {
+		jUID = uid
+	}
+
+	return fmt.Sprintf("Preempted to accommodate a workload (UID: %s, JobUID: %s) due to %s", wUID, jUID, HumanReadablePreemptionReasons[reason])
 }
 
 // IssuePreemptions marks the target workloads as evicted.
@@ -216,14 +235,14 @@ func (p *Preemptor) IssuePreemptions(ctx context.Context, preemptor *workload.In
 	workqueue.ParallelizeUntil(ctx, parallelPreemptions, len(targets), func(i int) {
 		target := targets[i]
 		if !meta.IsStatusConditionTrue(target.WorkloadInfo.Obj.Status.Conditions, kueue.WorkloadEvicted) {
-			message := fmt.Sprintf("Preempted to accommodate a workload (UID: %s) due to %s", preemptor.Obj.UID, HumanReadablePreemptionReasons[target.Reason])
+			message := preemptionMessage(preemptor.Obj, target.Reason)
 			err := p.applyPreemption(ctx, target.WorkloadInfo.Obj, target.Reason, message)
 			if err != nil {
 				errCh.SendErrorWithCancel(err, cancel)
 				return
 			}
 
-			log.V(3).Info("Preempted", "targetWorkload", klog.KObj(target.WorkloadInfo.Obj), "preemptingWorkload", klog.KObj(preemptor.Obj), "reason", target.Reason, "message", message, "targetClusterQueue", klog.KRef("", target.WorkloadInfo.ClusterQueue))
+			log.V(3).Info("Preempted", "targetWorkload", klog.KObj(target.WorkloadInfo.Obj), "preemptingWorkload", klog.KObj(preemptor.Obj), "reason", target.Reason, "message", message, "targetClusterQueue", klog.KRef("", string(target.WorkloadInfo.ClusterQueue)))
 			p.recorder.Eventf(target.WorkloadInfo.Obj, corev1.EventTypeNormal, "Preempted", message)
 			metrics.ReportPreemption(preemptor.ClusterQueue, target.Reason, target.WorkloadInfo.ClusterQueue)
 		} else {
@@ -458,14 +477,14 @@ type candidateCQ struct {
 func cqHeapFromCandidates(candidates []*workload.Info, firstOnly bool, snapshot *cache.Snapshot) *heap.Heap[candidateCQ] {
 	cqHeap := heap.New(
 		func(c *candidateCQ) string {
-			return c.cq.Name
+			return string(c.cq.Name)
 		},
 		func(c1, c2 *candidateCQ) bool {
 			return c1.share > c2.share
 		},
 	)
 	for _, cand := range candidates {
-		candCQ := cqHeap.GetByKey(cand.ClusterQueue)
+		candCQ := cqHeap.GetByKey(string(cand.ClusterQueue))
 		if candCQ == nil {
 			cq := snapshot.ClusterQueue(cand.ClusterQueue)
 			share := cq.DominantResourceShare()
@@ -597,7 +616,7 @@ func queueUnderNominalInResourcesNeedingPreemption(preemptionCtx *preemptionCtx)
 // same ClusterQueue as the preemptor.
 // 2. Workloads with lower priority first.
 // 3. Workloads admitted more recently first.
-func candidatesOrdering(candidates []*workload.Info, cq string, now time.Time) func(int, int) bool {
+func candidatesOrdering(candidates []*workload.Info, cq kueue.ClusterQueueReference, now time.Time) func(int, int) bool {
 	return func(i, j int) bool {
 		a := candidates[i]
 		b := candidates[j]
diff --git a/pkg/scheduler/scheduler.go b/pkg/scheduler/scheduler.go
index 4c93d4e6c..1ce869597 100644
--- a/pkg/scheduler/scheduler.go
+++ b/pkg/scheduler/scheduler.go
@@ -167,9 +167,9 @@ func setSkipped(e *entry, inadmissibleMsg string) {
 	e.LastAssignment = nil
 }
 
-func reportSkippedPreemptions(p map[string]int) {
+func reportSkippedPreemptions(p map[kueue.ClusterQueueReference]int) {
 	for cqName, count := range p {
-		metrics.AdmissionCyclePreemptionSkips.WithLabelValues(cqName).Set(float64(count))
+		metrics.AdmissionCyclePreemptionSkips.WithLabelValues(string(cqName)).Set(float64(count))
 	}
 }
 
@@ -207,14 +207,14 @@ func (s *Scheduler) schedule(ctx context.Context) wait.SpeedSignal {
 	// head got admitted that should be scheduled in the cohort before the heads
 	// of other clusterQueues.
 	preemptedWorkloads := make(preemptedWorkloads)
-	skippedPreemptions := make(map[string]int)
+	skippedPreemptions := make(map[kueue.ClusterQueueReference]int)
 	for iterator.hasNext() {
 		e := iterator.pop()
 
 		cq := snapshot.ClusterQueue(e.ClusterQueue)
-		log := log.WithValues("workload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", e.ClusterQueue))
+		log := log.WithValues("workload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", string(e.ClusterQueue)))
 		if cq.HasParent() {
-			log = log.WithValues("parentCohort", klog.KRef("", cq.Parent().GetName()), "rootCohort", klog.KRef("", cq.Parent().Root().GetName()))
+			log = log.WithValues("parentCohort", klog.KRef("", string(cq.Parent().GetName())), "rootCohort", klog.KRef("", string(cq.Parent().Root().GetName())))
 		}
 		ctx := ctrl.LoggerInto(ctx, log)
 
@@ -337,7 +337,7 @@ func (s *Scheduler) nominate(ctx context.Context, workloads []workload.Info, sna
 	log := ctrl.LoggerFrom(ctx)
 	entries := make([]entry, 0, len(workloads))
 	for _, w := range workloads {
-		log := log.WithValues("workload", klog.KObj(w.Obj), "clusterQueue", klog.KRef("", w.ClusterQueue))
+		log := log.WithValues("workload", klog.KObj(w.Obj), "clusterQueue", klog.KRef("", string(w.ClusterQueue)))
 		ns := corev1.Namespace{}
 		e := entry{Info: w}
 		e.clusterQueueSnapshot = snap.ClusterQueue(w.ClusterQueue)
@@ -491,7 +491,7 @@ func (s *Scheduler) admit(ctx context.Context, e *entry, cq *cache.ClusterQueueS
 	log := ctrl.LoggerFrom(ctx)
 	newWorkload := e.Obj.DeepCopy()
 	admission := &kueue.Admission{
-		ClusterQueue:      kueue.ClusterQueueReference(e.ClusterQueue),
+		ClusterQueue:      e.ClusterQueue,
 		PodSetAssignments: e.assignment.ToAPI(),
 	}
 
@@ -640,7 +640,7 @@ func (s *Scheduler) requeueAndUpdate(ctx context.Context, e entry) {
 		e.requeueReason = queue.RequeueReasonFailedAfterNomination
 	}
 	added := s.queues.RequeueWorkload(ctx, &e.Info, e.requeueReason)
-	log.V(2).Info("Workload re-queued", "workload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", e.ClusterQueue), "queue", klog.KRef(e.Obj.Namespace, e.Obj.Spec.QueueName), "requeueReason", e.requeueReason, "added", added, "status", e.status)
+	log.V(2).Info("Workload re-queued", "workload", klog.KObj(e.Obj), "clusterQueue", klog.KRef("", string(e.ClusterQueue)), "queue", klog.KRef(e.Obj.Namespace, e.Obj.Spec.QueueName), "requeueReason", e.requeueReason, "added", added, "status", e.status)
 
 	if e.status == notNominated || e.status == skipped {
 		patch := workload.BaseSSAWorkload(e.Obj)
diff --git a/pkg/visibility/api/v1beta1/pending_workloads_cq.go b/pkg/visibility/api/v1beta1/pending_workloads_cq.go
index 0ca18f07a..5c430b383 100644
--- a/pkg/visibility/api/v1beta1/pending_workloads_cq.go
+++ b/pkg/visibility/api/v1beta1/pending_workloads_cq.go
@@ -26,6 +26,7 @@ import (
 	"k8s.io/apiserver/pkg/registry/rest"
 	ctrl "sigs.k8s.io/controller-runtime"
 
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	visibility "sigs.k8s.io/kueue/apis/visibility/v1beta1"
 	"sigs.k8s.io/kueue/pkg/constants"
 	"sigs.k8s.io/kueue/pkg/queue"
@@ -68,7 +69,7 @@ func (m *pendingWorkloadsInCqREST) Get(_ context.Context, name string, opts runt
 	offset := pendingWorkloadOpts.Offset
 
 	wls := make([]visibility.PendingWorkload, 0, limit)
-	pendingWorkloadsInfo := m.queueMgr.PendingWorkloadsInfo(name)
+	pendingWorkloadsInfo := m.queueMgr.PendingWorkloadsInfo(kueue.ClusterQueueReference(name))
 	if pendingWorkloadsInfo == nil {
 		return nil, errors.NewNotFound(visibility.Resource("clusterqueue"), name)
 	}
diff --git a/pkg/webhooks/resourceflavor_webhook.go b/pkg/webhooks/resourceflavor_webhook.go
index 2e1e4d11b..0ec302787 100644
--- a/pkg/webhooks/resourceflavor_webhook.go
+++ b/pkg/webhooks/resourceflavor_webhook.go
@@ -98,7 +98,7 @@ func ValidateResourceFlavor(rf *kueue.ResourceFlavor) field.ErrorList {
 
 // validateNodeTaints is extracted from git.k8s.io/kubernetes/pkg/apis/core/validation/validation.go
 func validateNodeTaints(taints []corev1.Taint, fldPath *field.Path) field.ErrorList {
-	allErrors := field.ErrorList{}
+	var allErrors field.ErrorList
 
 	uniqueTaints := make(map[corev1.TaintEffect]sets.Set[string])
 
diff --git a/pkg/webhooks/workload_webhook.go b/pkg/webhooks/workload_webhook.go
index 8b73851aa..4d9295c4f 100644
--- a/pkg/webhooks/workload_webhook.go
+++ b/pkg/webhooks/workload_webhook.go
@@ -202,7 +202,7 @@ func validateImmutablePodSetUpdates(newObj, oldObj *kueue.Workload, basePath *fi
 // we do not import it as dependency, see the comment:
 // https://github.com/kubernetes/kubernetes/issues/79384#issuecomment-505627280
 func validateTolerations(tolerations []corev1.Toleration, fldPath *field.Path) field.ErrorList {
-	allErrors := field.ErrorList{}
+	var allErrors field.ErrorList
 	for i, toleration := range tolerations {
 		idxPath := fldPath.Index(i)
 		// validate the toleration key
diff --git a/pkg/workload/workload.go b/pkg/workload/workload.go
index 8d146a4a6..4443b75a9 100644
--- a/pkg/workload/workload.go
+++ b/pkg/workload/workload.go
@@ -156,7 +156,7 @@ type Info struct {
 	TotalRequests []PodSetResources
 	// Populated from the queue during admission or from the admission field if
 	// already admitted.
-	ClusterQueue   string
+	ClusterQueue   kueue.ClusterQueueReference
 	LastAssignment *AssignmentClusterQueueState
 }
 
@@ -223,7 +223,7 @@ func NewInfo(w *kueue.Workload, opts ...InfoOption) *Info {
 		Obj: w,
 	}
 	if w.Status.Admission != nil {
-		info.ClusterQueue = string(w.Status.Admission.ClusterQueue)
+		info.ClusterQueue = w.Status.Admission.ClusterQueue
 		info.TotalRequests = totalRequestsFromAdmission(w)
 	} else {
 		info.TotalRequests = totalRequestsFromPodSets(w, &options)
@@ -879,7 +879,7 @@ func AdmissionChecksForWorkload(log logr.Logger, wl *kueue.Workload, admissionCh
 	return acNames
 }
 
-func ReportEvictedWorkload(recorder record.EventRecorder, wl *kueue.Workload, cqName, reason, message string) {
+func ReportEvictedWorkload(recorder record.EventRecorder, wl *kueue.Workload, cqName kueue.ClusterQueueReference, reason, message string) {
 	metrics.ReportEvictedWorkloads(cqName, reason)
 	if features.Enabled(features.LocalQueueMetrics) {
 		metrics.ReportLocalQueueEvictedWorkloads(metrics.LQRefFromWorkload(wl), reason)
diff --git a/site/content/en/docs/concepts/preemption.md b/site/content/en/docs/concepts/preemption.md
index cc78d5b20..4dbfbb485 100644
--- a/site/content/en/docs/concepts/preemption.md
+++ b/site/content/en/docs/concepts/preemption.md
@@ -29,17 +29,16 @@ that is similar to the following:
 
 ```yaml
 status:
-  conditions:
-  - lastTransitionTime: "2024-05-31T18:42:33Z"
-    message: 'Preempted to accommodate a workload (UID: 5515f7da-d2ea-4851-9e9c-6b8b3333734d)
-      in the ClusterQueue'
+  - lastTransitionTime: "2025-03-07T21:19:54Z"
+    message: 'Preempted to accommodate a workload (UID: 5c023c28-8533-4927-b266-56bca5e310c1,
+      JobUID: 4548c8bd-c399-4027-bb02-6114f3a8cdeb) due to prioritization in the ClusterQueue'
     observedGeneration: 1
     reason: Preempted
     status: "True"
     type: Evicted
-  - lastTransitionTime: "2024-05-31T18:42:33Z"
-    message: 'Preempted to accommodate a workload (UID: 5515f7da-d2ea-4851-9e9c-6b8b3333734d)
-      in the ClusterQueue'
+  - lastTransitionTime: "2025-03-07T21:19:54Z"
+    message: 'Preempted to accommodate a workload (UID: 5c023c28-8533-4927-b266-56bca5e310c1,
+      JobUID: 4548c8bd-c399-4027-bb02-6114f3a8cdeb) due to prioritization in the ClusterQueue'
     reason: InClusterQueue
     status: "True"
     type: Preempted
@@ -48,6 +47,8 @@ status:
 The `Evicted` condition indicates that the Workload was evicted with a reason `Preempted`,
 whereas the `Preempted` condition gives more details about the preemption reason.
 
+The preempting workload can be found by running `kubectl get workloads --selector=kueue.x-k8s.io/job-uid=<JobUID> --all-namespaces`.
+
 ## Preemption algorithms
 
 Kueue offers two preemption algorithms. The main difference between them is the criteria to allow
diff --git a/site/content/en/docs/concepts/topology_aware_scheduling.md b/site/content/en/docs/concepts/topology_aware_scheduling.md
index 10c044097..0dedcfc26 100644
--- a/site/content/en/docs/concepts/topology_aware_scheduling.md
+++ b/site/content/en/docs/concepts/topology_aware_scheduling.md
@@ -100,14 +100,12 @@ to a TAS ResourceFlavor.
 
 ### Limitations
 
-Currently, there are multiple limitations for the compatibility of the feature
-with other features. In particular, a ClusterQueue referencing a TAS Resource
-Flavor (with the `.spec.topologyName` field) is marked as inactive in the
-following scenarios:
-- the CQ is in cohort (`.spec.cohort` is set)
-- the CQ is using [preemption](preemption.md)
-- the CQ is using [MultiKueue](multikueue.md) or
-  [ProvisioningRequest](/docs/admission-check-controllers/provisioning/) admission checks
+Currently, there are limitations for the compatibility of TAS with other
+features. In particular, a ClusterQueue referencing a TAS Resource
+Flavor (with the `.spec.topologyName` field) is marked as inactive if also
+using [MultiKueue](multikueue.md) or
+[ProvisioningRequest](/docs/admission-check-controllers/provisioning/) admission
+checks.
 
 These usage scenarios are considered to be supported in the future releases
 of Kueue.
diff --git a/site/content/en/docs/reference/kueue-alpha.v1alpha1.md b/site/content/en/docs/reference/kueue-alpha.v1alpha1.md
index 70d2fa7f2..d8ed3dfba 100644
--- a/site/content/en/docs/reference/kueue-alpha.v1alpha1.md
+++ b/site/content/en/docs/reference/kueue-alpha.v1alpha1.md
@@ -83,7 +83,7 @@ results in undefined behavior in 0.9</p>
     
   
 <tr><td><code>parent</code> <B>[Required]</B><br/>
-<code>string</code>
+<a href="#kueue-x-k8s-io-v1beta1-CohortReference"><code>CohortReference</code></a>
 </td>
 <td>
    <p>Parent references the name of the Cohort's parent, if
diff --git a/site/content/en/docs/reference/kueue.v1beta1.md b/site/content/en/docs/reference/kueue.v1beta1.md
index 6f06ebe80..0edccabd4 100644
--- a/site/content/en/docs/reference/kueue.v1beta1.md
+++ b/site/content/en/docs/reference/kueue.v1beta1.md
@@ -821,7 +821,7 @@ resourceGroups can be up to 16.</p>
 </td>
 </tr>
 <tr><td><code>cohort</code> <B>[Required]</B><br/>
-<code>string</code>
+<a href="#kueue-x-k8s-io-v1beta1-CohortReference"><code>CohortReference</code></a>
 </td>
 <td>
    <p>cohort that this ClusterQueue belongs to. CQs that belong to the
@@ -834,8 +834,6 @@ If empty, this ClusterQueue cannot borrow from any other ClusterQueue and
 vice versa.</p>
 <p>A cohort is a name that links CQs together, but it doesn't reference any
 object.</p>
-<p>Validation of a cohort name is equivalent to that of object names:
-subdomain in DNS (RFC 1123).</p>
 </td>
 </tr>
 <tr><td><code>queueingStrategy</code> <B>[Required]</B><br/>
@@ -1007,6 +1005,22 @@ instead.</p>
 </tbody>
 </table>
 
+## `CohortReference`     {#kueue-x-k8s-io-v1beta1-CohortReference}
+    
+(Alias of `string`)
+
+**Appears in:**
+
+- [ClusterQueueSpec](#kueue-x-k8s-io-v1beta1-ClusterQueueSpec)
+
+
+<p>CohortReference is the name of the Cohort.</p>
+<p>Validation of a cohort name is equivalent to that of object names:
+subdomain in DNS (RFC 1123).</p>
+
+
+
+
 ## `FairSharing`     {#kueue-x-k8s-io-v1beta1-FairSharing}
     
 
diff --git a/site/package-lock.json b/site/package-lock.json
index d1c877d29..873531d2f 100644
--- a/site/package-lock.json
+++ b/site/package-lock.json
@@ -5,7 +5,7 @@
   "packages": {
     "": {
       "devDependencies": {
-        "autoprefixer": "^10.4.20",
+        "autoprefixer": "^10.4.21",
         "cross-env": "^7.0.3",
         "postcss-cli": "^11.0.0"
       }
@@ -95,9 +95,9 @@
       }
     },
     "node_modules/autoprefixer": {
-      "version": "10.4.20",
-      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.20.tgz",
-      "integrity": "sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==",
+      "version": "10.4.21",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.21.tgz",
+      "integrity": "sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==",
       "dev": true,
       "funding": [
         {
@@ -113,12 +113,13 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "license": "MIT",
       "dependencies": {
-        "browserslist": "^4.23.3",
-        "caniuse-lite": "^1.0.30001646",
+        "browserslist": "^4.24.4",
+        "caniuse-lite": "^1.0.30001702",
         "fraction.js": "^4.3.7",
         "normalize-range": "^0.1.2",
-        "picocolors": "^1.0.1",
+        "picocolors": "^1.1.1",
         "postcss-value-parser": "^4.2.0"
       },
       "bin": {
@@ -156,9 +157,9 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.23.3",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.3.tgz",
-      "integrity": "sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==",
+      "version": "4.24.4",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz",
+      "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==",
       "dev": true,
       "funding": [
         {
@@ -174,11 +175,12 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "license": "MIT",
       "dependencies": {
-        "caniuse-lite": "^1.0.30001646",
-        "electron-to-chromium": "^1.5.4",
-        "node-releases": "^2.0.18",
-        "update-browserslist-db": "^1.1.0"
+        "caniuse-lite": "^1.0.30001688",
+        "electron-to-chromium": "^1.5.73",
+        "node-releases": "^2.0.19",
+        "update-browserslist-db": "^1.1.1"
       },
       "bin": {
         "browserslist": "cli.js"
@@ -188,9 +190,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001649",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001649.tgz",
-      "integrity": "sha512-fJegqZZ0ZX8HOWr6rcafGr72+xcgJKI9oWfDW5DrD7ExUtgZC7a7R7ZYmZqplh7XDocFdGeIFn7roAxhOeYrPQ==",
+      "version": "1.0.30001703",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001703.tgz",
+      "integrity": "sha512-kRlAGTRWgPsOj7oARC9m1okJEXdL/8fekFVcxA8Hl7GH4r/sN4OJn/i6Flde373T50KS7Y37oFbMwlE8+F42kQ==",
       "dev": true,
       "funding": [
         {
@@ -205,7 +207,8 @@
           "type": "github",
           "url": "https://github.com/sponsors/ai"
         }
-      ]
+      ],
+      "license": "CC-BY-4.0"
     },
     "node_modules/chokidar": {
       "version": "3.6.0",
@@ -305,10 +308,11 @@
       }
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.4",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.4.tgz",
-      "integrity": "sha512-orzA81VqLyIGUEA77YkVA1D+N+nNfl2isJVjjmOyrlxuooZ19ynb+dOlaDTqd/idKRS9lDCSBmtzM+kyCsMnkA==",
-      "dev": true
+      "version": "1.5.114",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.114.tgz",
+      "integrity": "sha512-DFptFef3iktoKlFQK/afbo274/XNWD00Am0xa7M8FZUepHlHT8PEuiNBoRfFHbH1okqN58AlhbJ4QTkcnXorjA==",
+      "dev": true,
+      "license": "ISC"
     },
     "node_modules/emoji-regex": {
       "version": "8.0.0",
@@ -317,10 +321,11 @@
       "dev": true
     },
     "node_modules/escalade": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
-      "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=6"
       }
@@ -594,10 +599,11 @@
       }
     },
     "node_modules/node-releases": {
-      "version": "2.0.18",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
-      "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
-      "dev": true
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
+      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/normalize-path": {
       "version": "3.0.0",
@@ -639,10 +645,11 @@
       }
     },
     "node_modules/picocolors": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.0.1.tgz",
-      "integrity": "sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==",
-      "dev": true
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
     },
     "node_modules/picomatch": {
       "version": "2.3.1",
@@ -991,9 +998,9 @@
       }
     },
     "node_modules/update-browserslist-db": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.0.tgz",
-      "integrity": "sha512-EdRAaAyk2cUE1wOf2DkEhzxqOQvFOoRJFNS6NeyJ01Gp2beMRpBAINjM2iDXE3KCuKhwnvHIQCJm6ThL2Z+HzQ==",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
+      "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==",
       "dev": true,
       "funding": [
         {
@@ -1009,9 +1016,10 @@
           "url": "https://github.com/sponsors/ai"
         }
       ],
+      "license": "MIT",
       "dependencies": {
-        "escalade": "^3.1.2",
-        "picocolors": "^1.0.1"
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
       },
       "bin": {
         "update-browserslist-db": "cli.js"
diff --git a/site/package.json b/site/package.json
index 177b338d8..03798d631 100644
--- a/site/package.json
+++ b/site/package.json
@@ -1,6 +1,6 @@
 {
   "devDependencies": {
-    "autoprefixer": "^10.4.20",
+    "autoprefixer": "^10.4.21",
     "cross-env": "^7.0.3",
     "postcss-cli": "^11.0.0"
   }
diff --git a/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md b/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
index f9d52e584..0d5506ca2 100644
--- a/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
+++ b/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
@@ -1,3 +1,26 @@
+## 2.23.0
+
+Ginkgo 2.23.0 adds a handful of methods to `GinkgoT()` to make it compatible with the `testing.TB` interface in Go 1.24.  `GinkgoT().Context()`, in particular, is a useful shorthand for generating a new context that will clean itself up in a `DeferCleanup()`.  This has subtle behavior differences from the golang implementation but should make sense in a Ginkgo... um... context.
+
+### Features
+- bump to go 1.24.0 - support new testing.TB methods and add a test to cover testing.TB regressions [37a511b]
+
+### Fixes
+- fix edge case where build -o is pointing at an explicit file, not a directory [7556a86]
+- Fix binary paths when precompiling multiple suites. [4df06c6]
+
+### Maintenance
+- Fix: Correct Markdown list rendering in MIGRATING_TO_V2.md [cbcf39a]
+- docs: fix test workflow badge (#1512) [9b261ff]
+- Bump golang.org/x/net in /integration/_fixtures/version_mismatch_fixture (#1516) [00f19c8]
+- Bump golang.org/x/tools from 0.28.0 to 0.30.0 (#1515) [e98a4df]
+- Bump activesupport from 6.0.6.1 to 6.1.7.5 in /docs (#1504) [60cc4e2]
+- Bump github-pages from 231 to 232 in /docs (#1447) [fea6f2d]
+- Bump rexml from 3.2.8 to 3.3.9 in /docs (#1497) [31d7813]
+- Bump webrick from 1.8.1 to 1.9.1 in /docs (#1501) [fc3bbd6]
+- Code linting (#1500) [aee0d56]
+- change interface{} to any (#1502) [809a710]
+
 ## 2.22.2
 
 ### Maintenance
@@ -630,7 +653,7 @@ Ginkgo also uses this progress reporting infrastructure under the hood when hand
 ### Features
 - `BeforeSuite`, `AfterSuite`, `SynchronizedBeforeSuite`, `SynchronizedAfterSuite`, and `ReportAfterSuite` now support (the relevant subset of) decorators.  These can be passed in _after_ the callback functions that are usually passed into these nodes.
 
-  As a result the **signature of these methods has changed** and now includes a trailing `args ...interface{}`.  For most users simply using the DSL, this change is transparent.  However if you were assigning one of these functions to a custom variable (or passing it around) then your code may need to change to reflect the new signature.
+  As a result the **signature of these methods has changed** and now includes a trailing `args ...any`.  For most users simply using the DSL, this change is transparent.  However if you were assigning one of these functions to a custom variable (or passing it around) then your code may need to change to reflect the new signature.
 
 ### Maintenance
 - Modernize the invocation of Ginkgo in github actions [0ffde58]
diff --git a/vendor/github.com/onsi/ginkgo/v2/README.md b/vendor/github.com/onsi/ginkgo/v2/README.md
index cb23ffdf6..e3d0c13cc 100644
--- a/vendor/github.com/onsi/ginkgo/v2/README.md
+++ b/vendor/github.com/onsi/ginkgo/v2/README.md
@@ -1,6 +1,6 @@
 ![Ginkgo](https://onsi.github.io/ginkgo/images/ginkgo.png)
 
-[![test](https://github.com/onsi/ginkgo/workflows/test/badge.svg?branch=master)](https://github.com/onsi/ginkgo/actions?query=workflow%3Atest+branch%3Amaster) | [Ginkgo Docs](https://onsi.github.io/ginkgo/)
+[![test](https://github.com/onsi/ginkgo/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/onsi/ginkgo/actions?query=workflow%3Atest+branch%3Amaster) | [Ginkgo Docs](https://onsi.github.io/ginkgo/)
 
 ---
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/core_dsl.go b/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
index a3e8237e9..d027bdff9 100644
--- a/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
@@ -83,9 +83,9 @@ func exitIfErrors(errors []error) {
 type GinkgoWriterInterface interface {
 	io.Writer
 
-	Print(a ...interface{})
-	Printf(format string, a ...interface{})
-	Println(a ...interface{})
+	Print(a ...any)
+	Printf(format string, a ...any)
+	Println(a ...any)
 
 	TeeTo(writer io.Writer)
 	ClearTeeWriters()
@@ -243,7 +243,7 @@ for more on how specs are parallelized in Ginkgo.
 
 You can also pass suite-level Label() decorators to RunSpecs.  The passed-in labels will apply to all specs in the suite.
 */
-func RunSpecs(t GinkgoTestingT, description string, args ...interface{}) bool {
+func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
 	if suiteDidRun {
 		exitIfErr(types.GinkgoErrors.RerunningSuite())
 	}
@@ -316,7 +316,7 @@ func RunSpecs(t GinkgoTestingT, description string, args ...interface{}) bool {
 	return passed
 }
 
-func extractSuiteConfiguration(args []interface{}) Labels {
+func extractSuiteConfiguration(args []any) Labels {
 	suiteLabels := Labels{}
 	configErrors := []error{}
 	for _, arg := range args {
@@ -491,14 +491,14 @@ to Describe the behavior of an object or function and, within that Describe, out
 You can learn more at https://onsi.github.io/ginkgo/#organizing-specs-with-container-nodes
 In addition, container nodes can be decorated with a variety of decorators.  You can learn more here: https://onsi.github.io/ginkgo/#decorator-reference
 */
-func Describe(text string, args ...interface{}) bool {
+func Describe(text string, args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, text, args...))
 }
 
 /*
 FDescribe focuses specs within the Describe block.
 */
-func FDescribe(text string, args ...interface{}) bool {
+func FDescribe(text string, args ...any) bool {
 	args = append(args, internal.Focus)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, text, args...))
 }
@@ -506,7 +506,7 @@ func FDescribe(text string, args ...interface{}) bool {
 /*
 PDescribe marks specs within the Describe block as pending.
 */
-func PDescribe(text string, args ...interface{}) bool {
+func PDescribe(text string, args ...any) bool {
 	args = append(args, internal.Pending)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, text, args...))
 }
@@ -522,18 +522,18 @@ var XDescribe = PDescribe
 var Context, FContext, PContext, XContext = Describe, FDescribe, PDescribe, XDescribe
 
 /* When is an alias for Describe - it generates the exact same kind of Container node */
-func When(text string, args ...interface{}) bool {
+func When(text string, args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, "when "+text, args...))
 }
 
 /* When is an alias for Describe - it generates the exact same kind of Container node */
-func FWhen(text string, args ...interface{}) bool {
+func FWhen(text string, args ...any) bool {
 	args = append(args, internal.Focus)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, "when "+text, args...))
 }
 
 /* When is an alias for Describe - it generates the exact same kind of Container node */
-func PWhen(text string, args ...interface{}) bool {
+func PWhen(text string, args ...any) bool {
 	args = append(args, internal.Pending)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, "when "+text, args...))
 }
@@ -550,14 +550,14 @@ You can pass It nodes bare functions (func() {}) or functions that receive a Spe
 You can learn more at https://onsi.github.io/ginkgo/#spec-subjects-it
 In addition, subject nodes can be decorated with a variety of decorators.  You can learn more here: https://onsi.github.io/ginkgo/#decorator-reference
 */
-func It(text string, args ...interface{}) bool {
+func It(text string, args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeIt, text, args...))
 }
 
 /*
 FIt allows you to focus an individual It.
 */
-func FIt(text string, args ...interface{}) bool {
+func FIt(text string, args ...any) bool {
 	args = append(args, internal.Focus)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeIt, text, args...))
 }
@@ -565,7 +565,7 @@ func FIt(text string, args ...interface{}) bool {
 /*
 PIt allows you to mark an individual It as pending.
 */
-func PIt(text string, args ...interface{}) bool {
+func PIt(text string, args ...any) bool {
 	args = append(args, internal.Pending)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeIt, text, args...))
 }
@@ -611,8 +611,8 @@ BeforeSuite can take a func() body, or an interruptible func(SpecContext)/func(c
 You cannot nest any other Ginkgo nodes within a BeforeSuite node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#suite-setup-and-cleanup-beforesuite-and-aftersuite
 */
-func BeforeSuite(body interface{}, args ...interface{}) bool {
-	combinedArgs := []interface{}{body}
+func BeforeSuite(body any, args ...any) bool {
+	combinedArgs := []any{body}
 	combinedArgs = append(combinedArgs, args...)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeBeforeSuite, "", combinedArgs...))
 }
@@ -630,8 +630,8 @@ AfterSuite can take a func() body, or an interruptible func(SpecContext)/func(co
 You cannot nest any other Ginkgo nodes within an AfterSuite node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#suite-setup-and-cleanup-beforesuite-and-aftersuite
 */
-func AfterSuite(body interface{}, args ...interface{}) bool {
-	combinedArgs := []interface{}{body}
+func AfterSuite(body any, args ...any) bool {
+	combinedArgs := []any{body}
 	combinedArgs = append(combinedArgs, args...)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeAfterSuite, "", combinedArgs...))
 }
@@ -667,8 +667,8 @@ If either function receives a context.Context/SpecContext it is considered inter
 You cannot nest any other Ginkgo nodes within an SynchronizedBeforeSuite node's closure.
 You can learn more, and see some examples, here: https://onsi.github.io/ginkgo/#parallel-suite-setup-and-cleanup-synchronizedbeforesuite-and-synchronizedaftersuite
 */
-func SynchronizedBeforeSuite(process1Body interface{}, allProcessBody interface{}, args ...interface{}) bool {
-	combinedArgs := []interface{}{process1Body, allProcessBody}
+func SynchronizedBeforeSuite(process1Body any, allProcessBody any, args ...any) bool {
+	combinedArgs := []any{process1Body, allProcessBody}
 	combinedArgs = append(combinedArgs, args...)
 
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeSynchronizedBeforeSuite, "", combinedArgs...))
@@ -687,8 +687,8 @@ Note that you can also use DeferCleanup() in SynchronizedBeforeSuite to accompli
 You cannot nest any other Ginkgo nodes within an SynchronizedAfterSuite node's closure.
 You can learn more, and see some examples, here: https://onsi.github.io/ginkgo/#parallel-suite-setup-and-cleanup-synchronizedbeforesuite-and-synchronizedaftersuite
 */
-func SynchronizedAfterSuite(allProcessBody interface{}, process1Body interface{}, args ...interface{}) bool {
-	combinedArgs := []interface{}{allProcessBody, process1Body}
+func SynchronizedAfterSuite(allProcessBody any, process1Body any, args ...any) bool {
+	combinedArgs := []any{allProcessBody, process1Body}
 	combinedArgs = append(combinedArgs, args...)
 
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeSynchronizedAfterSuite, "", combinedArgs...))
@@ -703,7 +703,7 @@ BeforeEach can take a func() body, or an interruptible func(SpecContext)/func(co
 You cannot nest any other Ginkgo nodes within a BeforeEach node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#extracting-common-setup-beforeeach
 */
-func BeforeEach(args ...interface{}) bool {
+func BeforeEach(args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeBeforeEach, "", args...))
 }
 
@@ -716,7 +716,7 @@ JustBeforeEach can take a func() body, or an interruptible func(SpecContext)/fun
 You cannot nest any other Ginkgo nodes within a JustBeforeEach node's closure.
 You can learn more and see some examples here: https://onsi.github.io/ginkgo/#separating-creation-and-configuration-justbeforeeach
 */
-func JustBeforeEach(args ...interface{}) bool {
+func JustBeforeEach(args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeJustBeforeEach, "", args...))
 }
 
@@ -731,7 +731,7 @@ AfterEach can take a func() body, or an interruptible func(SpecContext)/func(con
 You cannot nest any other Ginkgo nodes within an AfterEach node's closure.
 You can learn more here: https://onsi.github.io/ginkgo/#spec-cleanup-aftereach-and-defercleanup
 */
-func AfterEach(args ...interface{}) bool {
+func AfterEach(args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeAfterEach, "", args...))
 }
 
@@ -743,7 +743,7 @@ JustAfterEach can take a func() body, or an interruptible func(SpecContext)/func
 You cannot nest any other Ginkgo nodes within a JustAfterEach node's closure.
 You can learn more and see some examples here: https://onsi.github.io/ginkgo/#separating-diagnostics-collection-and-teardown-justaftereach
 */
-func JustAfterEach(args ...interface{}) bool {
+func JustAfterEach(args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeJustAfterEach, "", args...))
 }
 
@@ -758,7 +758,7 @@ You cannot nest any other Ginkgo nodes within a BeforeAll node's closure.
 You can learn more about Ordered Containers at: https://onsi.github.io/ginkgo/#ordered-containers
 And you can learn more about BeforeAll at: https://onsi.github.io/ginkgo/#setup-in-ordered-containers-beforeall-and-afterall
 */
-func BeforeAll(args ...interface{}) bool {
+func BeforeAll(args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeBeforeAll, "", args...))
 }
 
@@ -775,7 +775,7 @@ You cannot nest any other Ginkgo nodes within an AfterAll node's closure.
 You can learn more about Ordered Containers at: https://onsi.github.io/ginkgo/#ordered-containers
 And you can learn more about AfterAll at: https://onsi.github.io/ginkgo/#setup-in-ordered-containers-beforeall-and-afterall
 */
-func AfterAll(args ...interface{}) bool {
+func AfterAll(args ...any) bool {
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeAfterAll, "", args...))
 }
 
@@ -818,7 +818,7 @@ When DeferCleanup is called in BeforeSuite, SynchronizedBeforeSuite, AfterSuite,
 Note that DeferCleanup does not represent a node but rather dynamically generates the appropriate type of cleanup node based on the context in which it is called.  As such you must call DeferCleanup within a Setup or Subject node, and not within a Container node.
 You can learn more about DeferCleanup here: https://onsi.github.io/ginkgo/#cleaning-up-our-cleanup-code-defercleanup
 */
-func DeferCleanup(args ...interface{}) {
+func DeferCleanup(args ...any) {
 	fail := func(message string, cl types.CodeLocation) {
 		global.Failer.Fail(message, cl)
 	}
diff --git a/vendor/github.com/onsi/ginkgo/v2/deprecated_dsl.go b/vendor/github.com/onsi/ginkgo/v2/deprecated_dsl.go
index f912bbec6..fd45b8bea 100644
--- a/vendor/github.com/onsi/ginkgo/v2/deprecated_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/deprecated_dsl.go
@@ -118,9 +118,9 @@ Use Gomega's gmeasure package instead.
 You can learn more here: https://onsi.github.io/ginkgo/#benchmarking-code
 */
 type Benchmarker interface {
-	Time(name string, body func(), info ...interface{}) (elapsedTime time.Duration)
-	RecordValue(name string, value float64, info ...interface{})
-	RecordValueWithPrecision(name string, value float64, units string, precision int, info ...interface{})
+	Time(name string, body func(), info ...any) (elapsedTime time.Duration)
+	RecordValue(name string, value float64, info ...any)
+	RecordValueWithPrecision(name string, value float64, units string, precision int, info ...any)
 }
 
 /*
@@ -129,7 +129,7 @@ Deprecated: Measure() has been removed from Ginkgo 2.0
 Use Gomega's gmeasure package instead.
 You can learn more here: https://onsi.github.io/ginkgo/#benchmarking-code
 */
-func Measure(_ ...interface{}) bool {
+func Measure(_ ...any) bool {
 	deprecationTracker.TrackDeprecation(types.Deprecations.Measure(), types.NewCodeLocation(1))
 	return true
 }
diff --git a/vendor/github.com/onsi/ginkgo/v2/formatter/formatter.go b/vendor/github.com/onsi/ginkgo/v2/formatter/formatter.go
index 4d5749114..f61356db1 100644
--- a/vendor/github.com/onsi/ginkgo/v2/formatter/formatter.go
+++ b/vendor/github.com/onsi/ginkgo/v2/formatter/formatter.go
@@ -24,15 +24,15 @@ const (
 
 var SingletonFormatter = New(ColorModeTerminal)
 
-func F(format string, args ...interface{}) string {
+func F(format string, args ...any) string {
 	return SingletonFormatter.F(format, args...)
 }
 
-func Fi(indentation uint, format string, args ...interface{}) string {
+func Fi(indentation uint, format string, args ...any) string {
 	return SingletonFormatter.Fi(indentation, format, args...)
 }
 
-func Fiw(indentation uint, maxWidth uint, format string, args ...interface{}) string {
+func Fiw(indentation uint, maxWidth uint, format string, args ...any) string {
 	return SingletonFormatter.Fiw(indentation, maxWidth, format, args...)
 }
 
@@ -115,15 +115,15 @@ func New(colorMode ColorMode) Formatter {
 	return f
 }
 
-func (f Formatter) F(format string, args ...interface{}) string {
+func (f Formatter) F(format string, args ...any) string {
 	return f.Fi(0, format, args...)
 }
 
-func (f Formatter) Fi(indentation uint, format string, args ...interface{}) string {
+func (f Formatter) Fi(indentation uint, format string, args ...any) string {
 	return f.Fiw(indentation, 0, format, args...)
 }
 
-func (f Formatter) Fiw(indentation uint, maxWidth uint, format string, args ...interface{}) string {
+func (f Formatter) Fiw(indentation uint, maxWidth uint, format string, args ...any) string {
 	out := f.style(format)
 	if len(args) > 0 {
 		out = fmt.Sprintf(out, args...)
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go
index fd1726084..a071b8d09 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go
@@ -55,18 +55,22 @@ func buildSpecs(args []string, cliConfig types.CLIConfig, goFlagsConfig types.Go
 		if suite.State.Is(internal.TestSuiteStateFailedToCompile) {
 			fmt.Println(suite.CompilationError.Error())
 		} else {
-			if len(goFlagsConfig.O) == 0 {
-				goFlagsConfig.O = path.Join(suite.Path, suite.PackageName+".test")
-			} else {
+			var testBinPath string
+			if len(goFlagsConfig.O) != 0 {
 				stat, err := os.Stat(goFlagsConfig.O)
 				if err != nil {
 					panic(err)
 				}
 				if stat.IsDir() {
-					goFlagsConfig.O += "/" + suite.PackageName + ".test"
+					testBinPath = goFlagsConfig.O + "/" + suite.PackageName + ".test"
+				} else {
+					testBinPath = goFlagsConfig.O
 				}
 			}
-			fmt.Printf("Compiled %s\n", goFlagsConfig.O)
+			if len(testBinPath) == 0 {
+				testBinPath = path.Join(suite.Path, suite.PackageName+".test")
+			}
+			fmt.Printf("Compiled %s\n", testBinPath)
 		}
 	}
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/abort.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/abort.go
index 2efd28608..f0e7331f7 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/abort.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/abort.go
@@ -12,7 +12,7 @@ func Abort(details AbortDetails) {
 	panic(details)
 }
 
-func AbortGracefullyWith(format string, args ...interface{}) {
+func AbortGracefullyWith(format string, args ...any) {
 	Abort(AbortDetails{
 		ExitCode:  0,
 		Error:     fmt.Errorf(format, args...),
@@ -20,7 +20,7 @@ func AbortGracefullyWith(format string, args ...interface{}) {
 	})
 }
 
-func AbortWith(format string, args ...interface{}) {
+func AbortWith(format string, args ...any) {
 	Abort(AbortDetails{
 		ExitCode:  1,
 		Error:     fmt.Errorf(format, args...),
@@ -28,7 +28,7 @@ func AbortWith(format string, args ...interface{}) {
 	})
 }
 
-func AbortWithUsage(format string, args ...interface{}) {
+func AbortWithUsage(format string, args ...any) {
 	Abort(AbortDetails{
 		ExitCode:  1,
 		Error:     fmt.Errorf(format, args...),
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/program.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/program.go
index 88dd8d6b0..c3f6d3a11 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/program.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/command/program.go
@@ -68,7 +68,6 @@ func (p Program) RunAndExit(osArgs []string) {
 			fmt.Fprintln(p.ErrWriter, deprecationTracker.DeprecationsReport())
 		}
 		p.Exiter(exitCode)
-		return
 	}()
 
 	args, additionalArgs := []string{}, []string{}
@@ -157,7 +156,6 @@ func (p Program) handleHelpRequestsAndExit(writer io.Writer, args []string) {
 		p.EmitUsage(writer)
 		Abort(AbortDetails{ExitCode: 1})
 	}
-	return
 }
 
 func (p Program) EmitUsage(writer io.Writer) {
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/gocovmerge.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/gocovmerge.go
index 3c5079ff4..87cfa1119 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/gocovmerge.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/gocovmerge.go
@@ -89,7 +89,7 @@ func mergeProfileBlock(p *cover.Profile, pb cover.ProfileBlock, startIndex int)
 	}
 
 	i := 0
-	if sortFunc(i) != true {
+	if !sortFunc(i) {
 		i = sort.Search(len(p.Blocks)-startIndex, sortFunc)
 	}
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/run/run_command.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/run/run_command.go
index aaed4d570..b7d77390b 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/run/run_command.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/run/run_command.go
@@ -142,7 +142,7 @@ OUTER_LOOP:
 			}
 
 			if !endTime.IsZero() {
-				r.suiteConfig.Timeout = endTime.Sub(time.Now())
+				r.suiteConfig.Timeout = time.Until(endTime)
 				if r.suiteConfig.Timeout <= 0 {
 					suites[suiteIdx].State = internal.TestSuiteStateFailedDueToTimeout
 					opc.StopAndDrain()
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go
index 02c6739e5..0ca6e235b 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go
@@ -1,6 +1,7 @@
 package ginkgo
 
 import (
+	"context"
 	"testing"
 
 	"github.com/onsi/ginkgo/v2/internal/testingtproxy"
@@ -48,6 +49,8 @@ The portion of the interface returned by GinkgoT() that maps onto methods in the
 */
 type GinkgoTInterface interface {
 	Cleanup(func())
+	Chdir(dir string)
+	Context() context.Context
 	Setenv(kev, value string)
 	Error(args ...any)
 	Errorf(format string, args ...any)
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/failer.go b/vendor/github.com/onsi/ginkgo/v2/internal/failer.go
index e9bd9565f..8c5de9c16 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/failer.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/failer.go
@@ -32,7 +32,7 @@ func (f *Failer) GetFailure() types.Failure {
 	return f.failure
 }
 
-func (f *Failer) Panic(location types.CodeLocation, forwardedPanic interface{}) {
+func (f *Failer) Panic(location types.CodeLocation, forwardedPanic any) {
 	f.lock.Lock()
 	defer f.lock.Unlock()
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/interrupt_handler/interrupt_handler.go b/vendor/github.com/onsi/ginkgo/v2/internal/interrupt_handler/interrupt_handler.go
index 8ed86111f..79bfa87db 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/interrupt_handler/interrupt_handler.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/interrupt_handler/interrupt_handler.go
@@ -40,7 +40,7 @@ func (ic InterruptCause) String() string {
 }
 
 type InterruptStatus struct {
-	Channel chan interface{}
+	Channel chan any
 	Level   InterruptLevel
 	Cause   InterruptCause
 }
@@ -62,14 +62,14 @@ type InterruptHandlerInterface interface {
 }
 
 type InterruptHandler struct {
-	c                 chan interface{}
+	c                 chan any
 	lock              *sync.Mutex
 	level             InterruptLevel
 	cause             InterruptCause
 	client            parallel_support.Client
-	stop              chan interface{}
+	stop              chan any
 	signals           []os.Signal
-	requestAbortCheck chan interface{}
+	requestAbortCheck chan any
 }
 
 func NewInterruptHandler(client parallel_support.Client, signals ...os.Signal) *InterruptHandler {
@@ -77,10 +77,10 @@ func NewInterruptHandler(client parallel_support.Client, signals ...os.Signal) *
 		signals = []os.Signal{os.Interrupt, syscall.SIGTERM}
 	}
 	handler := &InterruptHandler{
-		c:                 make(chan interface{}),
+		c:                 make(chan any),
 		lock:              &sync.Mutex{},
-		stop:              make(chan interface{}),
-		requestAbortCheck: make(chan interface{}),
+		stop:              make(chan any),
+		requestAbortCheck: make(chan any),
 		client:            client,
 		signals:           signals,
 	}
@@ -98,9 +98,9 @@ func (handler *InterruptHandler) registerForInterrupts() {
 	signal.Notify(signalChannel, handler.signals...)
 
 	// cross-process abort handling
-	var abortChannel chan interface{}
+	var abortChannel chan any
 	if handler.client != nil {
-		abortChannel = make(chan interface{})
+		abortChannel = make(chan any)
 		go func() {
 			pollTicker := time.NewTicker(ABORT_POLLING_INTERVAL)
 			for {
@@ -125,7 +125,7 @@ func (handler *InterruptHandler) registerForInterrupts() {
 		}()
 	}
 
-	go func(abortChannel chan interface{}) {
+	go func(abortChannel chan any) {
 		var interruptCause InterruptCause
 		for {
 			select {
@@ -151,7 +151,7 @@ func (handler *InterruptHandler) registerForInterrupts() {
 			}
 			if handler.level != oldLevel {
 				close(handler.c)
-				handler.c = make(chan interface{})
+				handler.c = make(chan any)
 			}
 			handler.lock.Unlock()
 		}
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/node.go b/vendor/github.com/onsi/ginkgo/v2/internal/node.go
index 0686f7410..8096950b6 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/node.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/node.go
@@ -84,7 +84,7 @@ const SuppressProgressReporting = suppressProgressReporting(true)
 type FlakeAttempts uint
 type MustPassRepeatedly uint
 type Offset uint
-type Done chan<- interface{} // Deprecated Done Channel for asynchronous testing
+type Done chan<- any // Deprecated Done Channel for asynchronous testing
 type Labels []string
 type PollProgressInterval time.Duration
 type PollProgressAfter time.Duration
@@ -110,9 +110,9 @@ func UnionOfLabels(labels ...Labels) Labels {
 	return out
 }
 
-func PartitionDecorations(args ...interface{}) ([]interface{}, []interface{}) {
-	decorations := []interface{}{}
-	remainingArgs := []interface{}{}
+func PartitionDecorations(args ...any) ([]any, []any) {
+	decorations := []any{}
+	remainingArgs := []any{}
 	for _, arg := range args {
 		if isDecoration(arg) {
 			decorations = append(decorations, arg)
@@ -123,7 +123,7 @@ func PartitionDecorations(args ...interface{}) ([]interface{}, []interface{}) {
 	return decorations, remainingArgs
 }
 
-func isDecoration(arg interface{}) bool {
+func isDecoration(arg any) bool {
 	switch t := reflect.TypeOf(arg); {
 	case t == nil:
 		return false
@@ -168,7 +168,7 @@ func isDecoration(arg interface{}) bool {
 	}
 }
 
-func isSliceOfDecorations(slice interface{}) bool {
+func isSliceOfDecorations(slice any) bool {
 	vSlice := reflect.ValueOf(slice)
 	if vSlice.Len() == 0 {
 		return false
@@ -184,7 +184,7 @@ func isSliceOfDecorations(slice interface{}) bool {
 var contextType = reflect.TypeOf(new(context.Context)).Elem()
 var specContextType = reflect.TypeOf(new(SpecContext)).Elem()
 
-func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeType, text string, args ...interface{}) (Node, []error) {
+func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeType, text string, args ...any) (Node, []error) {
 	baseOffset := 2
 	node := Node{
 		ID:                   UniqueNodeID(),
@@ -207,7 +207,7 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 
 	args = unrollInterfaceSlice(args)
 
-	remainingArgs := []interface{}{}
+	remainingArgs := []any{}
 	// First get the CodeLocation up-to-date
 	for _, arg := range args {
 		switch v := arg.(type) {
@@ -223,7 +223,7 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 	labelsSeen := map[string]bool{}
 	trackedFunctionError := false
 	args = remainingArgs
-	remainingArgs = []interface{}{}
+	remainingArgs = []any{}
 	// now process the rest of the args
 	for _, arg := range args {
 		switch t := reflect.TypeOf(arg); {
@@ -451,7 +451,7 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
 
 var doneType = reflect.TypeOf(make(Done))
 
-func extractBodyFunction(deprecationTracker *types.DeprecationTracker, cl types.CodeLocation, arg interface{}) (func(SpecContext), bool) {
+func extractBodyFunction(deprecationTracker *types.DeprecationTracker, cl types.CodeLocation, arg any) (func(SpecContext), bool) {
 	t := reflect.TypeOf(arg)
 	if t.NumOut() > 0 || t.NumIn() > 1 {
 		return nil, false
@@ -477,7 +477,7 @@ func extractBodyFunction(deprecationTracker *types.DeprecationTracker, cl types.
 
 var byteType = reflect.TypeOf([]byte{})
 
-func extractSynchronizedBeforeSuiteProc1Body(arg interface{}) (func(SpecContext) []byte, bool) {
+func extractSynchronizedBeforeSuiteProc1Body(arg any) (func(SpecContext) []byte, bool) {
 	t := reflect.TypeOf(arg)
 	v := reflect.ValueOf(arg)
 
@@ -505,7 +505,7 @@ func extractSynchronizedBeforeSuiteProc1Body(arg interface{}) (func(SpecContext)
 	}, hasContext
 }
 
-func extractSynchronizedBeforeSuiteAllProcsBody(arg interface{}) (func(SpecContext, []byte), bool) {
+func extractSynchronizedBeforeSuiteAllProcsBody(arg any) (func(SpecContext, []byte), bool) {
 	t := reflect.TypeOf(arg)
 	v := reflect.ValueOf(arg)
 	hasContext, hasByte := false, false
@@ -536,11 +536,11 @@ func extractSynchronizedBeforeSuiteAllProcsBody(arg interface{}) (func(SpecConte
 
 var errInterface = reflect.TypeOf((*error)(nil)).Elem()
 
-func NewCleanupNode(deprecationTracker *types.DeprecationTracker, fail func(string, types.CodeLocation), args ...interface{}) (Node, []error) {
+func NewCleanupNode(deprecationTracker *types.DeprecationTracker, fail func(string, types.CodeLocation), args ...any) (Node, []error) {
 	decorations, remainingArgs := PartitionDecorations(args...)
 	baseOffset := 2
 	cl := types.NewCodeLocation(baseOffset)
-	finalArgs := []interface{}{}
+	finalArgs := []any{}
 	for _, arg := range decorations {
 		switch t := reflect.TypeOf(arg); {
 		case t == reflect.TypeOf(Offset(0)):
@@ -920,12 +920,12 @@ func (n Nodes) GetMaxMustPassRepeatedly() int {
 	return maxMustPassRepeatedly
 }
 
-func unrollInterfaceSlice(args interface{}) []interface{} {
+func unrollInterfaceSlice(args any) []any {
 	v := reflect.ValueOf(args)
 	if v.Kind() != reflect.Slice {
-		return []interface{}{args}
+		return []any{args}
 	}
-	out := []interface{}{}
+	out := []any{}
 	for i := 0; i < v.Len(); i++ {
 		el := reflect.ValueOf(v.Index(i).Interface())
 		if el.Kind() == reflect.Slice && el.Type() != reflect.TypeOf(Labels{}) {
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor.go b/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor.go
index 4a1c09461..5598f15cb 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor.go
@@ -69,7 +69,7 @@ type pipePair struct {
 	writer *os.File
 }
 
-func startPipeFactory(pipeChannel chan pipePair, shutdown chan interface{}) {
+func startPipeFactory(pipeChannel chan pipePair, shutdown chan any) {
 	for {
 		//make the next pipe...
 		pair := pipePair{}
@@ -101,8 +101,8 @@ type genericOutputInterceptor struct {
 	stderrClone *os.File
 	pipe        pipePair
 
-	shutdown           chan interface{}
-	emergencyBailout   chan interface{}
+	shutdown           chan any
+	emergencyBailout   chan any
 	pipeChannel        chan pipePair
 	interceptedContent chan string
 
@@ -139,7 +139,7 @@ func (interceptor *genericOutputInterceptor) ResumeIntercepting() {
 	interceptor.intercepting = true
 	if interceptor.stdoutClone == nil {
 		interceptor.stdoutClone, interceptor.stderrClone = interceptor.implementation.CreateStdoutStderrClones()
-		interceptor.shutdown = make(chan interface{})
+		interceptor.shutdown = make(chan any)
 		go startPipeFactory(interceptor.pipeChannel, interceptor.shutdown)
 	}
 
@@ -147,13 +147,13 @@ func (interceptor *genericOutputInterceptor) ResumeIntercepting() {
 	// we get the pipe from our pipe factory.  it runs in the background so we can request the next pipe while the spec being intercepted is running
 	interceptor.pipe = <-interceptor.pipeChannel
 
-	interceptor.emergencyBailout = make(chan interface{})
+	interceptor.emergencyBailout = make(chan any)
 
 	//Spin up a goroutine to copy data from the pipe into a buffer, this is how we capture any output the user is emitting
 	go func() {
 		buffer := &bytes.Buffer{}
 		destination := io.MultiWriter(buffer, interceptor.forwardTo)
-		copyFinished := make(chan interface{})
+		copyFinished := make(chan any)
 		reader := interceptor.pipe.reader
 		go func() {
 			io.Copy(destination, reader)
@@ -224,7 +224,7 @@ func NewOSGlobalReassigningOutputInterceptor() OutputInterceptor {
 	return &genericOutputInterceptor{
 		interceptedContent: make(chan string),
 		pipeChannel:        make(chan pipePair),
-		shutdown:           make(chan interface{}),
+		shutdown:           make(chan any),
 		implementation:     &osGlobalReassigningOutputInterceptorImpl{},
 	}
 }
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor_unix.go b/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor_unix.go
index 8a237f446..e0f1431d5 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor_unix.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/output_interceptor_unix.go
@@ -13,7 +13,7 @@ func NewOutputInterceptor() OutputInterceptor {
 	return &genericOutputInterceptor{
 		interceptedContent: make(chan string),
 		pipeChannel:        make(chan pipePair),
-		shutdown:           make(chan interface{}),
+		shutdown:           make(chan any),
 		implementation:     &dupSyscallOutputInterceptorImpl{},
 	}
 }
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/client_server.go b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/client_server.go
index b3cd64292..4234d802c 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/client_server.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/client_server.go
@@ -30,7 +30,7 @@ type Server interface {
 	Close()
 	Address() string
 	RegisterAlive(node int, alive func() bool)
-	GetSuiteDone() chan interface{}
+	GetSuiteDone() chan any
 	GetOutputDestination() io.Writer
 	SetOutputDestination(io.Writer)
 }
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_client.go b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_client.go
index 6547c7a66..4aa10ae4f 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_client.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_client.go
@@ -34,7 +34,7 @@ func (client *httpClient) Close() error {
 	return nil
 }
 
-func (client *httpClient) post(path string, data interface{}) error {
+func (client *httpClient) post(path string, data any) error {
 	var body io.Reader
 	if data != nil {
 		encoded, err := json.Marshal(data)
@@ -54,7 +54,7 @@ func (client *httpClient) post(path string, data interface{}) error {
 	return nil
 }
 
-func (client *httpClient) poll(path string, data interface{}) error {
+func (client *httpClient) poll(path string, data any) error {
 	for {
 		resp, err := http.Get(client.serverHost + path)
 		if err != nil {
@@ -153,10 +153,7 @@ func (client *httpClient) PostAbort() error {
 
 func (client *httpClient) ShouldAbort() bool {
 	err := client.poll("/abort", nil)
-	if err == ErrorGone {
-		return true
-	}
-	return false
+	return err == ErrorGone
 }
 
 func (client *httpClient) Write(p []byte) (int, error) {
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_server.go b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_server.go
index d2c71ab1b..8a1b7a5bb 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_server.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/http_server.go
@@ -75,7 +75,7 @@ func (server *httpServer) Address() string {
 	return "http://" + server.listener.Addr().String()
 }
 
-func (server *httpServer) GetSuiteDone() chan interface{} {
+func (server *httpServer) GetSuiteDone() chan any {
 	return server.handler.done
 }
 
@@ -96,7 +96,7 @@ func (server *httpServer) RegisterAlive(node int, alive func() bool) {
 //
 
 // The server will forward all received messages to Ginkgo reporters registered with `RegisterReporters`
-func (server *httpServer) decode(writer http.ResponseWriter, request *http.Request, object interface{}) bool {
+func (server *httpServer) decode(writer http.ResponseWriter, request *http.Request, object any) bool {
 	defer request.Body.Close()
 	if json.NewDecoder(request.Body).Decode(object) != nil {
 		writer.WriteHeader(http.StatusBadRequest)
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_client.go b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_client.go
index 59e8e6fd0..bb4675a02 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_client.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_client.go
@@ -35,7 +35,7 @@ func (client *rpcClient) Close() error {
 	return client.client.Close()
 }
 
-func (client *rpcClient) poll(method string, data interface{}) error {
+func (client *rpcClient) poll(method string, data any) error {
 	for {
 		err := client.client.Call(method, voidSender, data)
 		if err == nil {
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_server.go b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_server.go
index 2620fd562..1574f99ac 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_server.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/rpc_server.go
@@ -25,7 +25,7 @@ type RPCServer struct {
 	handler  *ServerHandler
 }
 
-//Create a new server, automatically selecting a port
+// Create a new server, automatically selecting a port
 func newRPCServer(parallelTotal int, reporter reporters.Reporter) (*RPCServer, error) {
 	listener, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
@@ -37,7 +37,7 @@ func newRPCServer(parallelTotal int, reporter reporters.Reporter) (*RPCServer, e
 	}, nil
 }
 
-//Start the server.  You don't need to `go s.Start()`, just `s.Start()`
+// Start the server.  You don't need to `go s.Start()`, just `s.Start()`
 func (server *RPCServer) Start() {
 	rpcServer := rpc.NewServer()
 	rpcServer.RegisterName("Server", server.handler) //register the handler's methods as the server
@@ -48,17 +48,17 @@ func (server *RPCServer) Start() {
 	go httpServer.Serve(server.listener)
 }
 
-//Stop the server
+// Stop the server
 func (server *RPCServer) Close() {
 	server.listener.Close()
 }
 
-//The address the server can be reached it.  Pass this into the `ForwardingReporter`.
+// The address the server can be reached it.  Pass this into the `ForwardingReporter`.
 func (server *RPCServer) Address() string {
 	return server.listener.Addr().String()
 }
 
-func (server *RPCServer) GetSuiteDone() chan interface{} {
+func (server *RPCServer) GetSuiteDone() chan any {
 	return server.handler.done
 }
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/server_handler.go b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/server_handler.go
index a6d98793e..ab9e11372 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/server_handler.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/parallel_support/server_handler.go
@@ -18,7 +18,7 @@ var voidSender Void
 // It handles all the business logic to avoid duplication between the two servers
 
 type ServerHandler struct {
-	done                   chan interface{}
+	done                   chan any
 	outputDestination      io.Writer
 	reporter               reporters.Reporter
 	alives                 []func() bool
@@ -46,7 +46,7 @@ func newServerHandler(parallelTotal int, reporter reporters.Reporter) *ServerHan
 
 		parallelTotal:     parallelTotal,
 		outputDestination: os.Stdout,
-		done:              make(chan interface{}),
+		done:              make(chan any),
 	}
 }
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/report_entry.go b/vendor/github.com/onsi/ginkgo/v2/internal/report_entry.go
index cc351a39b..9c18dc8e5 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/report_entry.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/report_entry.go
@@ -8,7 +8,7 @@ import (
 
 type ReportEntry = types.ReportEntry
 
-func NewReportEntry(name string, cl types.CodeLocation, args ...interface{}) (ReportEntry, error) {
+func NewReportEntry(name string, cl types.CodeLocation, args ...any) (ReportEntry, error) {
 	out := ReportEntry{
 		Visibility: types.ReportEntryVisibilityAlways,
 		Name:       name,
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/writer.go b/vendor/github.com/onsi/ginkgo/v2/internal/writer.go
index aab42d5fb..1c4e0534e 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/writer.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/writer.go
@@ -121,15 +121,15 @@ func (w *Writer) ClearTeeWriters() {
 	w.teeWriters = []io.Writer{}
 }
 
-func (w *Writer) Print(a ...interface{}) {
+func (w *Writer) Print(a ...any) {
 	fmt.Fprint(w, a...)
 }
 
-func (w *Writer) Printf(format string, a ...interface{}) {
+func (w *Writer) Printf(format string, a ...any) {
 	fmt.Fprintf(w, format, a...)
 }
 
-func (w *Writer) Println(a ...interface{}) {
+func (w *Writer) Println(a ...any) {
 	fmt.Fprintln(w, a...)
 }
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go b/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
index 480730486..74ad0768b 100644
--- a/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
@@ -685,11 +685,11 @@ func (r *DefaultReporter) _emit(s string, block bool, isDelimiter bool) {
 }
 
 /* Rendering text */
-func (r *DefaultReporter) f(format string, args ...interface{}) string {
+func (r *DefaultReporter) f(format string, args ...any) string {
 	return r.formatter.F(format, args...)
 }
 
-func (r *DefaultReporter) fi(indentation uint, format string, args ...interface{}) string {
+func (r *DefaultReporter) fi(indentation uint, format string, args ...any) string {
 	return r.formatter.Fi(indentation, format, args...)
 }
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go b/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
index aa1a35176..5bf2e62e9 100644
--- a/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
@@ -60,7 +60,7 @@ AddReportEntry() must be called within a Subject or Setup node - not in a Contai
 
 You can learn more about Report Entries here: https://onsi.github.io/ginkgo/#attaching-data-to-reports
 */
-func AddReportEntry(name string, args ...interface{}) {
+func AddReportEntry(name string, args ...any) {
 	cl := types.NewCodeLocation(1)
 	reportEntry, err := internal.NewReportEntry(name, cl, args...)
 	if err != nil {
@@ -89,7 +89,7 @@ You can learn more about ReportBeforeEach here: https://onsi.github.io/ginkgo/#g
 You can learn about interruptible nodes here: https://onsi.github.io/ginkgo/#spec-timeouts-and-interruptible-nodes
 */
 func ReportBeforeEach(body any, args ...any) bool {
-	combinedArgs := []interface{}{body}
+	combinedArgs := []any{body}
 	combinedArgs = append(combinedArgs, args...)
 
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeReportBeforeEach, "", combinedArgs...))
@@ -113,7 +113,7 @@ You can learn more about ReportAfterEach here: https://onsi.github.io/ginkgo/#ge
 You can learn about interruptible nodes here: https://onsi.github.io/ginkgo/#spec-timeouts-and-interruptible-nodes
 */
 func ReportAfterEach(body any, args ...any) bool {
-	combinedArgs := []interface{}{body}
+	combinedArgs := []any{body}
 	combinedArgs = append(combinedArgs, args...)
 
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeReportAfterEach, "", combinedArgs...))
@@ -143,7 +143,7 @@ You can learn more about Ginkgo's reporting infrastructure, including generating
 You can learn about interruptible nodes here: https://onsi.github.io/ginkgo/#spec-timeouts-and-interruptible-nodes
 */
 func ReportBeforeSuite(body any, args ...any) bool {
-	combinedArgs := []interface{}{body}
+	combinedArgs := []any{body}
 	combinedArgs = append(combinedArgs, args...)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeReportBeforeSuite, "", combinedArgs...))
 }
@@ -174,8 +174,8 @@ You can learn more about Ginkgo's reporting infrastructure, including generating
 
 You can learn about interruptible nodes here: https://onsi.github.io/ginkgo/#spec-timeouts-and-interruptible-nodes
 */
-func ReportAfterSuite(text string, body any, args ...interface{}) bool {
-	combinedArgs := []interface{}{body}
+func ReportAfterSuite(text string, body any, args ...any) bool {
+	combinedArgs := []any{body}
 	combinedArgs = append(combinedArgs, args...)
 	return pushNode(internal.NewNode(deprecationTracker, types.NodeTypeReportAfterSuite, text, combinedArgs...))
 }
diff --git a/vendor/github.com/onsi/ginkgo/v2/table_dsl.go b/vendor/github.com/onsi/ginkgo/v2/table_dsl.go
index 9074a57ac..b9e0ca9ef 100644
--- a/vendor/github.com/onsi/ginkgo/v2/table_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/table_dsl.go
@@ -23,7 +23,7 @@ You can learn more about generating EntryDescriptions here: https://onsi.github.
 */
 type EntryDescription string
 
-func (ed EntryDescription) render(args ...interface{}) string {
+func (ed EntryDescription) render(args ...any) string {
 	return fmt.Sprintf(string(ed), args...)
 }
 
@@ -44,7 +44,7 @@ For example:
 You can learn more about DescribeTable here: https://onsi.github.io/ginkgo/#table-specs
 And can explore some Table patterns here: https://onsi.github.io/ginkgo/#table-specs-patterns
 */
-func DescribeTable(description string, args ...interface{}) bool {
+func DescribeTable(description string, args ...any) bool {
 	GinkgoHelper()
 	generateTable(description, false, args...)
 	return true
@@ -53,7 +53,7 @@ func DescribeTable(description string, args ...interface{}) bool {
 /*
 You can focus a table with `FDescribeTable`.  This is equivalent to `FDescribe`.
 */
-func FDescribeTable(description string, args ...interface{}) bool {
+func FDescribeTable(description string, args ...any) bool {
 	GinkgoHelper()
 	args = append(args, internal.Focus)
 	generateTable(description, false, args...)
@@ -63,7 +63,7 @@ func FDescribeTable(description string, args ...interface{}) bool {
 /*
 You can mark a table as pending with `PDescribeTable`.  This is equivalent to `PDescribe`.
 */
-func PDescribeTable(description string, args ...interface{}) bool {
+func PDescribeTable(description string, args ...any) bool {
 	GinkgoHelper()
 	args = append(args, internal.Pending)
 	generateTable(description, false, args...)
@@ -109,7 +109,7 @@ Note that you **must** place define an It inside the body function.
 You can learn more about DescribeTableSubtree here: https://onsi.github.io/ginkgo/#table-specs
 And can explore some Table patterns here: https://onsi.github.io/ginkgo/#table-specs-patterns
 */
-func DescribeTableSubtree(description string, args ...interface{}) bool {
+func DescribeTableSubtree(description string, args ...any) bool {
 	GinkgoHelper()
 	generateTable(description, true, args...)
 	return true
@@ -118,7 +118,7 @@ func DescribeTableSubtree(description string, args ...interface{}) bool {
 /*
 You can focus a table with `FDescribeTableSubtree`.  This is equivalent to `FDescribe`.
 */
-func FDescribeTableSubtree(description string, args ...interface{}) bool {
+func FDescribeTableSubtree(description string, args ...any) bool {
 	GinkgoHelper()
 	args = append(args, internal.Focus)
 	generateTable(description, true, args...)
@@ -128,7 +128,7 @@ func FDescribeTableSubtree(description string, args ...interface{}) bool {
 /*
 You can mark a table as pending with `PDescribeTableSubtree`.  This is equivalent to `PDescribe`.
 */
-func PDescribeTableSubtree(description string, args ...interface{}) bool {
+func PDescribeTableSubtree(description string, args ...any) bool {
 	GinkgoHelper()
 	args = append(args, internal.Pending)
 	generateTable(description, true, args...)
@@ -144,9 +144,9 @@ var XDescribeTableSubtree = PDescribeTableSubtree
 TableEntry represents an entry in a table test.  You generally use the `Entry` constructor.
 */
 type TableEntry struct {
-	description  interface{}
-	decorations  []interface{}
-	parameters   []interface{}
+	description  any
+	decorations  []any
+	parameters   []any
 	codeLocation types.CodeLocation
 }
 
@@ -162,7 +162,7 @@ If you want to generate interruptible specs simply write a Table function that a
 
 You can learn more about Entry here: https://onsi.github.io/ginkgo/#table-specs
 */
-func Entry(description interface{}, args ...interface{}) TableEntry {
+func Entry(description any, args ...any) TableEntry {
 	GinkgoHelper()
 	decorations, parameters := internal.PartitionDecorations(args...)
 	return TableEntry{description: description, decorations: decorations, parameters: parameters, codeLocation: types.NewCodeLocation(0)}
@@ -171,7 +171,7 @@ func Entry(description interface{}, args ...interface{}) TableEntry {
 /*
 You can focus a particular entry with FEntry.  This is equivalent to FIt.
 */
-func FEntry(description interface{}, args ...interface{}) TableEntry {
+func FEntry(description any, args ...any) TableEntry {
 	GinkgoHelper()
 	decorations, parameters := internal.PartitionDecorations(args...)
 	decorations = append(decorations, internal.Focus)
@@ -181,7 +181,7 @@ func FEntry(description interface{}, args ...interface{}) TableEntry {
 /*
 You can mark a particular entry as pending with PEntry.  This is equivalent to PIt.
 */
-func PEntry(description interface{}, args ...interface{}) TableEntry {
+func PEntry(description any, args ...any) TableEntry {
 	GinkgoHelper()
 	decorations, parameters := internal.PartitionDecorations(args...)
 	decorations = append(decorations, internal.Pending)
@@ -196,17 +196,17 @@ var XEntry = PEntry
 var contextType = reflect.TypeOf(new(context.Context)).Elem()
 var specContextType = reflect.TypeOf(new(SpecContext)).Elem()
 
-func generateTable(description string, isSubtree bool, args ...interface{}) {
+func generateTable(description string, isSubtree bool, args ...any) {
 	GinkgoHelper()
 	cl := types.NewCodeLocation(0)
-	containerNodeArgs := []interface{}{cl}
+	containerNodeArgs := []any{cl}
 
 	entries := []TableEntry{}
-	var internalBody interface{}
+	var internalBody any
 	var internalBodyType reflect.Type
 
-	var tableLevelEntryDescription interface{}
-	tableLevelEntryDescription = func(args ...interface{}) string {
+	var tableLevelEntryDescription any
+	tableLevelEntryDescription = func(args ...any) string {
 		out := []string{}
 		for _, arg := range args {
 			out = append(out, fmt.Sprint(arg))
@@ -265,7 +265,7 @@ func generateTable(description string, isSubtree bool, args ...interface{}) {
 				err = types.GinkgoErrors.InvalidEntryDescription(entry.codeLocation)
 			}
 
-			internalNodeArgs := []interface{}{entry.codeLocation}
+			internalNodeArgs := []any{entry.codeLocation}
 			internalNodeArgs = append(internalNodeArgs, entry.decorations...)
 
 			hasContext := false
@@ -290,7 +290,7 @@ func generateTable(description string, isSubtree bool, args ...interface{}) {
 					if err != nil {
 						panic(err)
 					}
-					invokeFunction(internalBody, append([]interface{}{c}, entry.parameters...))
+					invokeFunction(internalBody, append([]any{c}, entry.parameters...))
 				})
 				if isSubtree {
 					exitIfErr(types.GinkgoErrors.ContextsCannotBeUsedInSubtreeTables(cl))
@@ -316,7 +316,7 @@ func generateTable(description string, isSubtree bool, args ...interface{}) {
 	pushNode(internal.NewNode(deprecationTracker, types.NodeTypeContainer, description, containerNodeArgs...))
 }
 
-func invokeFunction(function interface{}, parameters []interface{}) []reflect.Value {
+func invokeFunction(function any, parameters []any) []reflect.Value {
 	inValues := make([]reflect.Value, len(parameters))
 
 	funcType := reflect.TypeOf(function)
@@ -339,7 +339,7 @@ func invokeFunction(function interface{}, parameters []interface{}) []reflect.Va
 	return reflect.ValueOf(function).Call(inValues)
 }
 
-func validateParameters(function interface{}, parameters []interface{}, kind string, cl types.CodeLocation, hasContext bool) error {
+func validateParameters(function any, parameters []any, kind string, cl types.CodeLocation, hasContext bool) error {
 	funcType := reflect.TypeOf(function)
 	limit := funcType.NumIn()
 	offset := 0
@@ -377,7 +377,7 @@ func validateParameters(function interface{}, parameters []interface{}, kind str
 	return nil
 }
 
-func computeValue(parameter interface{}, t reflect.Type) reflect.Value {
+func computeValue(parameter any, t reflect.Type) reflect.Value {
 	if parameter == nil {
 		return reflect.Zero(t)
 	} else {
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/config.go b/vendor/github.com/onsi/ginkgo/v2/types/config.go
index 8c0dfab8c..9b2892432 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/config.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/config.go
@@ -365,7 +365,7 @@ var ReporterConfigFlags = GinkgoFlags{
 func BuildTestSuiteFlagSet(suiteConfig *SuiteConfig, reporterConfig *ReporterConfig) (GinkgoFlagSet, error) {
 	flags := SuiteConfigFlags.CopyAppend(ParallelConfigFlags...).CopyAppend(ReporterConfigFlags...)
 	flags = flags.WithPrefix("ginkgo")
-	bindings := map[string]interface{}{
+	bindings := map[string]any{
 		"S": suiteConfig,
 		"R": reporterConfig,
 		"D": &deprecatedConfig{},
@@ -646,7 +646,7 @@ func GenerateGoTestCompileArgs(goFlagsConfig GoFlagsConfig, packageToBuild strin
 	args := []string{"test", "-c", packageToBuild}
 	goArgs, err := GenerateFlagArgs(
 		GoBuildFlags,
-		map[string]interface{}{
+		map[string]any{
 			"Go": &goFlagsConfig,
 		},
 	)
@@ -665,7 +665,7 @@ func GenerateGinkgoTestRunArgs(suiteConfig SuiteConfig, reporterConfig ReporterC
 	flags = flags.CopyAppend(ParallelConfigFlags.WithPrefix("ginkgo")...)
 	flags = flags.CopyAppend(ReporterConfigFlags.WithPrefix("ginkgo")...)
 	flags = flags.CopyAppend(GoRunFlags.WithPrefix("test")...)
-	bindings := map[string]interface{}{
+	bindings := map[string]any{
 		"S":  &suiteConfig,
 		"R":  &reporterConfig,
 		"Go": &goFlagsConfig,
@@ -677,7 +677,7 @@ func GenerateGinkgoTestRunArgs(suiteConfig SuiteConfig, reporterConfig ReporterC
 // GenerateGoTestRunArgs is used by the Ginkgo CLI to generate command line arguments to pass to the compiled non-Ginkgo test binary
 func GenerateGoTestRunArgs(goFlagsConfig GoFlagsConfig) ([]string, error) {
 	flags := GoRunFlags.WithPrefix("test")
-	bindings := map[string]interface{}{
+	bindings := map[string]any{
 		"Go": &goFlagsConfig,
 	}
 
@@ -699,7 +699,7 @@ func BuildRunCommandFlagSet(suiteConfig *SuiteConfig, reporterConfig *ReporterCo
 	flags = flags.CopyAppend(GoBuildFlags...)
 	flags = flags.CopyAppend(GoRunFlags...)
 
-	bindings := map[string]interface{}{
+	bindings := map[string]any{
 		"S":  suiteConfig,
 		"R":  reporterConfig,
 		"C":  cliConfig,
@@ -720,7 +720,7 @@ func BuildWatchCommandFlagSet(suiteConfig *SuiteConfig, reporterConfig *Reporter
 	flags = flags.CopyAppend(GoBuildFlags...)
 	flags = flags.CopyAppend(GoRunFlags...)
 
-	bindings := map[string]interface{}{
+	bindings := map[string]any{
 		"S":  suiteConfig,
 		"R":  reporterConfig,
 		"C":  cliConfig,
@@ -736,7 +736,7 @@ func BuildBuildCommandFlagSet(cliConfig *CLIConfig, goFlagsConfig *GoFlagsConfig
 	flags := GinkgoCLISharedFlags
 	flags = flags.CopyAppend(GoBuildFlags...)
 
-	bindings := map[string]interface{}{
+	bindings := map[string]any{
 		"C":  cliConfig,
 		"Go": goFlagsConfig,
 		"D":  &deprecatedConfig{},
@@ -760,7 +760,7 @@ func BuildBuildCommandFlagSet(cliConfig *CLIConfig, goFlagsConfig *GoFlagsConfig
 func BuildLabelsCommandFlagSet(cliConfig *CLIConfig) (GinkgoFlagSet, error) {
 	flags := GinkgoCLISharedFlags.SubsetWithNames("r", "skip-package")
 
-	bindings := map[string]interface{}{
+	bindings := map[string]any{
 		"C": cliConfig,
 	}
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/deprecated_types.go b/vendor/github.com/onsi/ginkgo/v2/types/deprecated_types.go
index 17922304b..518989a84 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/deprecated_types.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/deprecated_types.go
@@ -113,7 +113,7 @@ type DeprecatedSpecFailure struct {
 
 type DeprecatedSpecMeasurement struct {
 	Name  string
-	Info  interface{}
+	Info  any
 	Order int
 
 	Results []float64
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/errors.go b/vendor/github.com/onsi/ginkgo/v2/types/errors.go
index 6bb72d00c..6e5eec988 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/errors.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/errors.go
@@ -88,7 +88,7 @@ body of a {{bold}}Describe{{/}}, {{bold}}Context{{/}}, or {{bold}}When{{/}}.`, n
 	}
 }
 
-func (g ginkgoErrors) CaughtPanicDuringABuildPhase(caughtPanic interface{}, cl CodeLocation) error {
+func (g ginkgoErrors) CaughtPanicDuringABuildPhase(caughtPanic any, cl CodeLocation) error {
 	return GinkgoError{
 		Heading: "Assertion or Panic detected during tree construction",
 		Message: formatter.F(
@@ -189,7 +189,7 @@ func (g ginkgoErrors) InvalidDeclarationOfFlakeAttemptsAndMustPassRepeatedly(cl
 	}
 }
 
-func (g ginkgoErrors) UnknownDecorator(cl CodeLocation, nodeType NodeType, decorator interface{}) error {
+func (g ginkgoErrors) UnknownDecorator(cl CodeLocation, nodeType NodeType, decorator any) error {
 	return GinkgoError{
 		Heading:      "Unknown Decorator",
 		Message:      formatter.F(`[%s] node was passed an unknown decorator: '%#v'`, nodeType, decorator),
@@ -345,7 +345,7 @@ func (g ginkgoErrors) PushingCleanupInCleanupNode(cl CodeLocation) error {
 }
 
 /* ReportEntry errors */
-func (g ginkgoErrors) TooManyReportEntryValues(cl CodeLocation, arg interface{}) error {
+func (g ginkgoErrors) TooManyReportEntryValues(cl CodeLocation, arg any) error {
 	return GinkgoError{
 		Heading:      "Too Many ReportEntry Values",
 		Message:      formatter.F(`{{bold}}AddGinkgoReport{{/}} can only be given one value. Got unexpected value: %#v`, arg),
@@ -539,7 +539,7 @@ func (g ginkgoErrors) SynchronizedBeforeSuiteDisappearedOnProc1() error {
 
 /* Configuration errors */
 
-func (g ginkgoErrors) UnknownTypePassedToRunSpecs(value interface{}) error {
+func (g ginkgoErrors) UnknownTypePassedToRunSpecs(value any) error {
 	return GinkgoError{
 		Heading: "Unknown Type passed to RunSpecs",
 		Message: fmt.Sprintf("RunSpecs() accepts labels, and configuration of type types.SuiteConfig and/or types.ReporterConfig.\n You passed in: %v", value),
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/flags.go b/vendor/github.com/onsi/ginkgo/v2/types/flags.go
index de69f3022..8409653f9 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/flags.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/flags.go
@@ -92,7 +92,7 @@ func (gfs GinkgoFlagSections) Lookup(key string) (GinkgoFlagSection, bool) {
 
 type GinkgoFlagSet struct {
 	flags    GinkgoFlags
-	bindings interface{}
+	bindings any
 
 	sections            GinkgoFlagSections
 	extraGoFlagsSection GinkgoFlagSection
@@ -101,7 +101,7 @@ type GinkgoFlagSet struct {
 }
 
 // Call NewGinkgoFlagSet to create GinkgoFlagSet that creates and binds to it's own *flag.FlagSet
-func NewGinkgoFlagSet(flags GinkgoFlags, bindings interface{}, sections GinkgoFlagSections) (GinkgoFlagSet, error) {
+func NewGinkgoFlagSet(flags GinkgoFlags, bindings any, sections GinkgoFlagSections) (GinkgoFlagSet, error) {
 	return bindFlagSet(GinkgoFlagSet{
 		flags:    flags,
 		bindings: bindings,
@@ -110,7 +110,7 @@ func NewGinkgoFlagSet(flags GinkgoFlags, bindings interface{}, sections GinkgoFl
 }
 
 // Call NewGinkgoFlagSet to create GinkgoFlagSet that extends an existing *flag.FlagSet
-func NewAttachedGinkgoFlagSet(flagSet *flag.FlagSet, flags GinkgoFlags, bindings interface{}, sections GinkgoFlagSections, extraGoFlagsSection GinkgoFlagSection) (GinkgoFlagSet, error) {
+func NewAttachedGinkgoFlagSet(flagSet *flag.FlagSet, flags GinkgoFlags, bindings any, sections GinkgoFlagSections, extraGoFlagsSection GinkgoFlagSection) (GinkgoFlagSet, error) {
 	return bindFlagSet(GinkgoFlagSet{
 		flags:               flags,
 		bindings:            bindings,
@@ -335,7 +335,7 @@ func (f GinkgoFlagSet) substituteUsage() {
 	fmt.Fprintln(f.flagSet.Output(), f.Usage())
 }
 
-func valueAtKeyPath(root interface{}, keyPath string) (reflect.Value, bool) {
+func valueAtKeyPath(root any, keyPath string) (reflect.Value, bool) {
 	if len(keyPath) == 0 {
 		return reflect.Value{}, false
 	}
@@ -433,7 +433,7 @@ func (ssv stringSliceVar) Set(s string) error {
 }
 
 // given a set of GinkgoFlags and bindings, generate flag arguments suitable to be passed to an application with that set of flags configured.
-func GenerateFlagArgs(flags GinkgoFlags, bindings interface{}) ([]string, error) {
+func GenerateFlagArgs(flags GinkgoFlags, bindings any) ([]string, error) {
 	result := []string{}
 	for _, flag := range flags {
 		name := flag.ExportAs
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/label_filter.go b/vendor/github.com/onsi/ginkgo/v2/types/label_filter.go
index 7fdc8aa23..40a909b6d 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/label_filter.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/label_filter.go
@@ -343,7 +343,7 @@ func tokenize(input string) func() (*treeNode, error) {
 	consumeUntil := func(cutset string) (string, int) {
 		j := i
 		for ; j < len(runes); j++ {
-			if strings.IndexRune(cutset, runes[j]) >= 0 {
+			if strings.ContainsRune(cutset, runes[j]) {
 				break
 			}
 		}
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/report_entry.go b/vendor/github.com/onsi/ginkgo/v2/types/report_entry.go
index 7b1524b52..63f7a9f6d 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/report_entry.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/report_entry.go
@@ -9,18 +9,18 @@ import (
 // ReportEntryValue wraps a report entry's value ensuring it can be encoded and decoded safely into reports
 // and across the network connection when running in parallel
 type ReportEntryValue struct {
-	raw            interface{} //unexported to prevent gob from freaking out about unregistered structs
+	raw            any //unexported to prevent gob from freaking out about unregistered structs
 	AsJSON         string
 	Representation string
 }
 
-func WrapEntryValue(value interface{}) ReportEntryValue {
+func WrapEntryValue(value any) ReportEntryValue {
 	return ReportEntryValue{
 		raw: value,
 	}
 }
 
-func (rev ReportEntryValue) GetRawValue() interface{} {
+func (rev ReportEntryValue) GetRawValue() any {
 	return rev.raw
 }
 
@@ -118,7 +118,7 @@ func (entry ReportEntry) StringRepresentation() string {
 // If used from a rehydrated JSON file _or_ in a ReportAfterSuite when running in parallel this will be
 // a JSON-decoded {}interface.  If you want to reconstitute your original object you can decode the entry.Value.AsJSON
 // field yourself.
-func (entry ReportEntry) GetRawValue() interface{} {
+func (entry ReportEntry) GetRawValue() any {
 	return entry.Value.GetRawValue()
 }
 
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/version.go b/vendor/github.com/onsi/ginkgo/v2/types/version.go
index 879e1d86c..23c030cdb 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/version.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/version.go
@@ -1,3 +1,3 @@
 package types
 
-const VERSION = "2.22.2"
+const VERSION = "2.23.0"
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/atomic_update.go b/vendor/github.com/prometheus/client_golang/prometheus/atomic_update.go
deleted file mode 100644
index b65896a31..000000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/atomic_update.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2014 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package prometheus
-
-import (
-	"math"
-	"sync/atomic"
-	"time"
-)
-
-// atomicUpdateFloat atomically updates the float64 value pointed to by bits
-// using the provided updateFunc, with an exponential backoff on contention.
-func atomicUpdateFloat(bits *uint64, updateFunc func(float64) float64) {
-	const (
-		// both numbers are derived from empirical observations
-		// documented in this PR: https://github.com/prometheus/client_golang/pull/1661
-		maxBackoff     = 320 * time.Millisecond
-		initialBackoff = 10 * time.Millisecond
-	)
-	backoff := initialBackoff
-
-	for {
-		loadedBits := atomic.LoadUint64(bits)
-		oldFloat := math.Float64frombits(loadedBits)
-		newFloat := updateFunc(oldFloat)
-		newBits := math.Float64bits(newFloat)
-
-		if atomic.CompareAndSwapUint64(bits, loadedBits, newBits) {
-			break
-		} else {
-			// Exponential backoff with sleep and cap to avoid infinite wait
-			time.Sleep(backoff)
-			backoff *= 2
-			if backoff > maxBackoff {
-				backoff = maxBackoff
-			}
-		}
-	}
-}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/counter.go b/vendor/github.com/prometheus/client_golang/prometheus/counter.go
index 2996aef6a..4ce84e7a8 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/counter.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/counter.go
@@ -134,9 +134,13 @@ func (c *counter) Add(v float64) {
 		return
 	}
 
-	atomicUpdateFloat(&c.valBits, func(oldVal float64) float64 {
-		return oldVal + v
-	})
+	for {
+		oldBits := atomic.LoadUint64(&c.valBits)
+		newBits := math.Float64bits(math.Float64frombits(oldBits) + v)
+		if atomic.CompareAndSwapUint64(&c.valBits, oldBits, newBits) {
+			return
+		}
+	}
 }
 
 func (c *counter) AddWithExemplar(v float64, e Labels) {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/gauge.go b/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
index aa1846365..dd2eac940 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
@@ -120,9 +120,13 @@ func (g *gauge) Dec() {
 }
 
 func (g *gauge) Add(val float64) {
-	atomicUpdateFloat(&g.valBits, func(oldVal float64) float64 {
-		return oldVal + val
-	})
+	for {
+		oldBits := atomic.LoadUint64(&g.valBits)
+		newBits := math.Float64bits(math.Float64frombits(oldBits) + val)
+		if atomic.CompareAndSwapUint64(&g.valBits, oldBits, newBits) {
+			return
+		}
+	}
 }
 
 func (g *gauge) Sub(val float64) {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
index 1a279035b..c453b754a 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
@@ -1647,9 +1647,13 @@ func waitForCooldown(count uint64, counts *histogramCounts) {
 // atomicAddFloat adds the provided float atomically to another float
 // represented by the bit pattern the bits pointer is pointing to.
 func atomicAddFloat(bits *uint64, v float64) {
-	atomicUpdateFloat(bits, func(oldVal float64) float64 {
-		return oldVal + v
-	})
+	for {
+		loadedBits := atomic.LoadUint64(bits)
+		newBits := math.Float64bits(math.Float64frombits(loadedBits) + v)
+		if atomic.CompareAndSwapUint64(bits, loadedBits, newBits) {
+			break
+		}
+	}
 }
 
 // atomicDecUint32 atomically decrements the uint32 p points to.  See
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go
index 50eb860a6..0a61b9846 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go
@@ -11,6 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build darwin && !ios
+
 package prometheus
 
 import (
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_cgo_darwin.c b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.c
similarity index 98%
rename from vendor/github.com/prometheus/client_golang/prometheus/process_collector_cgo_darwin.c
rename to vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.c
index 1554f674d..d00a24315 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_cgo_darwin.c
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.c
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build darwin && cgo
+//go:build darwin && !ios && cgo
 
 #include <mach/mach_init.h>
 #include <mach/task.h>
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_cgo_darwin.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.go
similarity index 97%
rename from vendor/github.com/prometheus/client_golang/prometheus/process_collector_cgo_darwin.go
rename to vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.go
index b375c3a77..9ac53f999 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_cgo_darwin.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_cgo_darwin.go
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build darwin && cgo
+//go:build darwin && !ios && cgo
 
 package prometheus
 
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_nocgo_darwin.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_nocgo_darwin.go
similarity index 97%
rename from vendor/github.com/prometheus/client_golang/prometheus/process_collector_nocgo_darwin.go
rename to vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_nocgo_darwin.go
index 516504731..8ddb0995d 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_nocgo_darwin.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_mem_nocgo_darwin.go
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build darwin && !cgo
+//go:build darwin && !ios && !cgo
 
 package prometheus
 
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_wasip1_js.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_not_supported.go
similarity index 95%
rename from vendor/github.com/prometheus/client_golang/prometheus/process_collector_wasip1_js.go
rename to vendor/github.com/prometheus/client_golang/prometheus/process_collector_not_supported.go
index c68f7f851..7732b7f37 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_wasip1_js.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_not_supported.go
@@ -11,8 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//go:build wasip1 || js
-// +build wasip1 js
+//go:build wasip1 || js || ios
+// +build wasip1 js ios
 
 package prometheus
 
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_other.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_procfsenabled.go
similarity index 100%
rename from vendor/github.com/prometheus/client_golang/prometheus/process_collector_other.go
rename to vendor/github.com/prometheus/client_golang/prometheus/process_collector_procfsenabled.go
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/summary.go b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
index 76a9e12f4..ac5203c6f 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/summary.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
@@ -471,9 +471,13 @@ func (s *noObjectivesSummary) Observe(v float64) {
 	n := atomic.AddUint64(&s.countAndHotIdx, 1)
 	hotCounts := s.counts[n>>63]
 
-	atomicUpdateFloat(&hotCounts.sumBits, func(oldVal float64) float64 {
-		return oldVal + v
-	})
+	for {
+		oldBits := atomic.LoadUint64(&hotCounts.sumBits)
+		newBits := math.Float64bits(math.Float64frombits(oldBits) + v)
+		if atomic.CompareAndSwapUint64(&hotCounts.sumBits, oldBits, newBits) {
+			break
+		}
+	}
 	// Increment count last as we take it as a signal that the observation
 	// is complete.
 	atomic.AddUint64(&hotCounts.count, 1)
@@ -515,13 +519,14 @@ func (s *noObjectivesSummary) Write(out *dto.Metric) error {
 	// Finally add all the cold counts to the new hot counts and reset the cold counts.
 	atomic.AddUint64(&hotCounts.count, count)
 	atomic.StoreUint64(&coldCounts.count, 0)
-
-	// Use atomicUpdateFloat to update hotCounts.sumBits atomically.
-	atomicUpdateFloat(&hotCounts.sumBits, func(oldVal float64) float64 {
-		return oldVal + sum.GetSampleSum()
-	})
-	atomic.StoreUint64(&coldCounts.sumBits, 0)
-
+	for {
+		oldBits := atomic.LoadUint64(&hotCounts.sumBits)
+		newBits := math.Float64bits(math.Float64frombits(oldBits) + sum.GetSampleSum())
+		if atomic.CompareAndSwapUint64(&hotCounts.sumBits, oldBits, newBits) {
+			atomic.StoreUint64(&coldCounts.sumBits, 0)
+			break
+		}
+	}
 	return nil
 }
 
diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go
index c7601c909..6c18ea230 100644
--- a/vendor/golang.org/x/net/http2/http2.go
+++ b/vendor/golang.org/x/net/http2/http2.go
@@ -34,11 +34,19 @@ import (
 )
 
 var (
-	VerboseLogs                    bool
-	logFrameWrites                 bool
-	logFrameReads                  bool
-	inTests                        bool
-	disableExtendedConnectProtocol bool
+	VerboseLogs    bool
+	logFrameWrites bool
+	logFrameReads  bool
+	inTests        bool
+
+	// Enabling extended CONNECT by causes browsers to attempt to use
+	// WebSockets-over-HTTP/2. This results in problems when the server's websocket
+	// package doesn't support extended CONNECT.
+	//
+	// Disable extended CONNECT by default for now.
+	//
+	// Issue #71128.
+	disableExtendedConnectProtocol = true
 )
 
 func init() {
@@ -51,8 +59,8 @@ func init() {
 		logFrameWrites = true
 		logFrameReads = true
 	}
-	if strings.Contains(e, "http2xconnect=0") {
-		disableExtendedConnectProtocol = true
+	if strings.Contains(e, "http2xconnect=1") {
+		disableExtendedConnectProtocol = false
 	}
 }
 
@@ -407,23 +415,6 @@ func (s *sorter) SortStrings(ss []string) {
 	s.v = save
 }
 
-// validPseudoPath reports whether v is a valid :path pseudo-header
-// value. It must be either:
-//
-//   - a non-empty string starting with '/'
-//   - the string '*', for OPTIONS requests.
-//
-// For now this is only used a quick check for deciding when to clean
-// up Opaque URLs before sending requests from the Transport.
-// See golang.org/issue/16847
-//
-// We used to enforce that the path also didn't start with "//", but
-// Google's GFE accepts such paths and Chrome sends them, so ignore
-// that part of the spec. See golang.org/issue/19103.
-func validPseudoPath(v string) bool {
-	return (len(v) > 0 && v[0] == '/') || v == "*"
-}
-
 // incomparable is a zero-width, non-comparable type. Adding it to a struct
 // makes that struct also non-comparable, and generally doesn't add
 // any size (as long as it's first).
diff --git a/vendor/golang.org/x/net/http2/server.go b/vendor/golang.org/x/net/http2/server.go
index b55547aec..7434b8784 100644
--- a/vendor/golang.org/x/net/http2/server.go
+++ b/vendor/golang.org/x/net/http2/server.go
@@ -50,6 +50,7 @@ import (
 
 	"golang.org/x/net/http/httpguts"
 	"golang.org/x/net/http2/hpack"
+	"golang.org/x/net/internal/httpcommon"
 )
 
 const (
@@ -812,8 +813,7 @@ const maxCachedCanonicalHeadersKeysSize = 2048
 
 func (sc *serverConn) canonicalHeader(v string) string {
 	sc.serveG.check()
-	buildCommonHeaderMapsOnce()
-	cv, ok := commonCanonHeader[v]
+	cv, ok := httpcommon.CachedCanonicalHeader(v)
 	if ok {
 		return cv
 	}
diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go
index b2e2ed337..f2c166b61 100644
--- a/vendor/golang.org/x/net/http2/transport.go
+++ b/vendor/golang.org/x/net/http2/transport.go
@@ -25,7 +25,6 @@ import (
 	"net/http"
 	"net/http/httptrace"
 	"net/textproto"
-	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -35,6 +34,7 @@ import (
 	"golang.org/x/net/http/httpguts"
 	"golang.org/x/net/http2/hpack"
 	"golang.org/x/net/idna"
+	"golang.org/x/net/internal/httpcommon"
 )
 
 const (
@@ -1275,23 +1275,6 @@ func (cc *ClientConn) closeForLostPing() {
 // exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests.
 var errRequestCanceled = errors.New("net/http: request canceled")
 
-func commaSeparatedTrailers(req *http.Request) (string, error) {
-	keys := make([]string, 0, len(req.Trailer))
-	for k := range req.Trailer {
-		k = canonicalHeader(k)
-		switch k {
-		case "Transfer-Encoding", "Trailer", "Content-Length":
-			return "", fmt.Errorf("invalid Trailer key %q", k)
-		}
-		keys = append(keys, k)
-	}
-	if len(keys) > 0 {
-		sort.Strings(keys)
-		return strings.Join(keys, ","), nil
-	}
-	return "", nil
-}
-
 func (cc *ClientConn) responseHeaderTimeout() time.Duration {
 	if cc.t.t1 != nil {
 		return cc.t.t1.ResponseHeaderTimeout
@@ -1303,35 +1286,6 @@ func (cc *ClientConn) responseHeaderTimeout() time.Duration {
 	return 0
 }
 
-// checkConnHeaders checks whether req has any invalid connection-level headers.
-// per RFC 7540 section 8.1.2.2: Connection-Specific Header Fields.
-// Certain headers are special-cased as okay but not transmitted later.
-func checkConnHeaders(req *http.Request) error {
-	if v := req.Header.Get("Upgrade"); v != "" {
-		return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
-	}
-	if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && vv[0] != "chunked") {
-		return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
-	}
-	if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !asciiEqualFold(vv[0], "close") && !asciiEqualFold(vv[0], "keep-alive")) {
-		return fmt.Errorf("http2: invalid Connection request header: %q", vv)
-	}
-	return nil
-}
-
-// actualContentLength returns a sanitized version of
-// req.ContentLength, where 0 actually means zero (not unknown) and -1
-// means unknown.
-func actualContentLength(req *http.Request) int64 {
-	if req.Body == nil || req.Body == http.NoBody {
-		return 0
-	}
-	if req.ContentLength != 0 {
-		return req.ContentLength
-	}
-	return -1
-}
-
 func (cc *ClientConn) decrStreamReservations() {
 	cc.mu.Lock()
 	defer cc.mu.Unlock()
@@ -1356,7 +1310,7 @@ func (cc *ClientConn) roundTrip(req *http.Request, streamf func(*clientStream))
 		reqCancel:            req.Cancel,
 		isHead:               req.Method == "HEAD",
 		reqBody:              req.Body,
-		reqBodyContentLength: actualContentLength(req),
+		reqBodyContentLength: httpcommon.ActualContentLength(req),
 		trace:                httptrace.ContextClientTrace(ctx),
 		peerClosed:           make(chan struct{}),
 		abort:                make(chan struct{}),
@@ -1364,25 +1318,7 @@ func (cc *ClientConn) roundTrip(req *http.Request, streamf func(*clientStream))
 		donec:                make(chan struct{}),
 	}
 
-	// TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
-	if !cc.t.disableCompression() &&
-		req.Header.Get("Accept-Encoding") == "" &&
-		req.Header.Get("Range") == "" &&
-		!cs.isHead {
-		// Request gzip only, not deflate. Deflate is ambiguous and
-		// not as universally supported anyway.
-		// See: https://zlib.net/zlib_faq.html#faq39
-		//
-		// Note that we don't request this for HEAD requests,
-		// due to a bug in nginx:
-		//   http://trac.nginx.org/nginx/ticket/358
-		//   https://golang.org/issue/5522
-		//
-		// We don't request gzip if the request is for a range, since
-		// auto-decoding a portion of a gzipped document will just fail
-		// anyway. See https://golang.org/issue/8923
-		cs.requestedGzip = true
-	}
+	cs.requestedGzip = httpcommon.IsRequestGzip(req, cc.t.disableCompression())
 
 	go cs.doRequest(req, streamf)
 
@@ -1413,7 +1349,7 @@ func (cc *ClientConn) roundTrip(req *http.Request, streamf func(*clientStream))
 		}
 		res.Request = req
 		res.TLS = cc.tlsState
-		if res.Body == noBody && actualContentLength(req) == 0 {
+		if res.Body == noBody && httpcommon.ActualContentLength(req) == 0 {
 			// If there isn't a request or response body still being
 			// written, then wait for the stream to be closed before
 			// RoundTrip returns.
@@ -1496,10 +1432,6 @@ func (cs *clientStream) writeRequest(req *http.Request, streamf func(*clientStre
 	cc := cs.cc
 	ctx := cs.ctx
 
-	if err := checkConnHeaders(req); err != nil {
-		return err
-	}
-
 	// wait for setting frames to be received, a server can change this value later,
 	// but we just wait for the first settings frame
 	var isExtendedConnect bool
@@ -1663,20 +1595,22 @@ func (cs *clientStream) encodeAndWriteHeaders(req *http.Request) error {
 	// we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is
 	// sent by writeRequestBody below, along with any Trailers,
 	// again in form HEADERS{1}, CONTINUATION{0,})
-	trailers, err := commaSeparatedTrailers(req)
-	if err != nil {
-		return err
-	}
-	hasTrailers := trailers != ""
-	contentLen := actualContentLength(req)
-	hasBody := contentLen != 0
-	hdrs, err := cc.encodeHeaders(req, cs.requestedGzip, trailers, contentLen)
+	cc.hbuf.Reset()
+	res, err := httpcommon.EncodeHeaders(httpcommon.EncodeHeadersParam{
+		Request:               req,
+		AddGzipHeader:         cs.requestedGzip,
+		PeerMaxHeaderListSize: cc.peerMaxHeaderListSize,
+		DefaultUserAgent:      defaultUserAgent,
+	}, func(name, value string) {
+		cc.writeHeader(name, value)
+	})
 	if err != nil {
-		return err
+		return fmt.Errorf("http2: %w", err)
 	}
+	hdrs := cc.hbuf.Bytes()
 
 	// Write the request.
-	endStream := !hasBody && !hasTrailers
+	endStream := !res.HasBody && !res.HasTrailers
 	cs.sentHeaders = true
 	err = cc.writeHeaders(cs.ID, endStream, int(cc.maxFrameSize), hdrs)
 	traceWroteHeaders(cs.trace)
@@ -2070,218 +2004,6 @@ func (cs *clientStream) awaitFlowControl(maxBytes int) (taken int32, err error)
 	}
 }
 
-func validateHeaders(hdrs http.Header) string {
-	for k, vv := range hdrs {
-		if !httpguts.ValidHeaderFieldName(k) && k != ":protocol" {
-			return fmt.Sprintf("name %q", k)
-		}
-		for _, v := range vv {
-			if !httpguts.ValidHeaderFieldValue(v) {
-				// Don't include the value in the error,
-				// because it may be sensitive.
-				return fmt.Sprintf("value for header %q", k)
-			}
-		}
-	}
-	return ""
-}
-
-var errNilRequestURL = errors.New("http2: Request.URI is nil")
-
-func isNormalConnect(req *http.Request) bool {
-	return req.Method == "CONNECT" && req.Header.Get(":protocol") == ""
-}
-
-// requires cc.wmu be held.
-func (cc *ClientConn) encodeHeaders(req *http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) {
-	cc.hbuf.Reset()
-	if req.URL == nil {
-		return nil, errNilRequestURL
-	}
-
-	host := req.Host
-	if host == "" {
-		host = req.URL.Host
-	}
-	host, err := httpguts.PunycodeHostPort(host)
-	if err != nil {
-		return nil, err
-	}
-	if !httpguts.ValidHostHeader(host) {
-		return nil, errors.New("http2: invalid Host header")
-	}
-
-	var path string
-	if !isNormalConnect(req) {
-		path = req.URL.RequestURI()
-		if !validPseudoPath(path) {
-			orig := path
-			path = strings.TrimPrefix(path, req.URL.Scheme+"://"+host)
-			if !validPseudoPath(path) {
-				if req.URL.Opaque != "" {
-					return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
-				} else {
-					return nil, fmt.Errorf("invalid request :path %q", orig)
-				}
-			}
-		}
-	}
-
-	// Check for any invalid headers+trailers and return an error before we
-	// potentially pollute our hpack state. (We want to be able to
-	// continue to reuse the hpack encoder for future requests)
-	if err := validateHeaders(req.Header); err != "" {
-		return nil, fmt.Errorf("invalid HTTP header %s", err)
-	}
-	if err := validateHeaders(req.Trailer); err != "" {
-		return nil, fmt.Errorf("invalid HTTP trailer %s", err)
-	}
-
-	enumerateHeaders := func(f func(name, value string)) {
-		// 8.1.2.3 Request Pseudo-Header Fields
-		// The :path pseudo-header field includes the path and query parts of the
-		// target URI (the path-absolute production and optionally a '?' character
-		// followed by the query production, see Sections 3.3 and 3.4 of
-		// [RFC3986]).
-		f(":authority", host)
-		m := req.Method
-		if m == "" {
-			m = http.MethodGet
-		}
-		f(":method", m)
-		if !isNormalConnect(req) {
-			f(":path", path)
-			f(":scheme", req.URL.Scheme)
-		}
-		if trailers != "" {
-			f("trailer", trailers)
-		}
-
-		var didUA bool
-		for k, vv := range req.Header {
-			if asciiEqualFold(k, "host") || asciiEqualFold(k, "content-length") {
-				// Host is :authority, already sent.
-				// Content-Length is automatic, set below.
-				continue
-			} else if asciiEqualFold(k, "connection") ||
-				asciiEqualFold(k, "proxy-connection") ||
-				asciiEqualFold(k, "transfer-encoding") ||
-				asciiEqualFold(k, "upgrade") ||
-				asciiEqualFold(k, "keep-alive") {
-				// Per 8.1.2.2 Connection-Specific Header
-				// Fields, don't send connection-specific
-				// fields. We have already checked if any
-				// are error-worthy so just ignore the rest.
-				continue
-			} else if asciiEqualFold(k, "user-agent") {
-				// Match Go's http1 behavior: at most one
-				// User-Agent. If set to nil or empty string,
-				// then omit it. Otherwise if not mentioned,
-				// include the default (below).
-				didUA = true
-				if len(vv) < 1 {
-					continue
-				}
-				vv = vv[:1]
-				if vv[0] == "" {
-					continue
-				}
-			} else if asciiEqualFold(k, "cookie") {
-				// Per 8.1.2.5 To allow for better compression efficiency, the
-				// Cookie header field MAY be split into separate header fields,
-				// each with one or more cookie-pairs.
-				for _, v := range vv {
-					for {
-						p := strings.IndexByte(v, ';')
-						if p < 0 {
-							break
-						}
-						f("cookie", v[:p])
-						p++
-						// strip space after semicolon if any.
-						for p+1 <= len(v) && v[p] == ' ' {
-							p++
-						}
-						v = v[p:]
-					}
-					if len(v) > 0 {
-						f("cookie", v)
-					}
-				}
-				continue
-			}
-
-			for _, v := range vv {
-				f(k, v)
-			}
-		}
-		if shouldSendReqContentLength(req.Method, contentLength) {
-			f("content-length", strconv.FormatInt(contentLength, 10))
-		}
-		if addGzipHeader {
-			f("accept-encoding", "gzip")
-		}
-		if !didUA {
-			f("user-agent", defaultUserAgent)
-		}
-	}
-
-	// Do a first pass over the headers counting bytes to ensure
-	// we don't exceed cc.peerMaxHeaderListSize. This is done as a
-	// separate pass before encoding the headers to prevent
-	// modifying the hpack state.
-	hlSize := uint64(0)
-	enumerateHeaders(func(name, value string) {
-		hf := hpack.HeaderField{Name: name, Value: value}
-		hlSize += uint64(hf.Size())
-	})
-
-	if hlSize > cc.peerMaxHeaderListSize {
-		return nil, errRequestHeaderListSize
-	}
-
-	trace := httptrace.ContextClientTrace(req.Context())
-	traceHeaders := traceHasWroteHeaderField(trace)
-
-	// Header list size is ok. Write the headers.
-	enumerateHeaders(func(name, value string) {
-		name, ascii := lowerHeader(name)
-		if !ascii {
-			// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
-			// field names have to be ASCII characters (just as in HTTP/1.x).
-			return
-		}
-		cc.writeHeader(name, value)
-		if traceHeaders {
-			traceWroteHeaderField(trace, name, value)
-		}
-	})
-
-	return cc.hbuf.Bytes(), nil
-}
-
-// shouldSendReqContentLength reports whether the http2.Transport should send
-// a "content-length" request header. This logic is basically a copy of the net/http
-// transferWriter.shouldSendContentLength.
-// The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
-// -1 means unknown.
-func shouldSendReqContentLength(method string, contentLength int64) bool {
-	if contentLength > 0 {
-		return true
-	}
-	if contentLength < 0 {
-		return false
-	}
-	// For zero bodies, whether we send a content-length depends on the method.
-	// It also kinda doesn't matter for http2 either way, with END_STREAM.
-	switch method {
-	case "POST", "PUT", "PATCH":
-		return true
-	default:
-		return false
-	}
-}
-
 // requires cc.wmu be held.
 func (cc *ClientConn) encodeTrailers(trailer http.Header) ([]byte, error) {
 	cc.hbuf.Reset()
@@ -2298,7 +2020,7 @@ func (cc *ClientConn) encodeTrailers(trailer http.Header) ([]byte, error) {
 	}
 
 	for k, vv := range trailer {
-		lowKey, ascii := lowerHeader(k)
+		lowKey, ascii := httpcommon.LowerHeader(k)
 		if !ascii {
 			// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
 			// field names have to be ASCII characters (just as in HTTP/1.x).
@@ -2653,7 +2375,7 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra
 		Status:     status + " " + http.StatusText(statusCode),
 	}
 	for _, hf := range regularFields {
-		key := canonicalHeader(hf.Name)
+		key := httpcommon.CanonicalHeader(hf.Name)
 		if key == "Trailer" {
 			t := res.Trailer
 			if t == nil {
@@ -2661,7 +2383,7 @@ func (rl *clientConnReadLoop) handleResponse(cs *clientStream, f *MetaHeadersFra
 				res.Trailer = t
 			}
 			foreachHeaderElement(hf.Value, func(v string) {
-				t[canonicalHeader(v)] = nil
+				t[httpcommon.CanonicalHeader(v)] = nil
 			})
 		} else {
 			vv := header[key]
@@ -2785,7 +2507,7 @@ func (rl *clientConnReadLoop) processTrailers(cs *clientStream, f *MetaHeadersFr
 
 	trailer := make(http.Header)
 	for _, hf := range f.RegularFields() {
-		key := canonicalHeader(hf.Name)
+		key := httpcommon.CanonicalHeader(hf.Name)
 		trailer[key] = append(trailer[key], hf.Value)
 	}
 	cs.trailer = trailer
@@ -3331,7 +3053,7 @@ func (cc *ClientConn) writeStreamReset(streamID uint32, code ErrCode, ping bool,
 
 var (
 	errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
-	errRequestHeaderListSize  = errors.New("http2: request header list larger than peer's advertised limit")
+	errRequestHeaderListSize  = httpcommon.ErrRequestHeaderListSize
 )
 
 func (cc *ClientConn) logf(format string, args ...interface{}) {
@@ -3515,16 +3237,6 @@ func traceFirstResponseByte(trace *httptrace.ClientTrace) {
 	}
 }
 
-func traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool {
-	return trace != nil && trace.WroteHeaderField != nil
-}
-
-func traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) {
-	if trace != nil && trace.WroteHeaderField != nil {
-		trace.WroteHeaderField(k, []string{v})
-	}
-}
-
 func traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error {
 	if trace != nil {
 		return trace.Got1xxResponse
diff --git a/vendor/golang.org/x/net/http2/write.go b/vendor/golang.org/x/net/http2/write.go
index 6ff6bee7e..fdb35b947 100644
--- a/vendor/golang.org/x/net/http2/write.go
+++ b/vendor/golang.org/x/net/http2/write.go
@@ -13,6 +13,7 @@ import (
 
 	"golang.org/x/net/http/httpguts"
 	"golang.org/x/net/http2/hpack"
+	"golang.org/x/net/internal/httpcommon"
 )
 
 // writeFramer is implemented by any type that is used to write frames.
@@ -351,7 +352,7 @@ func encodeHeaders(enc *hpack.Encoder, h http.Header, keys []string) {
 	}
 	for _, k := range keys {
 		vv := h[k]
-		k, ascii := lowerHeader(k)
+		k, ascii := httpcommon.LowerHeader(k)
 		if !ascii {
 			// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
 			// field names have to be ASCII characters (just as in HTTP/1.x).
diff --git a/vendor/golang.org/x/net/internal/httpcommon/ascii.go b/vendor/golang.org/x/net/internal/httpcommon/ascii.go
new file mode 100644
index 000000000..ed14da5af
--- /dev/null
+++ b/vendor/golang.org/x/net/internal/httpcommon/ascii.go
@@ -0,0 +1,53 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httpcommon
+
+import "strings"
+
+// The HTTP protocols are defined in terms of ASCII, not Unicode. This file
+// contains helper functions which may use Unicode-aware functions which would
+// otherwise be unsafe and could introduce vulnerabilities if used improperly.
+
+// asciiEqualFold is strings.EqualFold, ASCII only. It reports whether s and t
+// are equal, ASCII-case-insensitively.
+func asciiEqualFold(s, t string) bool {
+	if len(s) != len(t) {
+		return false
+	}
+	for i := 0; i < len(s); i++ {
+		if lower(s[i]) != lower(t[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// lower returns the ASCII lowercase version of b.
+func lower(b byte) byte {
+	if 'A' <= b && b <= 'Z' {
+		return b + ('a' - 'A')
+	}
+	return b
+}
+
+// isASCIIPrint returns whether s is ASCII and printable according to
+// https://tools.ietf.org/html/rfc20#section-4.2.
+func isASCIIPrint(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] < ' ' || s[i] > '~' {
+			return false
+		}
+	}
+	return true
+}
+
+// asciiToLower returns the lowercase version of s if s is ASCII and printable,
+// and whether or not it was.
+func asciiToLower(s string) (lower string, ok bool) {
+	if !isASCIIPrint(s) {
+		return "", false
+	}
+	return strings.ToLower(s), true
+}
diff --git a/vendor/golang.org/x/net/http2/headermap.go b/vendor/golang.org/x/net/internal/httpcommon/headermap.go
similarity index 77%
rename from vendor/golang.org/x/net/http2/headermap.go
rename to vendor/golang.org/x/net/internal/httpcommon/headermap.go
index 149b3dd20..ad3fbacd6 100644
--- a/vendor/golang.org/x/net/http2/headermap.go
+++ b/vendor/golang.org/x/net/internal/httpcommon/headermap.go
@@ -1,8 +1,8 @@
-// Copyright 2014 The Go Authors. All rights reserved.
+// Copyright 2025 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package http2
+package httpcommon
 
 import (
 	"net/http"
@@ -88,7 +88,9 @@ func buildCommonHeaderMaps() {
 	}
 }
 
-func lowerHeader(v string) (lower string, ascii bool) {
+// LowerHeader returns the lowercase form of a header name,
+// used on the wire for HTTP/2 and HTTP/3 requests.
+func LowerHeader(v string) (lower string, ascii bool) {
 	buildCommonHeaderMapsOnce()
 	if s, ok := commonLowerHeader[v]; ok {
 		return s, true
@@ -96,10 +98,18 @@ func lowerHeader(v string) (lower string, ascii bool) {
 	return asciiToLower(v)
 }
 
-func canonicalHeader(v string) string {
+// CanonicalHeader canonicalizes a header name. (For example, "host" becomes "Host".)
+func CanonicalHeader(v string) string {
 	buildCommonHeaderMapsOnce()
 	if s, ok := commonCanonHeader[v]; ok {
 		return s
 	}
 	return http.CanonicalHeaderKey(v)
 }
+
+// CachedCanonicalHeader returns the canonical form of a well-known header name.
+func CachedCanonicalHeader(v string) (string, bool) {
+	buildCommonHeaderMapsOnce()
+	s, ok := commonCanonHeader[v]
+	return s, ok
+}
diff --git a/vendor/golang.org/x/net/internal/httpcommon/request.go b/vendor/golang.org/x/net/internal/httpcommon/request.go
new file mode 100644
index 000000000..343914773
--- /dev/null
+++ b/vendor/golang.org/x/net/internal/httpcommon/request.go
@@ -0,0 +1,379 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package httpcommon
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptrace"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/net/http/httpguts"
+	"golang.org/x/net/http2/hpack"
+)
+
+var (
+	ErrRequestHeaderListSize = errors.New("request header list larger than peer's advertised limit")
+)
+
+// EncodeHeadersParam is parameters to EncodeHeaders.
+type EncodeHeadersParam struct {
+	Request *http.Request
+
+	// AddGzipHeader indicates that an "accept-encoding: gzip" header should be
+	// added to the request.
+	AddGzipHeader bool
+
+	// PeerMaxHeaderListSize, when non-zero, is the peer's MAX_HEADER_LIST_SIZE setting.
+	PeerMaxHeaderListSize uint64
+
+	// DefaultUserAgent is the User-Agent header to send when the request
+	// neither contains a User-Agent nor disables it.
+	DefaultUserAgent string
+}
+
+// EncodeHeadersParam is the result of EncodeHeaders.
+type EncodeHeadersResult struct {
+	HasBody     bool
+	HasTrailers bool
+}
+
+// EncodeHeaders constructs request headers common to HTTP/2 and HTTP/3.
+// It validates a request and calls headerf with each pseudo-header and header
+// for the request.
+// The headerf function is called with the validated, canonicalized header name.
+func EncodeHeaders(param EncodeHeadersParam, headerf func(name, value string)) (res EncodeHeadersResult, _ error) {
+	req := param.Request
+
+	// Check for invalid connection-level headers.
+	if err := checkConnHeaders(req); err != nil {
+		return res, err
+	}
+
+	if req.URL == nil {
+		return res, errors.New("Request.URL is nil")
+	}
+
+	host := req.Host
+	if host == "" {
+		host = req.URL.Host
+	}
+	host, err := httpguts.PunycodeHostPort(host)
+	if err != nil {
+		return res, err
+	}
+	if !httpguts.ValidHostHeader(host) {
+		return res, errors.New("invalid Host header")
+	}
+
+	// isNormalConnect is true if this is a non-extended CONNECT request.
+	isNormalConnect := false
+	protocol := req.Header.Get(":protocol")
+	if req.Method == "CONNECT" && protocol == "" {
+		isNormalConnect = true
+	} else if protocol != "" && req.Method != "CONNECT" {
+		return res, errors.New("invalid :protocol header in non-CONNECT request")
+	}
+
+	// Validate the path, except for non-extended CONNECT requests which have no path.
+	var path string
+	if !isNormalConnect {
+		path = req.URL.RequestURI()
+		if !validPseudoPath(path) {
+			orig := path
+			path = strings.TrimPrefix(path, req.URL.Scheme+"://"+host)
+			if !validPseudoPath(path) {
+				if req.URL.Opaque != "" {
+					return res, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
+				} else {
+					return res, fmt.Errorf("invalid request :path %q", orig)
+				}
+			}
+		}
+	}
+
+	// Check for any invalid headers+trailers and return an error before we
+	// potentially pollute our hpack state. (We want to be able to
+	// continue to reuse the hpack encoder for future requests)
+	if err := validateHeaders(req.Header); err != "" {
+		return res, fmt.Errorf("invalid HTTP header %s", err)
+	}
+	if err := validateHeaders(req.Trailer); err != "" {
+		return res, fmt.Errorf("invalid HTTP trailer %s", err)
+	}
+
+	contentLength := ActualContentLength(req)
+
+	trailers, err := commaSeparatedTrailers(req)
+	if err != nil {
+		return res, err
+	}
+
+	enumerateHeaders := func(f func(name, value string)) {
+		// 8.1.2.3 Request Pseudo-Header Fields
+		// The :path pseudo-header field includes the path and query parts of the
+		// target URI (the path-absolute production and optionally a '?' character
+		// followed by the query production, see Sections 3.3 and 3.4 of
+		// [RFC3986]).
+		f(":authority", host)
+		m := req.Method
+		if m == "" {
+			m = http.MethodGet
+		}
+		f(":method", m)
+		if !isNormalConnect {
+			f(":path", path)
+			f(":scheme", req.URL.Scheme)
+		}
+		if protocol != "" {
+			f(":protocol", protocol)
+		}
+		if trailers != "" {
+			f("trailer", trailers)
+		}
+
+		var didUA bool
+		for k, vv := range req.Header {
+			if asciiEqualFold(k, "host") || asciiEqualFold(k, "content-length") {
+				// Host is :authority, already sent.
+				// Content-Length is automatic, set below.
+				continue
+			} else if asciiEqualFold(k, "connection") ||
+				asciiEqualFold(k, "proxy-connection") ||
+				asciiEqualFold(k, "transfer-encoding") ||
+				asciiEqualFold(k, "upgrade") ||
+				asciiEqualFold(k, "keep-alive") {
+				// Per 8.1.2.2 Connection-Specific Header
+				// Fields, don't send connection-specific
+				// fields. We have already checked if any
+				// are error-worthy so just ignore the rest.
+				continue
+			} else if asciiEqualFold(k, "user-agent") {
+				// Match Go's http1 behavior: at most one
+				// User-Agent. If set to nil or empty string,
+				// then omit it. Otherwise if not mentioned,
+				// include the default (below).
+				didUA = true
+				if len(vv) < 1 {
+					continue
+				}
+				vv = vv[:1]
+				if vv[0] == "" {
+					continue
+				}
+			} else if asciiEqualFold(k, "cookie") {
+				// Per 8.1.2.5 To allow for better compression efficiency, the
+				// Cookie header field MAY be split into separate header fields,
+				// each with one or more cookie-pairs.
+				for _, v := range vv {
+					for {
+						p := strings.IndexByte(v, ';')
+						if p < 0 {
+							break
+						}
+						f("cookie", v[:p])
+						p++
+						// strip space after semicolon if any.
+						for p+1 <= len(v) && v[p] == ' ' {
+							p++
+						}
+						v = v[p:]
+					}
+					if len(v) > 0 {
+						f("cookie", v)
+					}
+				}
+				continue
+			} else if k == ":protocol" {
+				// :protocol pseudo-header was already sent above.
+				continue
+			}
+
+			for _, v := range vv {
+				f(k, v)
+			}
+		}
+		if shouldSendReqContentLength(req.Method, contentLength) {
+			f("content-length", strconv.FormatInt(contentLength, 10))
+		}
+		if param.AddGzipHeader {
+			f("accept-encoding", "gzip")
+		}
+		if !didUA {
+			f("user-agent", param.DefaultUserAgent)
+		}
+	}
+
+	// Do a first pass over the headers counting bytes to ensure
+	// we don't exceed cc.peerMaxHeaderListSize. This is done as a
+	// separate pass before encoding the headers to prevent
+	// modifying the hpack state.
+	if param.PeerMaxHeaderListSize > 0 {
+		hlSize := uint64(0)
+		enumerateHeaders(func(name, value string) {
+			hf := hpack.HeaderField{Name: name, Value: value}
+			hlSize += uint64(hf.Size())
+		})
+
+		if hlSize > param.PeerMaxHeaderListSize {
+			return res, ErrRequestHeaderListSize
+		}
+	}
+
+	trace := httptrace.ContextClientTrace(req.Context())
+
+	// Header list size is ok. Write the headers.
+	enumerateHeaders(func(name, value string) {
+		name, ascii := LowerHeader(name)
+		if !ascii {
+			// Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header
+			// field names have to be ASCII characters (just as in HTTP/1.x).
+			return
+		}
+
+		headerf(name, value)
+
+		if trace != nil && trace.WroteHeaderField != nil {
+			trace.WroteHeaderField(name, []string{value})
+		}
+	})
+
+	res.HasBody = contentLength != 0
+	res.HasTrailers = trailers != ""
+	return res, nil
+}
+
+// IsRequestGzip reports whether we should add an Accept-Encoding: gzip header
+// for a request.
+func IsRequestGzip(req *http.Request, disableCompression bool) bool {
+	// TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
+	if !disableCompression &&
+		req.Header.Get("Accept-Encoding") == "" &&
+		req.Header.Get("Range") == "" &&
+		req.Method != "HEAD" {
+		// Request gzip only, not deflate. Deflate is ambiguous and
+		// not as universally supported anyway.
+		// See: https://zlib.net/zlib_faq.html#faq39
+		//
+		// Note that we don't request this for HEAD requests,
+		// due to a bug in nginx:
+		//   http://trac.nginx.org/nginx/ticket/358
+		//   https://golang.org/issue/5522
+		//
+		// We don't request gzip if the request is for a range, since
+		// auto-decoding a portion of a gzipped document will just fail
+		// anyway. See https://golang.org/issue/8923
+		return true
+	}
+	return false
+}
+
+// checkConnHeaders checks whether req has any invalid connection-level headers.
+//
+// https://www.rfc-editor.org/rfc/rfc9114.html#section-4.2-3
+// https://www.rfc-editor.org/rfc/rfc9113.html#section-8.2.2-1
+//
+// Certain headers are special-cased as okay but not transmitted later.
+// For example, we allow "Transfer-Encoding: chunked", but drop the header when encoding.
+func checkConnHeaders(req *http.Request) error {
+	if v := req.Header.Get("Upgrade"); v != "" {
+		return fmt.Errorf("invalid Upgrade request header: %q", req.Header["Upgrade"])
+	}
+	if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && vv[0] != "chunked") {
+		return fmt.Errorf("invalid Transfer-Encoding request header: %q", vv)
+	}
+	if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !asciiEqualFold(vv[0], "close") && !asciiEqualFold(vv[0], "keep-alive")) {
+		return fmt.Errorf("invalid Connection request header: %q", vv)
+	}
+	return nil
+}
+
+func commaSeparatedTrailers(req *http.Request) (string, error) {
+	keys := make([]string, 0, len(req.Trailer))
+	for k := range req.Trailer {
+		k = CanonicalHeader(k)
+		switch k {
+		case "Transfer-Encoding", "Trailer", "Content-Length":
+			return "", fmt.Errorf("invalid Trailer key %q", k)
+		}
+		keys = append(keys, k)
+	}
+	if len(keys) > 0 {
+		sort.Strings(keys)
+		return strings.Join(keys, ","), nil
+	}
+	return "", nil
+}
+
+// ActualContentLength returns a sanitized version of
+// req.ContentLength, where 0 actually means zero (not unknown) and -1
+// means unknown.
+func ActualContentLength(req *http.Request) int64 {
+	if req.Body == nil || req.Body == http.NoBody {
+		return 0
+	}
+	if req.ContentLength != 0 {
+		return req.ContentLength
+	}
+	return -1
+}
+
+// validPseudoPath reports whether v is a valid :path pseudo-header
+// value. It must be either:
+//
+//   - a non-empty string starting with '/'
+//   - the string '*', for OPTIONS requests.
+//
+// For now this is only used a quick check for deciding when to clean
+// up Opaque URLs before sending requests from the Transport.
+// See golang.org/issue/16847
+//
+// We used to enforce that the path also didn't start with "//", but
+// Google's GFE accepts such paths and Chrome sends them, so ignore
+// that part of the spec. See golang.org/issue/19103.
+func validPseudoPath(v string) bool {
+	return (len(v) > 0 && v[0] == '/') || v == "*"
+}
+
+func validateHeaders(hdrs http.Header) string {
+	for k, vv := range hdrs {
+		if !httpguts.ValidHeaderFieldName(k) && k != ":protocol" {
+			return fmt.Sprintf("name %q", k)
+		}
+		for _, v := range vv {
+			if !httpguts.ValidHeaderFieldValue(v) {
+				// Don't include the value in the error,
+				// because it may be sensitive.
+				return fmt.Sprintf("value for header %q", k)
+			}
+		}
+	}
+	return ""
+}
+
+// shouldSendReqContentLength reports whether we should send
+// a "content-length" request header. This logic is basically a copy of the net/http
+// transferWriter.shouldSendContentLength.
+// The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
+// -1 means unknown.
+func shouldSendReqContentLength(method string, contentLength int64) bool {
+	if contentLength > 0 {
+		return true
+	}
+	if contentLength < 0 {
+		return false
+	}
+	// For zero bodies, whether we send a content-length depends on the method.
+	// It also kinda doesn't matter for http2 either way, with END_STREAM.
+	switch method {
+	case "POST", "PUT", "PATCH":
+		return true
+	default:
+		return false
+	}
+}
diff --git a/vendor/golang.org/x/sync/errgroup/errgroup.go b/vendor/golang.org/x/sync/errgroup/errgroup.go
index 948a3ee63..b8322598a 100644
--- a/vendor/golang.org/x/sync/errgroup/errgroup.go
+++ b/vendor/golang.org/x/sync/errgroup/errgroup.go
@@ -118,6 +118,7 @@ func (g *Group) TryGo(f func() error) bool {
 
 // SetLimit limits the number of active goroutines in this group to at most n.
 // A negative value indicates no limit.
+// A limit of zero will prevent any new goroutines from being added.
 //
 // Any subsequent call to the Go method will block until it can add an active
 // goroutine without exceeding the configured limit.
diff --git a/vendor/golang.org/x/sys/cpu/cpu.go b/vendor/golang.org/x/sys/cpu/cpu.go
index 02609d5b2..9c105f23a 100644
--- a/vendor/golang.org/x/sys/cpu/cpu.go
+++ b/vendor/golang.org/x/sys/cpu/cpu.go
@@ -72,6 +72,9 @@ var X86 struct {
 	HasSSSE3            bool // Supplemental streaming SIMD extension 3
 	HasSSE41            bool // Streaming SIMD extension 4 and 4.1
 	HasSSE42            bool // Streaming SIMD extension 4 and 4.2
+	HasAVXIFMA          bool // Advanced vector extension Integer Fused Multiply Add
+	HasAVXVNNI          bool // Advanced vector extension Vector Neural Network Instructions
+	HasAVXVNNIInt8      bool // Advanced vector extension Vector Neural Network Int8 instructions
 	_                   CacheLinePad
 }
 
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.go b/vendor/golang.org/x/sys/cpu/cpu_x86.go
index 600a68078..1e642f330 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_x86.go
@@ -53,6 +53,9 @@ func initOptions() {
 		{Name: "sse41", Feature: &X86.HasSSE41},
 		{Name: "sse42", Feature: &X86.HasSSE42},
 		{Name: "ssse3", Feature: &X86.HasSSSE3},
+		{Name: "avxifma", Feature: &X86.HasAVXIFMA},
+		{Name: "avxvnni", Feature: &X86.HasAVXVNNI},
+		{Name: "avxvnniint8", Feature: &X86.HasAVXVNNIInt8},
 
 		// These capabilities should always be enabled on amd64:
 		{Name: "sse2", Feature: &X86.HasSSE2, Required: runtime.GOARCH == "amd64"},
@@ -106,7 +109,7 @@ func archInit() {
 		return
 	}
 
-	_, ebx7, ecx7, edx7 := cpuid(7, 0)
+	eax7, ebx7, ecx7, edx7 := cpuid(7, 0)
 	X86.HasBMI1 = isSet(3, ebx7)
 	X86.HasAVX2 = isSet(5, ebx7) && osSupportsAVX
 	X86.HasBMI2 = isSet(8, ebx7)
@@ -134,14 +137,24 @@ func archInit() {
 		X86.HasAVX512VAES = isSet(9, ecx7)
 		X86.HasAVX512VBMI2 = isSet(6, ecx7)
 		X86.HasAVX512BITALG = isSet(12, ecx7)
-
-		eax71, _, _, _ := cpuid(7, 1)
-		X86.HasAVX512BF16 = isSet(5, eax71)
 	}
 
 	X86.HasAMXTile = isSet(24, edx7)
 	X86.HasAMXInt8 = isSet(25, edx7)
 	X86.HasAMXBF16 = isSet(22, edx7)
+
+	// These features depend on the second level of extended features.
+	if eax7 >= 1 {
+		eax71, _, _, edx71 := cpuid(7, 1)
+		if X86.HasAVX512 {
+			X86.HasAVX512BF16 = isSet(5, eax71)
+		}
+		if X86.HasAVX {
+			X86.HasAVXIFMA = isSet(23, eax71)
+			X86.HasAVXVNNI = isSet(4, eax71)
+			X86.HasAVXVNNIInt8 = isSet(4, edx71)
+		}
+	}
 }
 
 func isSet(bitpos uint, value uint32) bool {
diff --git a/vendor/golang.org/x/sys/unix/auxv.go b/vendor/golang.org/x/sys/unix/auxv.go
new file mode 100644
index 000000000..37a82528f
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/auxv.go
@@ -0,0 +1,36 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+//go:linkname runtime_getAuxv runtime.getAuxv
+func runtime_getAuxv() []uintptr
+
+// Auxv returns the ELF auxiliary vector as a sequence of key/value pairs.
+// The returned slice is always a fresh copy, owned by the caller.
+// It returns an error on non-ELF platforms, or if the auxiliary vector cannot be accessed,
+// which happens in some locked-down environments and build modes.
+func Auxv() ([][2]uintptr, error) {
+	vec := runtime_getAuxv()
+	vecLen := len(vec)
+
+	if vecLen == 0 {
+		return nil, syscall.ENOENT
+	}
+
+	if vecLen%2 != 0 {
+		return nil, syscall.EINVAL
+	}
+
+	result := make([]uintptr, vecLen)
+	copy(result, vec)
+	return unsafe.Slice((*[2]uintptr)(unsafe.Pointer(&result[0])), vecLen/2), nil
+}
diff --git a/vendor/golang.org/x/sys/unix/auxv_unsupported.go b/vendor/golang.org/x/sys/unix/auxv_unsupported.go
new file mode 100644
index 000000000..1200487f2
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/auxv_unsupported.go
@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !go1.21 && (aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos)
+
+package unix
+
+import "syscall"
+
+func Auxv() ([][2]uintptr, error) {
+	return nil, syscall.ENOTSUP
+}
diff --git a/vendor/golang.org/x/sys/unix/syscall_solaris.go b/vendor/golang.org/x/sys/unix/syscall_solaris.go
index 21974af06..abc395547 100644
--- a/vendor/golang.org/x/sys/unix/syscall_solaris.go
+++ b/vendor/golang.org/x/sys/unix/syscall_solaris.go
@@ -1102,3 +1102,90 @@ func (s *Strioctl) SetInt(i int) {
 func IoctlSetStrioctlRetInt(fd int, req int, s *Strioctl) (int, error) {
 	return ioctlPtrRet(fd, req, unsafe.Pointer(s))
 }
+
+// Ucred Helpers
+// See ucred(3c) and getpeerucred(3c)
+
+//sys	getpeerucred(fd uintptr, ucred *uintptr) (err error)
+//sys	ucredFree(ucred uintptr) = ucred_free
+//sys	ucredGet(pid int) (ucred uintptr, err error) = ucred_get
+//sys	ucredGeteuid(ucred uintptr) (uid int) = ucred_geteuid
+//sys	ucredGetegid(ucred uintptr) (gid int) = ucred_getegid
+//sys	ucredGetruid(ucred uintptr) (uid int) = ucred_getruid
+//sys	ucredGetrgid(ucred uintptr) (gid int) = ucred_getrgid
+//sys	ucredGetsuid(ucred uintptr) (uid int) = ucred_getsuid
+//sys	ucredGetsgid(ucred uintptr) (gid int) = ucred_getsgid
+//sys	ucredGetpid(ucred uintptr) (pid int) = ucred_getpid
+
+// Ucred is an opaque struct that holds user credentials.
+type Ucred struct {
+	ucred uintptr
+}
+
+// We need to ensure that ucredFree is called on the underlying ucred
+// when the Ucred is garbage collected.
+func ucredFinalizer(u *Ucred) {
+	ucredFree(u.ucred)
+}
+
+func GetPeerUcred(fd uintptr) (*Ucred, error) {
+	var ucred uintptr
+	err := getpeerucred(fd, &ucred)
+	if err != nil {
+		return nil, err
+	}
+	result := &Ucred{
+		ucred: ucred,
+	}
+	// set the finalizer on the result so that the ucred will be freed
+	runtime.SetFinalizer(result, ucredFinalizer)
+	return result, nil
+}
+
+func UcredGet(pid int) (*Ucred, error) {
+	ucred, err := ucredGet(pid)
+	if err != nil {
+		return nil, err
+	}
+	result := &Ucred{
+		ucred: ucred,
+	}
+	// set the finalizer on the result so that the ucred will be freed
+	runtime.SetFinalizer(result, ucredFinalizer)
+	return result, nil
+}
+
+func (u *Ucred) Geteuid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGeteuid(u.ucred)
+}
+
+func (u *Ucred) Getruid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetruid(u.ucred)
+}
+
+func (u *Ucred) Getsuid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetsuid(u.ucred)
+}
+
+func (u *Ucred) Getegid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetegid(u.ucred)
+}
+
+func (u *Ucred) Getrgid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetrgid(u.ucred)
+}
+
+func (u *Ucred) Getsgid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetsgid(u.ucred)
+}
+
+func (u *Ucred) Getpid() int {
+	defer runtime.KeepAlive(u)
+	return ucredGetpid(u.ucred)
+}
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 6ebc48b3f..4f432bfe8 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -1245,6 +1245,7 @@ const (
 	FAN_REPORT_DFID_NAME                        = 0xc00
 	FAN_REPORT_DFID_NAME_TARGET                 = 0x1e00
 	FAN_REPORT_DIR_FID                          = 0x400
+	FAN_REPORT_FD_ERROR                         = 0x2000
 	FAN_REPORT_FID                              = 0x200
 	FAN_REPORT_NAME                             = 0x800
 	FAN_REPORT_PIDFD                            = 0x80
@@ -1330,8 +1331,10 @@ const (
 	FUSE_SUPER_MAGIC                            = 0x65735546
 	FUTEXFS_SUPER_MAGIC                         = 0xbad1dea
 	F_ADD_SEALS                                 = 0x409
+	F_CREATED_QUERY                             = 0x404
 	F_DUPFD                                     = 0x0
 	F_DUPFD_CLOEXEC                             = 0x406
+	F_DUPFD_QUERY                               = 0x403
 	F_EXLCK                                     = 0x4
 	F_GETFD                                     = 0x1
 	F_GETFL                                     = 0x3
@@ -1551,6 +1554,7 @@ const (
 	IPPROTO_ROUTING                             = 0x2b
 	IPPROTO_RSVP                                = 0x2e
 	IPPROTO_SCTP                                = 0x84
+	IPPROTO_SMC                                 = 0x100
 	IPPROTO_TCP                                 = 0x6
 	IPPROTO_TP                                  = 0x1d
 	IPPROTO_UDP                                 = 0x11
@@ -1623,6 +1627,8 @@ const (
 	IPV6_UNICAST_IF                             = 0x4c
 	IPV6_USER_FLOW                              = 0xe
 	IPV6_V6ONLY                                 = 0x1a
+	IPV6_VERSION                                = 0x60
+	IPV6_VERSION_MASK                           = 0xf0
 	IPV6_XFRM_POLICY                            = 0x23
 	IP_ADD_MEMBERSHIP                           = 0x23
 	IP_ADD_SOURCE_MEMBERSHIP                    = 0x27
@@ -1867,6 +1873,7 @@ const (
 	MADV_UNMERGEABLE                            = 0xd
 	MADV_WILLNEED                               = 0x3
 	MADV_WIPEONFORK                             = 0x12
+	MAP_DROPPABLE                               = 0x8
 	MAP_FILE                                    = 0x0
 	MAP_FIXED                                   = 0x10
 	MAP_FIXED_NOREPLACE                         = 0x100000
@@ -1967,6 +1974,7 @@ const (
 	MSG_PEEK                                    = 0x2
 	MSG_PROXY                                   = 0x10
 	MSG_RST                                     = 0x1000
+	MSG_SOCK_DEVMEM                             = 0x2000000
 	MSG_SYN                                     = 0x400
 	MSG_TRUNC                                   = 0x20
 	MSG_TRYHARD                                 = 0x4
@@ -2083,6 +2091,7 @@ const (
 	NFC_ATR_REQ_MAXSIZE                         = 0x40
 	NFC_ATR_RES_GB_MAXSIZE                      = 0x2f
 	NFC_ATR_RES_MAXSIZE                         = 0x40
+	NFC_ATS_MAXSIZE                             = 0x14
 	NFC_COMM_ACTIVE                             = 0x0
 	NFC_COMM_PASSIVE                            = 0x1
 	NFC_DEVICE_NAME_MAXSIZE                     = 0x8
@@ -2163,6 +2172,7 @@ const (
 	NFNL_SUBSYS_QUEUE                           = 0x3
 	NFNL_SUBSYS_ULOG                            = 0x4
 	NFS_SUPER_MAGIC                             = 0x6969
+	NFT_BITWISE_BOOL                            = 0x0
 	NFT_CHAIN_FLAGS                             = 0x7
 	NFT_CHAIN_MAXNAMELEN                        = 0x100
 	NFT_CT_MAX                                  = 0x17
@@ -2491,6 +2501,7 @@ const (
 	PR_GET_PDEATHSIG                            = 0x2
 	PR_GET_SECCOMP                              = 0x15
 	PR_GET_SECUREBITS                           = 0x1b
+	PR_GET_SHADOW_STACK_STATUS                  = 0x4a
 	PR_GET_SPECULATION_CTRL                     = 0x34
 	PR_GET_TAGGED_ADDR_CTRL                     = 0x38
 	PR_GET_THP_DISABLE                          = 0x2a
@@ -2499,6 +2510,7 @@ const (
 	PR_GET_TIMING                               = 0xd
 	PR_GET_TSC                                  = 0x19
 	PR_GET_UNALIGN                              = 0x5
+	PR_LOCK_SHADOW_STACK_STATUS                 = 0x4c
 	PR_MCE_KILL                                 = 0x21
 	PR_MCE_KILL_CLEAR                           = 0x0
 	PR_MCE_KILL_DEFAULT                         = 0x2
@@ -2525,6 +2537,8 @@ const (
 	PR_PAC_GET_ENABLED_KEYS                     = 0x3d
 	PR_PAC_RESET_KEYS                           = 0x36
 	PR_PAC_SET_ENABLED_KEYS                     = 0x3c
+	PR_PMLEN_MASK                               = 0x7f000000
+	PR_PMLEN_SHIFT                              = 0x18
 	PR_PPC_DEXCR_CTRL_CLEAR                     = 0x4
 	PR_PPC_DEXCR_CTRL_CLEAR_ONEXEC              = 0x10
 	PR_PPC_DEXCR_CTRL_EDITABLE                  = 0x1
@@ -2592,6 +2606,7 @@ const (
 	PR_SET_PTRACER                              = 0x59616d61
 	PR_SET_SECCOMP                              = 0x16
 	PR_SET_SECUREBITS                           = 0x1c
+	PR_SET_SHADOW_STACK_STATUS                  = 0x4b
 	PR_SET_SPECULATION_CTRL                     = 0x35
 	PR_SET_SYSCALL_USER_DISPATCH                = 0x3b
 	PR_SET_TAGGED_ADDR_CTRL                     = 0x37
@@ -2602,6 +2617,9 @@ const (
 	PR_SET_UNALIGN                              = 0x6
 	PR_SET_VMA                                  = 0x53564d41
 	PR_SET_VMA_ANON_NAME                        = 0x0
+	PR_SHADOW_STACK_ENABLE                      = 0x1
+	PR_SHADOW_STACK_PUSH                        = 0x4
+	PR_SHADOW_STACK_WRITE                       = 0x2
 	PR_SME_GET_VL                               = 0x40
 	PR_SME_SET_VL                               = 0x3f
 	PR_SME_SET_VL_ONEXEC                        = 0x40000
@@ -2911,7 +2929,6 @@ const (
 	RTM_NEWNEXTHOP                              = 0x68
 	RTM_NEWNEXTHOPBUCKET                        = 0x74
 	RTM_NEWNSID                                 = 0x58
-	RTM_NEWNVLAN                                = 0x70
 	RTM_NEWPREFIX                               = 0x34
 	RTM_NEWQDISC                                = 0x24
 	RTM_NEWROUTE                                = 0x18
@@ -2920,6 +2937,7 @@ const (
 	RTM_NEWTCLASS                               = 0x28
 	RTM_NEWTFILTER                              = 0x2c
 	RTM_NEWTUNNEL                               = 0x78
+	RTM_NEWVLAN                                 = 0x70
 	RTM_NR_FAMILIES                             = 0x1b
 	RTM_NR_MSGTYPES                             = 0x6c
 	RTM_SETDCB                                  = 0x4f
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index c0d45e320..75207613c 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -116,6 +116,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -304,6 +306,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index c731d24f0..c68acda53 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -116,6 +116,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -305,6 +307,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index 680018a4a..a8c607ab8 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -310,6 +312,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index a63909f30..18563dd8d 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -109,6 +109,7 @@ const (
 	F_SETOWN                         = 0x8
 	F_UNLCK                          = 0x2
 	F_WRLCK                          = 0x1
+	GCS_MAGIC                        = 0x47435300
 	HIDIOCGRAWINFO                   = 0x80084803
 	HIDIOCGRDESC                     = 0x90044802
 	HIDIOCGRDESCSIZE                 = 0x80044801
@@ -119,6 +120,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -302,6 +305,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
index 9b0a2573f..22912cdaa 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
@@ -116,6 +116,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -297,6 +299,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index 958e6e064..29344eb37 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -303,6 +305,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index 50c7f25bd..20d51fb96 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -303,6 +305,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index ced21d66d..321b60902 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -303,6 +305,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index 226c04419..9bacdf1e2 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x80
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -303,6 +305,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
index 3122737cd..c22427261 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -358,6 +360,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index eb5d3467e..6270c8ee1 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -362,6 +364,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index e921ebc60..9966c1941 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x80
 	IUCLC                            = 0x1000
 	IXOFF                            = 0x400
@@ -362,6 +364,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index 38ba81c55..848e5fcc4 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xffffff0f
+	IPV6_FLOWLABEL_MASK              = 0xffff0f00
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -294,6 +296,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index 71f040097..669b2adb8 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -115,6 +115,8 @@ const (
 	IN_CLOEXEC                       = 0x80000
 	IN_NONBLOCK                      = 0x800
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x7b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -366,6 +368,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x36
 	SCM_TIMESTAMPING_PKTINFO         = 0x3a
 	SCM_TIMESTAMPNS                  = 0x23
+	SCM_TS_OPT_ID                    = 0x51
 	SCM_TXTIME                       = 0x3d
 	SCM_WIFI_STATUS                  = 0x29
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x40182103
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index c44a31332..4834e5751 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -119,6 +119,8 @@ const (
 	IN_CLOEXEC                       = 0x400000
 	IN_NONBLOCK                      = 0x4000
 	IOCTL_VM_SOCKETS_GET_LOCAL_CID   = 0x200007b9
+	IPV6_FLOWINFO_MASK               = 0xfffffff
+	IPV6_FLOWLABEL_MASK              = 0xfffff
 	ISIG                             = 0x1
 	IUCLC                            = 0x200
 	IXOFF                            = 0x1000
@@ -357,6 +359,7 @@ const (
 	SCM_TIMESTAMPING_OPT_STATS       = 0x38
 	SCM_TIMESTAMPING_PKTINFO         = 0x3c
 	SCM_TIMESTAMPNS                  = 0x21
+	SCM_TS_OPT_ID                    = 0x5a
 	SCM_TXTIME                       = 0x3f
 	SCM_WIFI_STATUS                  = 0x25
 	SECCOMP_IOCTL_NOTIF_ADDFD        = 0x80182103
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
index 829b87feb..c6545413c 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_solaris_amd64.go
@@ -141,6 +141,16 @@ import (
 //go:cgo_import_dynamic libc_getpeername getpeername "libsocket.so"
 //go:cgo_import_dynamic libc_setsockopt setsockopt "libsocket.so"
 //go:cgo_import_dynamic libc_recvfrom recvfrom "libsocket.so"
+//go:cgo_import_dynamic libc_getpeerucred getpeerucred "libc.so"
+//go:cgo_import_dynamic libc_ucred_get ucred_get "libc.so"
+//go:cgo_import_dynamic libc_ucred_geteuid ucred_geteuid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getegid ucred_getegid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getruid ucred_getruid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getrgid ucred_getrgid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getsuid ucred_getsuid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getsgid ucred_getsgid "libc.so"
+//go:cgo_import_dynamic libc_ucred_getpid ucred_getpid "libc.so"
+//go:cgo_import_dynamic libc_ucred_free ucred_free "libc.so"
 //go:cgo_import_dynamic libc_port_create port_create "libc.so"
 //go:cgo_import_dynamic libc_port_associate port_associate "libc.so"
 //go:cgo_import_dynamic libc_port_dissociate port_dissociate "libc.so"
@@ -280,6 +290,16 @@ import (
 //go:linkname procgetpeername libc_getpeername
 //go:linkname procsetsockopt libc_setsockopt
 //go:linkname procrecvfrom libc_recvfrom
+//go:linkname procgetpeerucred libc_getpeerucred
+//go:linkname procucred_get libc_ucred_get
+//go:linkname procucred_geteuid libc_ucred_geteuid
+//go:linkname procucred_getegid libc_ucred_getegid
+//go:linkname procucred_getruid libc_ucred_getruid
+//go:linkname procucred_getrgid libc_ucred_getrgid
+//go:linkname procucred_getsuid libc_ucred_getsuid
+//go:linkname procucred_getsgid libc_ucred_getsgid
+//go:linkname procucred_getpid libc_ucred_getpid
+//go:linkname procucred_free libc_ucred_free
 //go:linkname procport_create libc_port_create
 //go:linkname procport_associate libc_port_associate
 //go:linkname procport_dissociate libc_port_dissociate
@@ -420,6 +440,16 @@ var (
 	procgetpeername,
 	procsetsockopt,
 	procrecvfrom,
+	procgetpeerucred,
+	procucred_get,
+	procucred_geteuid,
+	procucred_getegid,
+	procucred_getruid,
+	procucred_getrgid,
+	procucred_getsuid,
+	procucred_getsgid,
+	procucred_getpid,
+	procucred_free,
 	procport_create,
 	procport_associate,
 	procport_dissociate,
@@ -2029,6 +2059,90 @@ func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Sockl
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func getpeerucred(fd uintptr, ucred *uintptr) (err error) {
+	_, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procgetpeerucred)), 2, uintptr(fd), uintptr(unsafe.Pointer(ucred)), 0, 0, 0, 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGet(pid int) (ucred uintptr, err error) {
+	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procucred_get)), 1, uintptr(pid), 0, 0, 0, 0, 0)
+	ucred = uintptr(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGeteuid(ucred uintptr) (uid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_geteuid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetegid(ucred uintptr) (gid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getegid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetruid(ucred uintptr) (uid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getruid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetrgid(ucred uintptr) (gid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getrgid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetsuid(ucred uintptr) (uid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getsuid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	uid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetsgid(ucred uintptr) (gid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getsgid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	gid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredGetpid(ucred uintptr) (pid int) {
+	r0, _, _ := sysvicall6(uintptr(unsafe.Pointer(&procucred_getpid)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	pid = int(r0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func ucredFree(ucred uintptr) {
+	sysvicall6(uintptr(unsafe.Pointer(&procucred_free)), 1, uintptr(ucred), 0, 0, 0, 0, 0)
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func port_create() (n int, err error) {
 	r0, _, e1 := sysvicall6(uintptr(unsafe.Pointer(&procport_create)), 0, 0, 0, 0, 0, 0, 0)
 	n = int(r0)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index 524b0820c..c79aaff30 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -458,4 +458,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
+	SYS_SETXATTRAT                   = 463
+	SYS_GETXATTRAT                   = 464
+	SYS_LISTXATTRAT                  = 465
+	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index f485dbf45..5eb450695 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -381,4 +381,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 70b35bf3b..05e502974 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -422,4 +422,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
+	SYS_SETXATTRAT                   = 463
+	SYS_GETXATTRAT                   = 464
+	SYS_LISTXATTRAT                  = 465
+	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 1893e2fe8..38c53ec51 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -325,4 +325,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
index 16a4017da..31d2e71a1 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
@@ -321,4 +321,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index 7e567f1ef..f4184a336 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -442,4 +442,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 4460
 	SYS_LSM_LIST_MODULES             = 4461
 	SYS_MSEAL                        = 4462
+	SYS_SETXATTRAT                   = 4463
+	SYS_GETXATTRAT                   = 4464
+	SYS_LISTXATTRAT                  = 4465
+	SYS_REMOVEXATTRAT                = 4466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 38ae55e5e..05b996227 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -372,4 +372,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 5460
 	SYS_LSM_LIST_MODULES        = 5461
 	SYS_MSEAL                   = 5462
+	SYS_SETXATTRAT              = 5463
+	SYS_GETXATTRAT              = 5464
+	SYS_LISTXATTRAT             = 5465
+	SYS_REMOVEXATTRAT           = 5466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 55e92e60a..43a256e9e 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -372,4 +372,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 5460
 	SYS_LSM_LIST_MODULES        = 5461
 	SYS_MSEAL                   = 5462
+	SYS_SETXATTRAT              = 5463
+	SYS_GETXATTRAT              = 5464
+	SYS_LISTXATTRAT             = 5465
+	SYS_REMOVEXATTRAT           = 5466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index 60658d6a0..eea5ddfc2 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -442,4 +442,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 4460
 	SYS_LSM_LIST_MODULES             = 4461
 	SYS_MSEAL                        = 4462
+	SYS_SETXATTRAT                   = 4463
+	SYS_GETXATTRAT                   = 4464
+	SYS_LISTXATTRAT                  = 4465
+	SYS_REMOVEXATTRAT                = 4466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
index e203e8a7e..0d777bfbb 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
@@ -449,4 +449,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR            = 460
 	SYS_LSM_LIST_MODULES             = 461
 	SYS_MSEAL                        = 462
+	SYS_SETXATTRAT                   = 463
+	SYS_GETXATTRAT                   = 464
+	SYS_LISTXATTRAT                  = 465
+	SYS_REMOVEXATTRAT                = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index 5944b97d5..b44636502 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -421,4 +421,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index c66d416da..0c7d21c18 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -421,4 +421,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index a5459e766..840539169 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -326,4 +326,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index 01d86825b..fcf1b790d 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -387,4 +387,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index 7b703e77c..52d15b5f9 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -400,4 +400,8 @@ const (
 	SYS_LSM_SET_SELF_ATTR       = 460
 	SYS_LSM_LIST_MODULES        = 461
 	SYS_MSEAL                   = 462
+	SYS_SETXATTRAT              = 463
+	SYS_GETXATTRAT              = 464
+	SYS_LISTXATTRAT             = 465
+	SYS_REMOVEXATTRAT           = 466
 )
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go
index 5537148dc..a46abe647 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -4747,7 +4747,7 @@ const (
 	NL80211_ATTR_MAC_HINT                                   = 0xc8
 	NL80211_ATTR_MAC_MASK                                   = 0xd7
 	NL80211_ATTR_MAX_AP_ASSOC_STA                           = 0xca
-	NL80211_ATTR_MAX                                        = 0x14c
+	NL80211_ATTR_MAX                                        = 0x14d
 	NL80211_ATTR_MAX_CRIT_PROT_DURATION                     = 0xb4
 	NL80211_ATTR_MAX_CSA_COUNTERS                           = 0xce
 	NL80211_ATTR_MAX_MATCH_SETS                             = 0x85
@@ -5519,7 +5519,7 @@ const (
 	NL80211_MNTR_FLAG_CONTROL                               = 0x3
 	NL80211_MNTR_FLAG_COOK_FRAMES                           = 0x5
 	NL80211_MNTR_FLAG_FCSFAIL                               = 0x1
-	NL80211_MNTR_FLAG_MAX                                   = 0x6
+	NL80211_MNTR_FLAG_MAX                                   = 0x7
 	NL80211_MNTR_FLAG_OTHER_BSS                             = 0x4
 	NL80211_MNTR_FLAG_PLCPFAIL                              = 0x2
 	NL80211_MPATH_FLAG_ACTIVE                               = 0x1
@@ -6174,3 +6174,5 @@ type SockDiagReq struct {
 	Family   uint8
 	Protocol uint8
 }
+
+const RTM_NEWNVLAN = 0x70
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go b/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
index cfda89343..0d5050fe4 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
@@ -37,6 +37,8 @@ package inspector
 import (
 	"go/ast"
 	_ "unsafe"
+
+	"golang.org/x/tools/internal/astutil/edge"
 )
 
 // An Inspector provides methods for inspecting
@@ -48,6 +50,21 @@ type Inspector struct {
 //go:linkname events
 func events(in *Inspector) []event { return in.events }
 
+func packEdgeKindAndIndex(ek edge.Kind, index int) int32 {
+	return int32(uint32(index+1)<<7 | uint32(ek))
+}
+
+// unpackEdgeKindAndIndex unpacks the edge kind and edge index (within
+// an []ast.Node slice) from the parent field of a pop event.
+//
+//go:linkname unpackEdgeKindAndIndex
+func unpackEdgeKindAndIndex(x int32) (edge.Kind, int) {
+	// The "parent" field of a pop node holds the
+	// edge Kind in the lower 7 bits and the index+1
+	// in the upper 25.
+	return edge.Kind(x & 0x7f), int(x>>7) - 1
+}
+
 // New returns an Inspector for the specified syntax trees.
 func New(files []*ast.File) *Inspector {
 	return &Inspector{traverse(files)}
@@ -59,7 +76,7 @@ type event struct {
 	node   ast.Node
 	typ    uint64 // typeOf(node) on push event, or union of typ strictly between push and pop events on pop events
 	index  int32  // index of corresponding push or pop event
-	parent int32  // index of parent's push node (defined for push nodes only)
+	parent int32  // index of parent's push node (push nodes only), or packed edge kind/index (pop nodes only)
 }
 
 // TODO: Experiment with storing only the second word of event.node (unsafe.Pointer).
@@ -194,49 +211,74 @@ func traverse(files []*ast.File) []event {
 		extent += int(f.End() - f.Pos())
 	}
 	// This estimate is based on the net/http package.
-	capacity := extent * 33 / 100
-	if capacity > 1e6 {
-		capacity = 1e6 // impose some reasonable maximum
+	capacity := min(extent*33/100, 1e6) // impose some reasonable maximum (1M)
+
+	v := &visitor{
+		events: make([]event, 0, capacity),
+		stack:  []item{{index: -1}}, // include an extra event so file nodes have a parent
 	}
-	events := make([]event, 0, capacity)
+	for _, file := range files {
+		walk(v, edge.Invalid, -1, file)
+	}
+	return v.events
+}
 
-	var stack []event
-	stack = append(stack, event{index: -1}) // include an extra event so file nodes have a parent
-	for _, f := range files {
-		ast.Inspect(f, func(n ast.Node) bool {
-			if n != nil {
-				// push
-				ev := event{
-					node:   n,
-					typ:    0,                  // temporarily used to accumulate type bits of subtree
-					index:  int32(len(events)), // push event temporarily holds own index
-					parent: stack[len(stack)-1].index,
-				}
-				stack = append(stack, ev)
-				events = append(events, ev)
+type visitor struct {
+	events []event
+	stack  []item
+}
 
-				// 2B nodes ought to be enough for anyone!
-				if int32(len(events)) < 0 {
-					panic("event index exceeded int32")
-				}
-			} else {
-				// pop
-				top := len(stack) - 1
-				ev := stack[top]
-				typ := typeOf(ev.node)
-				push := ev.index
-				parent := top - 1
-
-				events[push].typ = typ                  // set type of push
-				stack[parent].typ |= typ | ev.typ       // parent's typ contains push and pop's typs.
-				events[push].index = int32(len(events)) // make push refer to pop
-
-				stack = stack[:top]
-				events = append(events, ev)
-			}
-			return true
-		})
+type item struct {
+	index            int32  // index of current node's push event
+	parentIndex      int32  // index of parent node's push event
+	typAccum         uint64 // accumulated type bits of current node's descendents
+	edgeKindAndIndex int32  // edge.Kind and index, bit packed
+}
+
+func (v *visitor) push(ek edge.Kind, eindex int, node ast.Node) {
+	var (
+		index       = int32(len(v.events))
+		parentIndex = v.stack[len(v.stack)-1].index
+	)
+	v.events = append(v.events, event{
+		node:   node,
+		parent: parentIndex,
+		typ:    typeOf(node),
+		index:  0, // (pop index is set later by visitor.pop)
+	})
+	v.stack = append(v.stack, item{
+		index:            index,
+		parentIndex:      parentIndex,
+		edgeKindAndIndex: packEdgeKindAndIndex(ek, eindex),
+	})
+
+	// 2B nodes ought to be enough for anyone!
+	if int32(len(v.events)) < 0 {
+		panic("event index exceeded int32")
+	}
+
+	// 32M elements in an []ast.Node ought to be enough for anyone!
+	if ek2, eindex2 := unpackEdgeKindAndIndex(packEdgeKindAndIndex(ek, eindex)); ek2 != ek || eindex2 != eindex {
+		panic("Node slice index exceeded uint25")
 	}
+}
+
+func (v *visitor) pop(node ast.Node) {
+	top := len(v.stack) - 1
+	current := v.stack[top]
+
+	push := &v.events[current.index]
+	parent := &v.stack[top-1]
+
+	push.index = int32(len(v.events))              // make push event refer to pop
+	parent.typAccum |= current.typAccum | push.typ // accumulate type bits into parent
+
+	v.stack = v.stack[:top]
 
-	return events
+	v.events = append(v.events, event{
+		node:   node,
+		typ:    current.typAccum,
+		index:  current.index,
+		parent: current.edgeKindAndIndex, // see [unpackEdgeKindAndIndex]
+	})
 }
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/typeof.go b/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
index 40b1bfd7e..977844845 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
@@ -219,7 +219,7 @@ func typeOf(n ast.Node) uint64 {
 
 //go:linkname maskOf
 func maskOf(nodes []ast.Node) uint64 {
-	if nodes == nil {
+	if len(nodes) == 0 {
 		return math.MaxUint64 // match all node types
 	}
 	var mask uint64
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/walk.go b/vendor/golang.org/x/tools/go/ast/inspector/walk.go
new file mode 100644
index 000000000..5a42174a0
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/inspector/walk.go
@@ -0,0 +1,341 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package inspector
+
+// This file is a fork of ast.Inspect to reduce unnecessary dynamic
+// calls and to gather edge information.
+//
+// Consistency with the original is ensured by TestInspectAllNodes.
+
+import (
+	"fmt"
+	"go/ast"
+
+	"golang.org/x/tools/internal/astutil/edge"
+)
+
+func walkList[N ast.Node](v *visitor, ek edge.Kind, list []N) {
+	for i, node := range list {
+		walk(v, ek, i, node)
+	}
+}
+
+func walk(v *visitor, ek edge.Kind, index int, node ast.Node) {
+	v.push(ek, index, node)
+
+	// walk children
+	// (the order of the cases matches the order
+	// of the corresponding node types in ast.go)
+	switch n := node.(type) {
+	// Comments and fields
+	case *ast.Comment:
+		// nothing to do
+
+	case *ast.CommentGroup:
+		walkList(v, edge.CommentGroup_List, n.List)
+
+	case *ast.Field:
+		if n.Doc != nil {
+			walk(v, edge.Field_Doc, -1, n.Doc)
+		}
+		walkList(v, edge.Field_Names, n.Names)
+		if n.Type != nil {
+			walk(v, edge.Field_Type, -1, n.Type)
+		}
+		if n.Tag != nil {
+			walk(v, edge.Field_Tag, -1, n.Tag)
+		}
+		if n.Comment != nil {
+			walk(v, edge.Field_Comment, -1, n.Comment)
+		}
+
+	case *ast.FieldList:
+		walkList(v, edge.FieldList_List, n.List)
+
+	// Expressions
+	case *ast.BadExpr, *ast.Ident, *ast.BasicLit:
+		// nothing to do
+
+	case *ast.Ellipsis:
+		if n.Elt != nil {
+			walk(v, edge.Ellipsis_Elt, -1, n.Elt)
+		}
+
+	case *ast.FuncLit:
+		walk(v, edge.FuncLit_Type, -1, n.Type)
+		walk(v, edge.FuncLit_Body, -1, n.Body)
+
+	case *ast.CompositeLit:
+		if n.Type != nil {
+			walk(v, edge.CompositeLit_Type, -1, n.Type)
+		}
+		walkList(v, edge.CompositeLit_Elts, n.Elts)
+
+	case *ast.ParenExpr:
+		walk(v, edge.ParenExpr_X, -1, n.X)
+
+	case *ast.SelectorExpr:
+		walk(v, edge.SelectorExpr_X, -1, n.X)
+		walk(v, edge.SelectorExpr_Sel, -1, n.Sel)
+
+	case *ast.IndexExpr:
+		walk(v, edge.IndexExpr_X, -1, n.X)
+		walk(v, edge.IndexExpr_Index, -1, n.Index)
+
+	case *ast.IndexListExpr:
+		walk(v, edge.IndexListExpr_X, -1, n.X)
+		walkList(v, edge.IndexListExpr_Indices, n.Indices)
+
+	case *ast.SliceExpr:
+		walk(v, edge.SliceExpr_X, -1, n.X)
+		if n.Low != nil {
+			walk(v, edge.SliceExpr_Low, -1, n.Low)
+		}
+		if n.High != nil {
+			walk(v, edge.SliceExpr_High, -1, n.High)
+		}
+		if n.Max != nil {
+			walk(v, edge.SliceExpr_Max, -1, n.Max)
+		}
+
+	case *ast.TypeAssertExpr:
+		walk(v, edge.TypeAssertExpr_X, -1, n.X)
+		if n.Type != nil {
+			walk(v, edge.TypeAssertExpr_Type, -1, n.Type)
+		}
+
+	case *ast.CallExpr:
+		walk(v, edge.CallExpr_Fun, -1, n.Fun)
+		walkList(v, edge.CallExpr_Args, n.Args)
+
+	case *ast.StarExpr:
+		walk(v, edge.StarExpr_X, -1, n.X)
+
+	case *ast.UnaryExpr:
+		walk(v, edge.UnaryExpr_X, -1, n.X)
+
+	case *ast.BinaryExpr:
+		walk(v, edge.BinaryExpr_X, -1, n.X)
+		walk(v, edge.BinaryExpr_Y, -1, n.Y)
+
+	case *ast.KeyValueExpr:
+		walk(v, edge.KeyValueExpr_Key, -1, n.Key)
+		walk(v, edge.KeyValueExpr_Value, -1, n.Value)
+
+	// Types
+	case *ast.ArrayType:
+		if n.Len != nil {
+			walk(v, edge.ArrayType_Len, -1, n.Len)
+		}
+		walk(v, edge.ArrayType_Elt, -1, n.Elt)
+
+	case *ast.StructType:
+		walk(v, edge.StructType_Fields, -1, n.Fields)
+
+	case *ast.FuncType:
+		if n.TypeParams != nil {
+			walk(v, edge.FuncType_TypeParams, -1, n.TypeParams)
+		}
+		if n.Params != nil {
+			walk(v, edge.FuncType_Params, -1, n.Params)
+		}
+		if n.Results != nil {
+			walk(v, edge.FuncType_Results, -1, n.Results)
+		}
+
+	case *ast.InterfaceType:
+		walk(v, edge.InterfaceType_Methods, -1, n.Methods)
+
+	case *ast.MapType:
+		walk(v, edge.MapType_Key, -1, n.Key)
+		walk(v, edge.MapType_Value, -1, n.Value)
+
+	case *ast.ChanType:
+		walk(v, edge.ChanType_Value, -1, n.Value)
+
+	// Statements
+	case *ast.BadStmt:
+		// nothing to do
+
+	case *ast.DeclStmt:
+		walk(v, edge.DeclStmt_Decl, -1, n.Decl)
+
+	case *ast.EmptyStmt:
+		// nothing to do
+
+	case *ast.LabeledStmt:
+		walk(v, edge.LabeledStmt_Label, -1, n.Label)
+		walk(v, edge.LabeledStmt_Stmt, -1, n.Stmt)
+
+	case *ast.ExprStmt:
+		walk(v, edge.ExprStmt_X, -1, n.X)
+
+	case *ast.SendStmt:
+		walk(v, edge.SendStmt_Chan, -1, n.Chan)
+		walk(v, edge.SendStmt_Value, -1, n.Value)
+
+	case *ast.IncDecStmt:
+		walk(v, edge.IncDecStmt_X, -1, n.X)
+
+	case *ast.AssignStmt:
+		walkList(v, edge.AssignStmt_Lhs, n.Lhs)
+		walkList(v, edge.AssignStmt_Rhs, n.Rhs)
+
+	case *ast.GoStmt:
+		walk(v, edge.GoStmt_Call, -1, n.Call)
+
+	case *ast.DeferStmt:
+		walk(v, edge.DeferStmt_Call, -1, n.Call)
+
+	case *ast.ReturnStmt:
+		walkList(v, edge.ReturnStmt_Results, n.Results)
+
+	case *ast.BranchStmt:
+		if n.Label != nil {
+			walk(v, edge.BranchStmt_Label, -1, n.Label)
+		}
+
+	case *ast.BlockStmt:
+		walkList(v, edge.BlockStmt_List, n.List)
+
+	case *ast.IfStmt:
+		if n.Init != nil {
+			walk(v, edge.IfStmt_Init, -1, n.Init)
+		}
+		walk(v, edge.IfStmt_Cond, -1, n.Cond)
+		walk(v, edge.IfStmt_Body, -1, n.Body)
+		if n.Else != nil {
+			walk(v, edge.IfStmt_Else, -1, n.Else)
+		}
+
+	case *ast.CaseClause:
+		walkList(v, edge.CaseClause_List, n.List)
+		walkList(v, edge.CaseClause_Body, n.Body)
+
+	case *ast.SwitchStmt:
+		if n.Init != nil {
+			walk(v, edge.SwitchStmt_Init, -1, n.Init)
+		}
+		if n.Tag != nil {
+			walk(v, edge.SwitchStmt_Tag, -1, n.Tag)
+		}
+		walk(v, edge.SwitchStmt_Body, -1, n.Body)
+
+	case *ast.TypeSwitchStmt:
+		if n.Init != nil {
+			walk(v, edge.TypeSwitchStmt_Init, -1, n.Init)
+		}
+		walk(v, edge.TypeSwitchStmt_Assign, -1, n.Assign)
+		walk(v, edge.TypeSwitchStmt_Body, -1, n.Body)
+
+	case *ast.CommClause:
+		if n.Comm != nil {
+			walk(v, edge.CommClause_Comm, -1, n.Comm)
+		}
+		walkList(v, edge.CommClause_Body, n.Body)
+
+	case *ast.SelectStmt:
+		walk(v, edge.SelectStmt_Body, -1, n.Body)
+
+	case *ast.ForStmt:
+		if n.Init != nil {
+			walk(v, edge.ForStmt_Init, -1, n.Init)
+		}
+		if n.Cond != nil {
+			walk(v, edge.ForStmt_Cond, -1, n.Cond)
+		}
+		if n.Post != nil {
+			walk(v, edge.ForStmt_Post, -1, n.Post)
+		}
+		walk(v, edge.ForStmt_Body, -1, n.Body)
+
+	case *ast.RangeStmt:
+		if n.Key != nil {
+			walk(v, edge.RangeStmt_Key, -1, n.Key)
+		}
+		if n.Value != nil {
+			walk(v, edge.RangeStmt_Value, -1, n.Value)
+		}
+		walk(v, edge.RangeStmt_X, -1, n.X)
+		walk(v, edge.RangeStmt_Body, -1, n.Body)
+
+	// Declarations
+	case *ast.ImportSpec:
+		if n.Doc != nil {
+			walk(v, edge.ImportSpec_Doc, -1, n.Doc)
+		}
+		if n.Name != nil {
+			walk(v, edge.ImportSpec_Name, -1, n.Name)
+		}
+		walk(v, edge.ImportSpec_Path, -1, n.Path)
+		if n.Comment != nil {
+			walk(v, edge.ImportSpec_Comment, -1, n.Comment)
+		}
+
+	case *ast.ValueSpec:
+		if n.Doc != nil {
+			walk(v, edge.ValueSpec_Doc, -1, n.Doc)
+		}
+		walkList(v, edge.ValueSpec_Names, n.Names)
+		if n.Type != nil {
+			walk(v, edge.ValueSpec_Type, -1, n.Type)
+		}
+		walkList(v, edge.ValueSpec_Values, n.Values)
+		if n.Comment != nil {
+			walk(v, edge.ValueSpec_Comment, -1, n.Comment)
+		}
+
+	case *ast.TypeSpec:
+		if n.Doc != nil {
+			walk(v, edge.TypeSpec_Doc, -1, n.Doc)
+		}
+		walk(v, edge.TypeSpec_Name, -1, n.Name)
+		if n.TypeParams != nil {
+			walk(v, edge.TypeSpec_TypeParams, -1, n.TypeParams)
+		}
+		walk(v, edge.TypeSpec_Type, -1, n.Type)
+		if n.Comment != nil {
+			walk(v, edge.TypeSpec_Comment, -1, n.Comment)
+		}
+
+	case *ast.BadDecl:
+		// nothing to do
+
+	case *ast.GenDecl:
+		if n.Doc != nil {
+			walk(v, edge.GenDecl_Doc, -1, n.Doc)
+		}
+		walkList(v, edge.GenDecl_Specs, n.Specs)
+
+	case *ast.FuncDecl:
+		if n.Doc != nil {
+			walk(v, edge.FuncDecl_Doc, -1, n.Doc)
+		}
+		if n.Recv != nil {
+			walk(v, edge.FuncDecl_Recv, -1, n.Recv)
+		}
+		walk(v, edge.FuncDecl_Name, -1, n.Name)
+		walk(v, edge.FuncDecl_Type, -1, n.Type)
+		if n.Body != nil {
+			walk(v, edge.FuncDecl_Body, -1, n.Body)
+		}
+
+	case *ast.File:
+		if n.Doc != nil {
+			walk(v, edge.File_Doc, -1, n.Doc)
+		}
+		walk(v, edge.File_Name, -1, n.Name)
+		walkList(v, edge.File_Decls, n.Decls)
+		// don't walk n.Comments - they have been
+		// visited already through the individual
+		// nodes
+
+	default:
+		// (includes *ast.Package)
+		panic(fmt.Sprintf("Walk: unexpected node type %T", n))
+	}
+
+	v.pop(node)
+}
diff --git a/vendor/golang.org/x/tools/go/packages/packages.go b/vendor/golang.org/x/tools/go/packages/packages.go
index 0147d9080..c3a59b8eb 100644
--- a/vendor/golang.org/x/tools/go/packages/packages.go
+++ b/vendor/golang.org/x/tools/go/packages/packages.go
@@ -59,10 +59,10 @@ import (
 //
 // Unfortunately there are a number of open bugs related to
 // interactions among the LoadMode bits:
-//   - https://github.com/golang/go/issues/56633
-//   - https://github.com/golang/go/issues/56677
-//   - https://github.com/golang/go/issues/58726
-//   - https://github.com/golang/go/issues/63517
+//   - https://go.dev/issue/56633
+//   - https://go.dev/issue/56677
+//   - https://go.dev/issue/58726
+//   - https://go.dev/issue/63517
 type LoadMode int
 
 const (
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map.go b/vendor/golang.org/x/tools/go/types/typeutil/map.go
index 93b3090c6..43261147c 100644
--- a/vendor/golang.org/x/tools/go/types/typeutil/map.go
+++ b/vendor/golang.org/x/tools/go/types/typeutil/map.go
@@ -257,10 +257,13 @@ func (h hasher) hash(t types.Type) uint32 {
 		}
 
 		tparams := t.TypeParams()
-		for i := range tparams.Len() {
-			h.inGenericSig = true
-			tparam := tparams.At(i)
-			hash += 7 * h.hash(tparam.Constraint())
+		if n := tparams.Len(); n > 0 {
+			h.inGenericSig = true // affects constraints, params, and results
+
+			for i := range n {
+				tparam := tparams.At(i)
+				hash += 7 * h.hash(tparam.Constraint())
+			}
 		}
 
 		return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results())
diff --git a/vendor/golang.org/x/tools/internal/astutil/edge/edge.go b/vendor/golang.org/x/tools/internal/astutil/edge/edge.go
new file mode 100644
index 000000000..4f6ccfd6e
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/astutil/edge/edge.go
@@ -0,0 +1,295 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package edge defines identifiers for each field of an ast.Node
+// struct type that refers to another Node.
+package edge
+
+import (
+	"fmt"
+	"go/ast"
+	"reflect"
+)
+
+// A Kind describes a field of an ast.Node struct.
+type Kind uint8
+
+// String returns a description of the edge kind.
+func (k Kind) String() string {
+	if k == Invalid {
+		return "<invalid>"
+	}
+	info := fieldInfos[k]
+	return fmt.Sprintf("%v.%s", info.nodeType.Elem().Name(), info.name)
+}
+
+// NodeType returns the pointer-to-struct type of the ast.Node implementation.
+func (k Kind) NodeType() reflect.Type { return fieldInfos[k].nodeType }
+
+// FieldName returns the name of the field.
+func (k Kind) FieldName() string { return fieldInfos[k].name }
+
+// FieldType returns the declared type of the field.
+func (k Kind) FieldType() reflect.Type { return fieldInfos[k].fieldType }
+
+// Get returns the direct child of n identified by (k, idx).
+// n's type must match k.NodeType().
+// idx must be a valid slice index, or -1 for a non-slice.
+func (k Kind) Get(n ast.Node, idx int) ast.Node {
+	if k.NodeType() != reflect.TypeOf(n) {
+		panic(fmt.Sprintf("%v.Get(%T): invalid node type", k, n))
+	}
+	v := reflect.ValueOf(n).Elem().Field(fieldInfos[k].index)
+	if idx != -1 {
+		v = v.Index(idx) // asserts valid index
+	} else {
+		// (The type assertion below asserts that v is not a slice.)
+	}
+	return v.Interface().(ast.Node) // may be nil
+}
+
+const (
+	Invalid Kind = iota // for nodes at the root of the traversal
+
+	// Kinds are sorted alphabetically.
+	// Numbering is not stable.
+	// Each is named Type_Field, where Type is the
+	// ast.Node struct type and Field is the name of the field
+
+	ArrayType_Elt
+	ArrayType_Len
+	AssignStmt_Lhs
+	AssignStmt_Rhs
+	BinaryExpr_X
+	BinaryExpr_Y
+	BlockStmt_List
+	BranchStmt_Label
+	CallExpr_Args
+	CallExpr_Fun
+	CaseClause_Body
+	CaseClause_List
+	ChanType_Value
+	CommClause_Body
+	CommClause_Comm
+	CommentGroup_List
+	CompositeLit_Elts
+	CompositeLit_Type
+	DeclStmt_Decl
+	DeferStmt_Call
+	Ellipsis_Elt
+	ExprStmt_X
+	FieldList_List
+	Field_Comment
+	Field_Doc
+	Field_Names
+	Field_Tag
+	Field_Type
+	File_Decls
+	File_Doc
+	File_Name
+	ForStmt_Body
+	ForStmt_Cond
+	ForStmt_Init
+	ForStmt_Post
+	FuncDecl_Body
+	FuncDecl_Doc
+	FuncDecl_Name
+	FuncDecl_Recv
+	FuncDecl_Type
+	FuncLit_Body
+	FuncLit_Type
+	FuncType_Params
+	FuncType_Results
+	FuncType_TypeParams
+	GenDecl_Doc
+	GenDecl_Specs
+	GoStmt_Call
+	IfStmt_Body
+	IfStmt_Cond
+	IfStmt_Else
+	IfStmt_Init
+	ImportSpec_Comment
+	ImportSpec_Doc
+	ImportSpec_Name
+	ImportSpec_Path
+	IncDecStmt_X
+	IndexExpr_Index
+	IndexExpr_X
+	IndexListExpr_Indices
+	IndexListExpr_X
+	InterfaceType_Methods
+	KeyValueExpr_Key
+	KeyValueExpr_Value
+	LabeledStmt_Label
+	LabeledStmt_Stmt
+	MapType_Key
+	MapType_Value
+	ParenExpr_X
+	RangeStmt_Body
+	RangeStmt_Key
+	RangeStmt_Value
+	RangeStmt_X
+	ReturnStmt_Results
+	SelectStmt_Body
+	SelectorExpr_Sel
+	SelectorExpr_X
+	SendStmt_Chan
+	SendStmt_Value
+	SliceExpr_High
+	SliceExpr_Low
+	SliceExpr_Max
+	SliceExpr_X
+	StarExpr_X
+	StructType_Fields
+	SwitchStmt_Body
+	SwitchStmt_Init
+	SwitchStmt_Tag
+	TypeAssertExpr_Type
+	TypeAssertExpr_X
+	TypeSpec_Comment
+	TypeSpec_Doc
+	TypeSpec_Name
+	TypeSpec_Type
+	TypeSpec_TypeParams
+	TypeSwitchStmt_Assign
+	TypeSwitchStmt_Body
+	TypeSwitchStmt_Init
+	UnaryExpr_X
+	ValueSpec_Comment
+	ValueSpec_Doc
+	ValueSpec_Names
+	ValueSpec_Type
+	ValueSpec_Values
+
+	maxKind
+)
+
+// Assert that the encoding fits in 7 bits,
+// as the inspector relies on this.
+// (We are currently at 104.)
+var _ = [1 << 7]struct{}{}[maxKind]
+
+type fieldInfo struct {
+	nodeType  reflect.Type // pointer-to-struct type of ast.Node implementation
+	name      string
+	index     int
+	fieldType reflect.Type
+}
+
+func info[N ast.Node](fieldName string) fieldInfo {
+	nodePtrType := reflect.TypeFor[N]()
+	f, ok := nodePtrType.Elem().FieldByName(fieldName)
+	if !ok {
+		panic(fieldName)
+	}
+	return fieldInfo{nodePtrType, fieldName, f.Index[0], f.Type}
+}
+
+var fieldInfos = [...]fieldInfo{
+	Invalid:               {},
+	ArrayType_Elt:         info[*ast.ArrayType]("Elt"),
+	ArrayType_Len:         info[*ast.ArrayType]("Len"),
+	AssignStmt_Lhs:        info[*ast.AssignStmt]("Lhs"),
+	AssignStmt_Rhs:        info[*ast.AssignStmt]("Rhs"),
+	BinaryExpr_X:          info[*ast.BinaryExpr]("X"),
+	BinaryExpr_Y:          info[*ast.BinaryExpr]("Y"),
+	BlockStmt_List:        info[*ast.BlockStmt]("List"),
+	BranchStmt_Label:      info[*ast.BranchStmt]("Label"),
+	CallExpr_Args:         info[*ast.CallExpr]("Args"),
+	CallExpr_Fun:          info[*ast.CallExpr]("Fun"),
+	CaseClause_Body:       info[*ast.CaseClause]("Body"),
+	CaseClause_List:       info[*ast.CaseClause]("List"),
+	ChanType_Value:        info[*ast.ChanType]("Value"),
+	CommClause_Body:       info[*ast.CommClause]("Body"),
+	CommClause_Comm:       info[*ast.CommClause]("Comm"),
+	CommentGroup_List:     info[*ast.CommentGroup]("List"),
+	CompositeLit_Elts:     info[*ast.CompositeLit]("Elts"),
+	CompositeLit_Type:     info[*ast.CompositeLit]("Type"),
+	DeclStmt_Decl:         info[*ast.DeclStmt]("Decl"),
+	DeferStmt_Call:        info[*ast.DeferStmt]("Call"),
+	Ellipsis_Elt:          info[*ast.Ellipsis]("Elt"),
+	ExprStmt_X:            info[*ast.ExprStmt]("X"),
+	FieldList_List:        info[*ast.FieldList]("List"),
+	Field_Comment:         info[*ast.Field]("Comment"),
+	Field_Doc:             info[*ast.Field]("Doc"),
+	Field_Names:           info[*ast.Field]("Names"),
+	Field_Tag:             info[*ast.Field]("Tag"),
+	Field_Type:            info[*ast.Field]("Type"),
+	File_Decls:            info[*ast.File]("Decls"),
+	File_Doc:              info[*ast.File]("Doc"),
+	File_Name:             info[*ast.File]("Name"),
+	ForStmt_Body:          info[*ast.ForStmt]("Body"),
+	ForStmt_Cond:          info[*ast.ForStmt]("Cond"),
+	ForStmt_Init:          info[*ast.ForStmt]("Init"),
+	ForStmt_Post:          info[*ast.ForStmt]("Post"),
+	FuncDecl_Body:         info[*ast.FuncDecl]("Body"),
+	FuncDecl_Doc:          info[*ast.FuncDecl]("Doc"),
+	FuncDecl_Name:         info[*ast.FuncDecl]("Name"),
+	FuncDecl_Recv:         info[*ast.FuncDecl]("Recv"),
+	FuncDecl_Type:         info[*ast.FuncDecl]("Type"),
+	FuncLit_Body:          info[*ast.FuncLit]("Body"),
+	FuncLit_Type:          info[*ast.FuncLit]("Type"),
+	FuncType_Params:       info[*ast.FuncType]("Params"),
+	FuncType_Results:      info[*ast.FuncType]("Results"),
+	FuncType_TypeParams:   info[*ast.FuncType]("TypeParams"),
+	GenDecl_Doc:           info[*ast.GenDecl]("Doc"),
+	GenDecl_Specs:         info[*ast.GenDecl]("Specs"),
+	GoStmt_Call:           info[*ast.GoStmt]("Call"),
+	IfStmt_Body:           info[*ast.IfStmt]("Body"),
+	IfStmt_Cond:           info[*ast.IfStmt]("Cond"),
+	IfStmt_Else:           info[*ast.IfStmt]("Else"),
+	IfStmt_Init:           info[*ast.IfStmt]("Init"),
+	ImportSpec_Comment:    info[*ast.ImportSpec]("Comment"),
+	ImportSpec_Doc:        info[*ast.ImportSpec]("Doc"),
+	ImportSpec_Name:       info[*ast.ImportSpec]("Name"),
+	ImportSpec_Path:       info[*ast.ImportSpec]("Path"),
+	IncDecStmt_X:          info[*ast.IncDecStmt]("X"),
+	IndexExpr_Index:       info[*ast.IndexExpr]("Index"),
+	IndexExpr_X:           info[*ast.IndexExpr]("X"),
+	IndexListExpr_Indices: info[*ast.IndexListExpr]("Indices"),
+	IndexListExpr_X:       info[*ast.IndexListExpr]("X"),
+	InterfaceType_Methods: info[*ast.InterfaceType]("Methods"),
+	KeyValueExpr_Key:      info[*ast.KeyValueExpr]("Key"),
+	KeyValueExpr_Value:    info[*ast.KeyValueExpr]("Value"),
+	LabeledStmt_Label:     info[*ast.LabeledStmt]("Label"),
+	LabeledStmt_Stmt:      info[*ast.LabeledStmt]("Stmt"),
+	MapType_Key:           info[*ast.MapType]("Key"),
+	MapType_Value:         info[*ast.MapType]("Value"),
+	ParenExpr_X:           info[*ast.ParenExpr]("X"),
+	RangeStmt_Body:        info[*ast.RangeStmt]("Body"),
+	RangeStmt_Key:         info[*ast.RangeStmt]("Key"),
+	RangeStmt_Value:       info[*ast.RangeStmt]("Value"),
+	RangeStmt_X:           info[*ast.RangeStmt]("X"),
+	ReturnStmt_Results:    info[*ast.ReturnStmt]("Results"),
+	SelectStmt_Body:       info[*ast.SelectStmt]("Body"),
+	SelectorExpr_Sel:      info[*ast.SelectorExpr]("Sel"),
+	SelectorExpr_X:        info[*ast.SelectorExpr]("X"),
+	SendStmt_Chan:         info[*ast.SendStmt]("Chan"),
+	SendStmt_Value:        info[*ast.SendStmt]("Value"),
+	SliceExpr_High:        info[*ast.SliceExpr]("High"),
+	SliceExpr_Low:         info[*ast.SliceExpr]("Low"),
+	SliceExpr_Max:         info[*ast.SliceExpr]("Max"),
+	SliceExpr_X:           info[*ast.SliceExpr]("X"),
+	StarExpr_X:            info[*ast.StarExpr]("X"),
+	StructType_Fields:     info[*ast.StructType]("Fields"),
+	SwitchStmt_Body:       info[*ast.SwitchStmt]("Body"),
+	SwitchStmt_Init:       info[*ast.SwitchStmt]("Init"),
+	SwitchStmt_Tag:        info[*ast.SwitchStmt]("Tag"),
+	TypeAssertExpr_Type:   info[*ast.TypeAssertExpr]("Type"),
+	TypeAssertExpr_X:      info[*ast.TypeAssertExpr]("X"),
+	TypeSpec_Comment:      info[*ast.TypeSpec]("Comment"),
+	TypeSpec_Doc:          info[*ast.TypeSpec]("Doc"),
+	TypeSpec_Name:         info[*ast.TypeSpec]("Name"),
+	TypeSpec_Type:         info[*ast.TypeSpec]("Type"),
+	TypeSpec_TypeParams:   info[*ast.TypeSpec]("TypeParams"),
+	TypeSwitchStmt_Assign: info[*ast.TypeSwitchStmt]("Assign"),
+	TypeSwitchStmt_Body:   info[*ast.TypeSwitchStmt]("Body"),
+	TypeSwitchStmt_Init:   info[*ast.TypeSwitchStmt]("Init"),
+	UnaryExpr_X:           info[*ast.UnaryExpr]("X"),
+	ValueSpec_Comment:     info[*ast.ValueSpec]("Comment"),
+	ValueSpec_Doc:         info[*ast.ValueSpec]("Doc"),
+	ValueSpec_Names:       info[*ast.ValueSpec]("Names"),
+	ValueSpec_Type:        info[*ast.ValueSpec]("Type"),
+	ValueSpec_Values:      info[*ast.ValueSpec]("Values"),
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
index 69b1d697c..129439271 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
@@ -671,7 +671,9 @@ func (r *importReader) obj(name string) {
 	case varTag:
 		typ := r.typ()
 
-		r.declare(types.NewVar(pos, r.currPkg, name, typ))
+		v := types.NewVar(pos, r.currPkg, name, typ)
+		typesinternal.SetVarKind(v, typesinternal.PackageVar)
+		r.declare(v)
 
 	default:
 		errorf("unexpected tag: %v", tag)
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
index 6cdab448e..522287d18 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
@@ -14,6 +14,7 @@ import (
 
 	"golang.org/x/tools/internal/aliases"
 	"golang.org/x/tools/internal/pkgbits"
+	"golang.org/x/tools/internal/typesinternal"
 )
 
 // A pkgReader holds the shared state for reading a unified IR package
@@ -572,6 +573,7 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 						sig := fn.Type().(*types.Signature)
 
 						recv := types.NewVar(fn.Pos(), fn.Pkg(), "", named)
+						typesinternal.SetVarKind(recv, typesinternal.RecvVar)
 						methods[i] = types.NewFunc(fn.Pos(), fn.Pkg(), fn.Name(), types.NewSignature(recv, sig.Params(), sig.Results(), sig.Variadic()))
 					}
 
@@ -619,7 +621,9 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 		case pkgbits.ObjVar:
 			pos := r.pos()
 			typ := r.typ()
-			declare(types.NewVar(pos, objPkg, objName, typ))
+			v := types.NewVar(pos, objPkg, objName, typ)
+			typesinternal.SetVarKind(v, typesinternal.PackageVar)
+			declare(v)
 		}
 	}
 
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke.go b/vendor/golang.org/x/tools/internal/gocommand/invoke.go
index e333efc87..7ea901344 100644
--- a/vendor/golang.org/x/tools/internal/gocommand/invoke.go
+++ b/vendor/golang.org/x/tools/internal/gocommand/invoke.go
@@ -28,7 +28,7 @@ import (
 	"golang.org/x/tools/internal/event/label"
 )
 
-// An Runner will run go command invocations and serialize
+// A Runner will run go command invocations and serialize
 // them if it sees a concurrency error.
 type Runner struct {
 	// once guards the runner initialization.
@@ -179,7 +179,7 @@ type Invocation struct {
 	CleanEnv   bool
 	Env        []string
 	WorkingDir string
-	Logf       func(format string, args ...interface{})
+	Logf       func(format string, args ...any)
 }
 
 // Postcondition: both error results have same nilness.
@@ -388,7 +388,9 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
 		case err := <-resChan:
 			return err
 		case <-timer.C:
-			HandleHangingGoCommand(startTime, cmd)
+			// HandleHangingGoCommand terminates this process.
+			// Pass off resChan in case we can collect the command error.
+			handleHangingGoCommand(startTime, cmd, resChan)
 		case <-ctx.Done():
 		}
 	} else {
@@ -413,8 +415,6 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
 	}
 
 	// Didn't shut down in response to interrupt. Kill it hard.
-	// TODO(rfindley): per advice from bcmills@, it may be better to send SIGQUIT
-	// on certain platforms, such as unix.
 	if err := cmd.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) && debug {
 		log.Printf("error killing the Go command: %v", err)
 	}
@@ -422,15 +422,17 @@ func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
 	return <-resChan
 }
 
-func HandleHangingGoCommand(start time.Time, cmd *exec.Cmd) {
+// handleHangingGoCommand outputs debugging information to help diagnose the
+// cause of a hanging Go command, and then exits with log.Fatalf.
+func handleHangingGoCommand(start time.Time, cmd *exec.Cmd, resChan chan error) {
 	switch runtime.GOOS {
-	case "linux", "darwin", "freebsd", "netbsd":
+	case "linux", "darwin", "freebsd", "netbsd", "openbsd":
 		fmt.Fprintln(os.Stderr, `DETECTED A HANGING GO COMMAND
 
-The gopls test runner has detected a hanging go command. In order to debug
-this, the output of ps and lsof/fstat is printed below.
+			The gopls test runner has detected a hanging go command. In order to debug
+			this, the output of ps and lsof/fstat is printed below.
 
-See golang/go#54461 for more details.`)
+			See golang/go#54461 for more details.`)
 
 		fmt.Fprintln(os.Stderr, "\nps axo ppid,pid,command:")
 		fmt.Fprintln(os.Stderr, "-------------------------")
@@ -438,7 +440,7 @@ See golang/go#54461 for more details.`)
 		psCmd.Stdout = os.Stderr
 		psCmd.Stderr = os.Stderr
 		if err := psCmd.Run(); err != nil {
-			panic(fmt.Sprintf("running ps: %v", err))
+			log.Printf("Handling hanging Go command: running ps: %v", err)
 		}
 
 		listFiles := "lsof"
@@ -452,10 +454,24 @@ See golang/go#54461 for more details.`)
 		listFilesCmd.Stdout = os.Stderr
 		listFilesCmd.Stderr = os.Stderr
 		if err := listFilesCmd.Run(); err != nil {
-			panic(fmt.Sprintf("running %s: %v", listFiles, err))
+			log.Printf("Handling hanging Go command: running %s: %v", listFiles, err)
+		}
+		// Try to extract information about the slow go process by issuing a SIGQUIT.
+		if err := cmd.Process.Signal(sigStuckProcess); err == nil {
+			select {
+			case err := <-resChan:
+				stderr := "not a bytes.Buffer"
+				if buf, _ := cmd.Stderr.(*bytes.Buffer); buf != nil {
+					stderr = buf.String()
+				}
+				log.Printf("Quit hanging go command:\n\terr:%v\n\tstderr:\n%v\n\n", err, stderr)
+			case <-time.After(5 * time.Second):
+			}
+		} else {
+			log.Printf("Sending signal %d to hanging go command: %v", sigStuckProcess, err)
 		}
 	}
-	panic(fmt.Sprintf("detected hanging go command (golang/go#54461); waited %s\n\tcommand:%s\n\tpid:%d", time.Since(start), cmd, cmd.Process.Pid))
+	log.Fatalf("detected hanging go command (golang/go#54461); waited %s\n\tcommand:%s\n\tpid:%d", time.Since(start), cmd, cmd.Process.Pid)
 }
 
 func cmdDebugStr(cmd *exec.Cmd) string {
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go b/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go
new file mode 100644
index 000000000..469c648e4
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go
@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !unix
+
+package gocommand
+
+import "os"
+
+// sigStuckProcess is the signal to send to kill a hanging subprocess.
+// On Unix we send SIGQUIT, but on non-Unix we only have os.Kill.
+var sigStuckProcess = os.Kill
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go b/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go
new file mode 100644
index 000000000..169d37c8e
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go
@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build unix
+
+package gocommand
+
+import "syscall"
+
+// Sigstuckprocess is the signal to send to kill a hanging subprocess.
+// Send SIGQUIT to get a stack trace.
+var sigStuckProcess = syscall.SIGQUIT
diff --git a/vendor/golang.org/x/tools/internal/imports/fix.go b/vendor/golang.org/x/tools/internal/imports/fix.go
index 5ae576977..bf6b0aadd 100644
--- a/vendor/golang.org/x/tools/internal/imports/fix.go
+++ b/vendor/golang.org/x/tools/internal/imports/fix.go
@@ -780,7 +780,7 @@ func GetAllCandidates(ctx context.Context, wrapped func(ImportFix), searchPrefix
 			return true
 		},
 		dirFound: func(pkg *pkg) bool {
-			if !canUse(filename, pkg.dir) {
+			if !CanUse(filename, pkg.dir) {
 				return false
 			}
 			// Try the assumed package name first, then a simpler path match
@@ -815,7 +815,7 @@ func GetImportPaths(ctx context.Context, wrapped func(ImportFix), searchPrefix,
 			return true
 		},
 		dirFound: func(pkg *pkg) bool {
-			if !canUse(filename, pkg.dir) {
+			if !CanUse(filename, pkg.dir) {
 				return false
 			}
 			return strings.HasPrefix(pkg.importPathShort, searchPrefix)
@@ -927,7 +927,7 @@ type ProcessEnv struct {
 	WorkingDir string
 
 	// If Logf is non-nil, debug logging is enabled through this function.
-	Logf func(format string, args ...interface{})
+	Logf func(format string, args ...any)
 
 	// If set, ModCache holds a shared cache of directory info to use across
 	// multiple ProcessEnvs.
@@ -1132,6 +1132,9 @@ func addStdlibCandidates(pass *pass, refs References) error {
 			// but we have no way of figuring out what the user is using
 			// TODO: investigate using the toolchain version to disambiguate in the stdlib
 			add("math/rand/v2")
+			// math/rand has an overlapping API
+			// TestIssue66407 fails without this
+			add("math/rand")
 			continue
 		}
 		for importPath := range stdlib.PackageSymbols {
@@ -1736,7 +1739,7 @@ func (s *symbolSearcher) searchOne(ctx context.Context, c pkgDistance, symbols m
 // searching for "client.New")
 func pkgIsCandidate(filename string, refs References, pkg *pkg) bool {
 	// Check "internal" and "vendor" visibility:
-	if !canUse(filename, pkg.dir) {
+	if !CanUse(filename, pkg.dir) {
 		return false
 	}
 
@@ -1759,9 +1762,9 @@ func pkgIsCandidate(filename string, refs References, pkg *pkg) bool {
 	return false
 }
 
-// canUse reports whether the package in dir is usable from filename,
+// CanUse reports whether the package in dir is usable from filename,
 // respecting the Go "internal" and "vendor" visibility rules.
-func canUse(filename, dir string) bool {
+func CanUse(filename, dir string) bool {
 	// Fast path check, before any allocations. If it doesn't contain vendor
 	// or internal, it's not tricky:
 	// Note that this can false-negative on directories like "notinternal",
diff --git a/vendor/golang.org/x/tools/internal/imports/source_env.go b/vendor/golang.org/x/tools/internal/imports/source_env.go
index d14abaa31..ec996c3cc 100644
--- a/vendor/golang.org/x/tools/internal/imports/source_env.go
+++ b/vendor/golang.org/x/tools/internal/imports/source_env.go
@@ -67,7 +67,7 @@ func (s *ProcessEnvSource) ResolveReferences(ctx context.Context, filename strin
 				// same package name. Don't try to import ourselves.
 				return false
 			}
-			if !canUse(filename, pkg.dir) {
+			if !CanUse(filename, pkg.dir) {
 				return false
 			}
 			mu.Lock()
diff --git a/vendor/golang.org/x/tools/internal/modindex/lookup.go b/vendor/golang.org/x/tools/internal/modindex/lookup.go
index 012fdd713..5499c5c67 100644
--- a/vendor/golang.org/x/tools/internal/modindex/lookup.go
+++ b/vendor/golang.org/x/tools/internal/modindex/lookup.go
@@ -35,6 +35,36 @@ const (
 	Func
 )
 
+// LookupAll only returns those Candidates whose import path
+// finds all the nms.
+func (ix *Index) LookupAll(pkg string, names ...string) map[string][]Candidate {
+	// this can be made faster when benchmarks show that it needs to be
+	names = uniquify(names)
+	byImpPath := make(map[string][]Candidate)
+	for _, nm := range names {
+		cands := ix.Lookup(pkg, nm, false)
+		for _, c := range cands {
+			byImpPath[c.ImportPath] = append(byImpPath[c.ImportPath], c)
+		}
+	}
+	for k, v := range byImpPath {
+		if len(v) != len(names) {
+			delete(byImpPath, k)
+		}
+	}
+	return byImpPath
+}
+
+// remove duplicates
+func uniquify(in []string) []string {
+	if len(in) == 0 {
+		return in
+	}
+	in = slices.Clone(in)
+	slices.Sort(in)
+	return slices.Compact(in)
+}
+
 // Lookup finds all the symbols in the index with the given PkgName and name.
 // If prefix is true, it finds all of these with name as a prefix.
 func (ix *Index) Lookup(pkg, name string, prefix bool) []Candidate {
diff --git a/vendor/golang.org/x/tools/internal/modindex/symbols.go b/vendor/golang.org/x/tools/internal/modindex/symbols.go
index 33bf2641f..b918529d4 100644
--- a/vendor/golang.org/x/tools/internal/modindex/symbols.go
+++ b/vendor/golang.org/x/tools/internal/modindex/symbols.go
@@ -12,6 +12,7 @@ import (
 	"go/types"
 	"os"
 	"path/filepath"
+	"runtime"
 	"slices"
 	"strings"
 
@@ -29,14 +30,14 @@ import (
 type symbol struct {
 	pkg  string // name of the symbols's package
 	name string // declared name
-	kind string // T, C, V, or F
+	kind string // T, C, V, or F, follwed by D if deprecated
 	sig  string // signature information, for F
 }
 
 // find the symbols for the best directories
 func getSymbols(cd Abspath, dirs map[string][]*directory) {
 	var g errgroup.Group
-	g.SetLimit(-1) // maybe throttle this some day
+	g.SetLimit(max(2, runtime.GOMAXPROCS(0)/2))
 	for _, vv := range dirs {
 		// throttling some day?
 		d := vv[0]
@@ -111,7 +112,7 @@ func getFileExports(f *ast.File) []symbol {
 				// print struct tags. So for this to happen the type of a formal parameter
 				// has to be a explict struct, e.g. foo(x struct{a int "$"}) and ExprString
 				// would have to show the struct tag. Even testing for this case seems
-				// a waste of effort, but let's not ignore such pathologies
+				// a waste of effort, but let's remember the possibility
 				if strings.Contains(tp, "$") {
 					continue
 				}
diff --git a/vendor/golang.org/x/tools/internal/packagesinternal/packages.go b/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
index 66e69b438..784605914 100644
--- a/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
+++ b/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
@@ -5,7 +5,7 @@
 // Package packagesinternal exposes internal-only fields from go/packages.
 package packagesinternal
 
-var GetDepsErrors = func(p interface{}) []*PackageError { return nil }
+var GetDepsErrors = func(p any) []*PackageError { return nil }
 
 type PackageError struct {
 	ImportStack []string // shortest path from package named on command line to this one
@@ -16,5 +16,5 @@ type PackageError struct {
 var TypecheckCgo int
 var DepsErrors int // must be set as a LoadMode to call GetDepsErrors
 
-var SetModFlag = func(config interface{}, value string) {}
+var SetModFlag = func(config any, value string) {}
 var SetModFile = func(config interface{}, value string) {}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/coretype.go b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
index 6e83c6fb1..27a2b1792 100644
--- a/vendor/golang.org/x/tools/internal/typeparams/coretype.go
+++ b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
@@ -109,8 +109,13 @@ func CoreType(T types.Type) types.Type {
 //
 // NormalTerms makes no guarantees about the order of terms, except that it
 // is deterministic.
-func NormalTerms(typ types.Type) ([]*types.Term, error) {
-	switch typ := typ.Underlying().(type) {
+func NormalTerms(T types.Type) ([]*types.Term, error) {
+	// typeSetOf(T) == typeSetOf(Unalias(T))
+	typ := types.Unalias(T)
+	if named, ok := typ.(*types.Named); ok {
+		typ = named.Underlying()
+	}
+	switch typ := typ.(type) {
 	case *types.TypeParam:
 		return StructuralTerms(typ)
 	case *types.Union:
@@ -118,7 +123,7 @@ func NormalTerms(typ types.Type) ([]*types.Term, error) {
 	case *types.Interface:
 		return InterfaceTermSet(typ)
 	default:
-		return []*types.Term{types.NewTerm(false, typ)}, nil
+		return []*types.Term{types.NewTerm(false, T)}, nil
 	}
 }
 
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go b/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
index 131caab28..235a6defc 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
@@ -966,7 +966,7 @@ const (
 	//  var _ = string(x)
 	InvalidConversion
 
-	// InvalidUntypedConversion occurs when an there is no valid implicit
+	// InvalidUntypedConversion occurs when there is no valid implicit
 	// conversion from an untyped value satisfying the type constraints of the
 	// context in which it is used.
 	//
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/recv.go b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
index e54accc69..8352ea761 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/recv.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
@@ -12,7 +12,8 @@ import (
 // type of recv, which may be of the form N or *N, or aliases thereof.
 // It also reports whether a Pointer was present.
 //
-// The named result may be nil in ill-typed code.
+// The named result may be nil if recv is from a method on an
+// anonymous interface or struct types or in ill-typed code.
 func ReceiverNamed(recv *types.Var) (isPtr bool, named *types.Named) {
 	t := recv.Type()
 	if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/types.go b/vendor/golang.org/x/tools/internal/typesinternal/types.go
index a93d51f98..345348796 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/types.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/types.go
@@ -120,3 +120,8 @@ func Origin(t NamedOrAlias) NamedOrAlias {
 	}
 	return t
 }
+
+// IsPackageLevel reports whether obj is a package-level symbol.
+func IsPackageLevel(obj types.Object) bool {
+	return obj.Pkg() != nil && obj.Parent() == obj.Pkg().Scope()
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go b/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
new file mode 100644
index 000000000..e5da04951
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
@@ -0,0 +1,40 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+// TODO(adonovan): when CL 645115 lands, define the go1.25 version of
+// this API that actually does something.
+
+import "go/types"
+
+type VarKind uint8
+
+const (
+	_          VarKind = iota // (not meaningful)
+	PackageVar                // a package-level variable
+	LocalVar                  // a local variable
+	RecvVar                   // a method receiver variable
+	ParamVar                  // a function parameter variable
+	ResultVar                 // a function result variable
+	FieldVar                  // a struct field
+)
+
+func (kind VarKind) String() string {
+	return [...]string{
+		0:          "VarKind(0)",
+		PackageVar: "PackageVar",
+		LocalVar:   "LocalVar",
+		RecvVar:    "RecvVar",
+		ParamVar:   "ParamVar",
+		ResultVar:  "ResultVar",
+		FieldVar:   "FieldVar",
+	}[kind]
+}
+
+// GetVarKind returns an invalid VarKind.
+func GetVarKind(v *types.Var) VarKind { return 0 }
+
+// SetVarKind has no effect.
+func SetVarKind(v *types.Var, kind VarKind) {}
diff --git a/vendor/gomodules.xyz/jsonpatch/v2/jsonpatch.go b/vendor/gomodules.xyz/jsonpatch/v2/jsonpatch.go
index 0d7823b3c..d88162ff5 100644
--- a/vendor/gomodules.xyz/jsonpatch/v2/jsonpatch.go
+++ b/vendor/gomodules.xyz/jsonpatch/v2/jsonpatch.go
@@ -70,12 +70,14 @@ func CreatePatch(a, b []byte) ([]Operation, error) {
 	}
 	var aI interface{}
 	var bI interface{}
-	err := json.Unmarshal(a, &aI)
-	if err != nil {
+	aDec := json.NewDecoder(bytes.NewReader(a))
+	aDec.UseNumber()
+	if err := aDec.Decode(&aI); err != nil {
 		return nil, errBadJSONDoc
 	}
-	err = json.Unmarshal(b, &bI)
-	if err != nil {
+	bDec := json.NewDecoder(bytes.NewReader(b))
+	bDec.UseNumber()
+	if err := bDec.Decode(&bI); err != nil {
 		return nil, errBadJSONDoc
 	}
 	return handleValues(aI, bI, "", []Operation{})
@@ -94,6 +96,11 @@ func matchesValue(av, bv interface{}) bool {
 		if ok && bt == at {
 			return true
 		}
+	case json.Number:
+		bt, ok := bv.(json.Number)
+		if ok && bt == at {
+			return true
+		}
 	case float64:
 		bt, ok := bv.(float64)
 		if ok && bt == at {
@@ -212,7 +219,7 @@ func handleValues(av, bv interface{}, p string, patch []Operation) ([]Operation,
 		if err != nil {
 			return nil, err
 		}
-	case string, float64, bool:
+	case string, float64, bool, json.Number:
 		if !matchesValue(av, bv) {
 			patch = append(patch, NewOperation("replace", p, bv))
 		}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index cb815efb6..954d9a1dd 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -236,8 +236,8 @@ github.com/munnerz/goautoneg
 # github.com/mxk/go-flowrate v0.0.0-20140419014527-cca7078d478f
 ## explicit
 github.com/mxk/go-flowrate/flowrate
-# github.com/onsi/ginkgo/v2 v2.22.2
-## explicit; go 1.22.0
+# github.com/onsi/ginkgo/v2 v2.23.0
+## explicit; go 1.23.0
 github.com/onsi/ginkgo/v2
 github.com/onsi/ginkgo/v2/config
 github.com/onsi/ginkgo/v2/formatter
@@ -287,7 +287,7 @@ github.com/pkg/errors
 ## explicit; go 1.23.0
 github.com/project-codeflare/appwrapper/api/v1beta2
 github.com/project-codeflare/appwrapper/pkg/utils
-# github.com/prometheus/client_golang v1.21.0
+# github.com/prometheus/client_golang v1.21.1
 ## explicit; go 1.21
 github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil
 github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil/header
@@ -437,7 +437,7 @@ go.uber.org/zap/internal/pool
 go.uber.org/zap/internal/stacktrace
 go.uber.org/zap/zapcore
 go.uber.org/zap/zapgrpc
-# golang.org/x/crypto v0.32.0
+# golang.org/x/crypto v0.33.0
 ## explicit; go 1.20
 golang.org/x/crypto/cryptobyte
 golang.org/x/crypto/cryptobyte/asn1
@@ -451,12 +451,12 @@ golang.org/x/crypto/salsa20/salsa
 golang.org/x/exp/constraints
 golang.org/x/exp/maps
 golang.org/x/exp/slices
-# golang.org/x/mod v0.22.0
+# golang.org/x/mod v0.23.0
 ## explicit; go 1.22.0
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/module
 golang.org/x/mod/semver
-# golang.org/x/net v0.34.0
+# golang.org/x/net v0.35.0
 ## explicit; go 1.18
 golang.org/x/net/context
 golang.org/x/net/html
@@ -466,6 +466,7 @@ golang.org/x/net/http/httpguts
 golang.org/x/net/http2
 golang.org/x/net/http2/hpack
 golang.org/x/net/idna
+golang.org/x/net/internal/httpcommon
 golang.org/x/net/internal/socks
 golang.org/x/net/internal/timeseries
 golang.org/x/net/proxy
@@ -475,21 +476,21 @@ golang.org/x/net/websocket
 ## explicit; go 1.18
 golang.org/x/oauth2
 golang.org/x/oauth2/internal
-# golang.org/x/sync v0.10.0
+# golang.org/x/sync v0.11.0
 ## explicit; go 1.18
 golang.org/x/sync/errgroup
 golang.org/x/sync/singleflight
-# golang.org/x/sys v0.29.0
+# golang.org/x/sys v0.30.0
 ## explicit; go 1.18
 golang.org/x/sys/cpu
 golang.org/x/sys/plan9
 golang.org/x/sys/unix
 golang.org/x/sys/windows
 golang.org/x/sys/windows/registry
-# golang.org/x/term v0.28.0
+# golang.org/x/term v0.29.0
 ## explicit; go 1.18
 golang.org/x/term
-# golang.org/x/text v0.21.0
+# golang.org/x/text v0.22.0
 ## explicit; go 1.18
 golang.org/x/text/cases
 golang.org/x/text/encoding
@@ -523,7 +524,7 @@ golang.org/x/text/unicode/norm
 # golang.org/x/time v0.7.0
 ## explicit; go 1.18
 golang.org/x/time/rate
-# golang.org/x/tools v0.29.0
+# golang.org/x/tools v0.30.0
 ## explicit; go 1.22.0
 golang.org/x/tools/cover
 golang.org/x/tools/go/ast/astutil
@@ -534,6 +535,7 @@ golang.org/x/tools/go/types/objectpath
 golang.org/x/tools/go/types/typeutil
 golang.org/x/tools/imports
 golang.org/x/tools/internal/aliases
+golang.org/x/tools/internal/astutil/edge
 golang.org/x/tools/internal/event
 golang.org/x/tools/internal/event/core
 golang.org/x/tools/internal/event/keys
@@ -549,7 +551,7 @@ golang.org/x/tools/internal/stdlib
 golang.org/x/tools/internal/typeparams
 golang.org/x/tools/internal/typesinternal
 golang.org/x/tools/internal/versions
-# gomodules.xyz/jsonpatch/v2 v2.4.0
+# gomodules.xyz/jsonpatch/v2 v2.5.0
 ## explicit; go 1.20
 gomodules.xyz/jsonpatch/v2
 # google.golang.org/genproto v0.0.0-20240528184218-531527333157
@@ -1650,7 +1652,7 @@ sigs.k8s.io/kustomize/kyaml/yaml/walk
 # sigs.k8s.io/lws v0.5.1
 ## explicit; go 1.23.0
 sigs.k8s.io/lws/api/leaderworkerset/v1
-# sigs.k8s.io/structured-merge-diff/v4 v4.5.0
+# sigs.k8s.io/structured-merge-diff/v4 v4.6.0
 ## explicit; go 1.13
 sigs.k8s.io/structured-merge-diff/v4/fieldpath
 sigs.k8s.io/structured-merge-diff/v4/merge



Test patch:
diff --git a/pkg/cache/cache_test.go b/pkg/cache/cache_test.go
index a1540fc5a..cbdf50ced 100644
--- a/pkg/cache/cache_test.go
+++ b/pkg/cache/cache_test.go
@@ -97,8 +97,8 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 		name                string
 		operation           func(*Cache) error
 		clientObjects       []client.Object
-		wantClusterQueues   map[string]*clusterQueue
-		wantCohorts         map[string]sets.Set[string]
+		wantClusterQueues   map[kueue.ClusterQueueReference]*clusterQueue
+		wantCohorts         map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]
 		disableLendingLimit bool
 	}{
 		{
@@ -106,7 +106,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 			operation: func(cache *Cache) error {
 				return setup(cache)
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"a": {
 					Name:                          "a",
 					AllocatableResourceGeneration: 2,
@@ -165,9 +165,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("a", "b"),
-				"two": sets.New("c", "e", "f"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"one": sets.New[kueue.ClusterQueueReference]("a", "b"),
+				"two": sets.New[kueue.ClusterQueueReference]("c", "e", "f"),
 			},
 		},
 		{
@@ -182,7 +182,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					AllocatableResourceGeneration: 1,
@@ -206,7 +206,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					AllocatableResourceGeneration: 1,
@@ -232,7 +232,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 						Obj())
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"a": {
 					Name:                          "a",
 					AllocatableResourceGeneration: 2,
@@ -291,9 +291,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("a", "b"),
-				"two": sets.New("c", "e", "f"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"one": sets.New[kueue.ClusterQueueReference]("a", "b"),
+				"two": sets.New[kueue.ClusterQueueReference]("c", "e", "f"),
 			},
 		},
 		{
@@ -333,7 +333,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 						Obj())
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"a": {
 					Name:                          "a",
 					AllocatableResourceGeneration: 4,
@@ -392,9 +392,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("b"),
-				"two": sets.New("a", "c", "e", "f"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"one": sets.New[kueue.ClusterQueueReference]("b"),
+				"two": sets.New[kueue.ClusterQueueReference]("a", "c", "e", "f"),
 			},
 		},
 		{
@@ -439,7 +439,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"a": {
 					Name:                          "a",
 					AllocatableResourceGeneration: 2,
@@ -478,8 +478,8 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					},
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("a"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"one": sets.New[kueue.ClusterQueueReference]("a"),
 			},
 		},
 		{
@@ -507,7 +507,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"a": {
 					Name:                          "a",
 					AllocatableResourceGeneration: 4,
@@ -536,8 +536,8 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					NamespaceSelector:             labels.Nothing(),
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"three": sets.New("a", "c"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"three": sets.New[kueue.ClusterQueueReference]("a", "c"),
 			},
 		},
 		{
@@ -556,7 +556,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"b": {
 					Name:                          "b",
 					AllocatableResourceGeneration: 1,
@@ -597,9 +597,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("b"),
-				"two": sets.New("c", "e", "f"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"one": sets.New[kueue.ClusterQueueReference]("b"),
+				"two": sets.New[kueue.ClusterQueueReference]("c", "e", "f"),
 			},
 		},
 		{
@@ -612,7 +612,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				cache.AddOrUpdateResourceFlavor(utiltesting.MakeResourceFlavor("nonexistent-flavor").Obj())
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"a": {
 					Name:                          "a",
 					AllocatableResourceGeneration: 2,
@@ -671,9 +671,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"one": sets.New("a", "b"),
-				"two": sets.New("c", "e", "f"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"one": sets.New[kueue.ClusterQueueReference]("a", "b"),
+				"two": sets.New[kueue.ClusterQueueReference]("c", "e", "f"),
 			},
 		},
 		{
@@ -701,7 +701,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					NamespaceSelector:             labels.Everything(),
@@ -725,7 +725,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					NamespaceSelector:             labels.Everything(),
@@ -740,7 +740,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{},
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{},
 		},
 		{
 			name: "add check after queue creation",
@@ -757,7 +757,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				cache.AddOrUpdateAdmissionCheck(utiltesting.MakeAdmissionCheck("check2").Active(metav1.ConditionTrue).Obj())
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					NamespaceSelector:             labels.Everything(),
@@ -772,7 +772,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{},
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{},
 		},
 		{
 			name: "remove check after queue creation",
@@ -790,7 +790,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				cache.DeleteAdmissionCheck(utiltesting.MakeAdmissionCheck("check2").Obj())
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					NamespaceSelector:             labels.Everything(),
@@ -805,7 +805,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{},
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{},
 		},
 		{
 			name: "inactivate check after queue creation",
@@ -823,7 +823,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				cache.AddOrUpdateAdmissionCheck(utiltesting.MakeAdmissionCheck("check2").Active(metav1.ConditionFalse).Obj())
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					NamespaceSelector:             labels.Everything(),
@@ -838,7 +838,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight: oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{},
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{},
 		},
 		{
 			name: "add cluster queue after finished workloads",
@@ -874,7 +874,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"cq1": {
 					Name:                          "cq1",
 					NamespaceSelector:             labels.Everything(),
@@ -921,7 +921,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					},
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{},
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{},
 		},
 		{
 			name: "add CQ with multiple resource groups and flavors",
@@ -974,7 +974,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Obj()
 				return cache.AddClusterQueue(context.Background(), cq)
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					NamespaceSelector:             labels.Everything(),
@@ -1038,7 +1038,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					Obj()
 				return cache.AddClusterQueue(context.Background(), cq)
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"foo": {
 					Name:                          "foo",
 					NamespaceSelector:             labels.Everything(),
@@ -1056,7 +1056,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 				cohort := utiltesting.MakeCohort("cohort").Obj()
 				return cache.AddOrUpdateCohort(cohort)
 			},
-			wantCohorts: map[string]sets.Set[string]{
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
 				"cohort": nil,
 			},
 		},
@@ -1065,7 +1065,7 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 			operation: func(cache *Cache) error {
 				cohort := utiltesting.MakeCohort("cohort").Obj()
 				_ = cache.AddOrUpdateCohort(cohort)
-				cache.DeleteCohort(cohort.Name)
+				cache.DeleteCohort(kueue.CohortReference(cohort.Name))
 				return nil
 			},
 			wantCohorts: nil,
@@ -1078,10 +1078,10 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 
 				_ = cache.AddClusterQueue(context.Background(),
 					utiltesting.MakeClusterQueue("cq").Cohort("cohort").Obj())
-				cache.DeleteCohort(cohort.Name)
+				cache.DeleteCohort(kueue.CohortReference(cohort.Name))
 				return nil
 			},
-			wantClusterQueues: map[string]*clusterQueue{
+			wantClusterQueues: map[kueue.ClusterQueueReference]*clusterQueue{
 				"cq": {
 					Name:                          "cq",
 					NamespaceSelector:             labels.Everything(),
@@ -1092,8 +1092,8 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 					FairWeight:                    oneQuantity,
 				},
 			},
-			wantCohorts: map[string]sets.Set[string]{
-				"cohort": sets.New("cq"),
+			wantCohorts: map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+				"cohort": sets.New[kueue.ClusterQueueReference]("cq"),
 			},
 		},
 	}
@@ -1116,9 +1116,9 @@ func TestCacheClusterQueueOperations(t *testing.T) {
 			}
 
 			cohorts := cache.hm.Cohorts()
-			gotCohorts := make(map[string]sets.Set[string], len(cohorts))
+			gotCohorts := make(map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference], len(cohorts))
 			for name, cohort := range cohorts {
-				gotCohort := sets.New[string]()
+				gotCohort := sets.New[kueue.ClusterQueueReference]()
 				for _, cq := range cohort.ChildCQs() {
 					gotCohort.Insert(cq.Name)
 				}
@@ -1197,8 +1197,8 @@ func TestCacheWorkloadOperations(t *testing.T) {
 	steps := []struct {
 		name                 string
 		operation            func(cache *Cache) error
-		wantResults          map[string]result
-		wantAssumedWorkloads map[string]string
+		wantResults          map[kueue.ClusterQueueReference]result
+		wantAssumedWorkloads map[string]kueue.ClusterQueueReference
 		wantError            string
 	}{
 		{
@@ -1219,7 +1219,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1244,7 +1244,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				return nil
 			},
 			wantError: "failed to add workload",
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1268,7 +1268,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1293,7 +1293,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}).Obj()
 				return cache.UpdateWorkload(old, latest)
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1322,7 +1322,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				return cache.UpdateWorkload(old, latest)
 			},
 			wantError: "old ClusterQueue doesn't exist",
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1347,7 +1347,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				return cache.UpdateWorkload(old, latest)
 			},
 			wantError: "new ClusterQueue doesn't exist",
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1371,7 +1371,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}).Obj()
 				return cache.UpdateWorkload(old, latest)
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1392,7 +1392,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}).Obj()
 				return cache.DeleteWorkload(w)
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1411,7 +1411,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				w := utiltesting.MakeWorkload("a", "").Obj()
 				return cache.DeleteWorkload(w)
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1431,7 +1431,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				return cache.DeleteWorkload(w)
 			},
 			wantError: "cluster queue not found",
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1453,7 +1453,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				return cache.DeleteWorkload(w)
 			},
 			wantError: "cluster queue not found",
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1474,7 +1474,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}).Obj()
 				return cache.DeleteWorkload(w)
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1507,7 +1507,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b", "/d"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1523,7 +1523,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 					},
 				},
 			},
-			wantAssumedWorkloads: map[string]string{
+			wantAssumedWorkloads: map[string]kueue.ClusterQueueReference{
 				"/d": "one",
 				"/e": "two",
 			},
@@ -1540,7 +1540,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				return nil
 			},
 			wantError: "cluster queue not found",
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1552,7 +1552,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 					Workloads: sets.New("/c"),
 				},
 			},
-			wantAssumedWorkloads: map[string]string{},
+			wantAssumedWorkloads: map[string]kueue.ClusterQueueReference{},
 		},
 		{
 			name: "forget",
@@ -1576,7 +1576,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				w := workloads[0]
 				return cache.ForgetWorkload(w)
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1592,7 +1592,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 					},
 				},
 			},
-			wantAssumedWorkloads: map[string]string{
+			wantAssumedWorkloads: map[string]kueue.ClusterQueueReference{
 				"/e": "two",
 			},
 		},
@@ -1608,7 +1608,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				return nil
 			},
 			wantError: "the workload is not assumed",
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1646,7 +1646,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				}
 				return nil
 			},
-			wantResults: map[string]result{
+			wantResults: map[kueue.ClusterQueueReference]result{
 				"one": {
 					Workloads: sets.New("/a", "/b", "/d"),
 					UsedResources: resources.FlavorResourceQuantities{
@@ -1662,7 +1662,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 					},
 				},
 			},
-			wantAssumedWorkloads: map[string]string{
+			wantAssumedWorkloads: map[string]kueue.ClusterQueueReference{
 				"/e": "two",
 			},
 		},
@@ -1681,7 +1681,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 			if diff := cmp.Diff(step.wantError, messageOrEmpty(gotError)); diff != "" {
 				t.Errorf("Unexpected error (-want,+got):\n%s", diff)
 			}
-			gotResult := make(map[string]result)
+			gotResult := make(map[kueue.ClusterQueueReference]result)
 			for name, cq := range cache.hm.ClusterQueues() {
 				gotResult[name] = result{
 					Workloads:     sets.KeySet(cq.Workloads),
@@ -1692,7 +1692,7 @@ func TestCacheWorkloadOperations(t *testing.T) {
 				t.Errorf("Unexpected clusterQueues (-want,+got):\n%s", diff)
 			}
 			if step.wantAssumedWorkloads == nil {
-				step.wantAssumedWorkloads = map[string]string{}
+				step.wantAssumedWorkloads = map[string]kueue.ClusterQueueReference{}
 			}
 			if diff := cmp.Diff(step.wantAssumedWorkloads, cache.assumedWorkloads); diff != "" {
 				t.Errorf("Unexpected assumed workloads (-want,+got):\n%s", diff)
@@ -2759,14 +2759,14 @@ func TestClusterQueuesUsingFlavor(t *testing.T) {
 	tests := []struct {
 		name                       string
 		clusterQueues              []*kueue.ClusterQueue
-		wantInUseClusterQueueNames []string
+		wantInUseClusterQueueNames []kueue.ClusterQueueReference
 	}{
 		{
 			name: "single clusterQueue with flavor in use",
 			clusterQueues: []*kueue.ClusterQueue{
 				fooCq,
 			},
-			wantInUseClusterQueueNames: []string{fooCq.Name},
+			wantInUseClusterQueueNames: []kueue.ClusterQueueReference{kueue.ClusterQueueReference(fooCq.Name)},
 		},
 		{
 			name: "single clusterQueue with no flavor",
@@ -2781,7 +2781,10 @@ func TestClusterQueuesUsingFlavor(t *testing.T) {
 				barCq,
 				fizzCq,
 			},
-			wantInUseClusterQueueNames: []string{fooCq.Name, fizzCq.Name},
+			wantInUseClusterQueueNames: []kueue.ClusterQueueReference{
+				kueue.ClusterQueueReference(fooCq.Name),
+				kueue.ClusterQueueReference(fizzCq.Name),
+			},
 		},
 	}
 	for _, tc := range tests {
@@ -2797,7 +2800,7 @@ func TestClusterQueuesUsingFlavor(t *testing.T) {
 			}
 
 			cqs := cache.ClusterQueuesUsingFlavor("x86")
-			if diff := cmp.Diff(tc.wantInUseClusterQueueNames, cqs, cmpopts.SortSlices(func(a, b string) bool {
+			if diff := cmp.Diff(tc.wantInUseClusterQueueNames, cqs, cmpopts.SortSlices(func(a, b kueue.ClusterQueueReference) bool {
 				return a < b
 			})); len(diff) != 0 {
 				t.Errorf("Unexpected flavor is in use by clusterQueues (-want,+got):\n%s", diff)
@@ -2823,7 +2826,7 @@ func TestMatchingClusterQueues(t *testing.T) {
 				},
 			}).Obj(),
 	}
-	wantCQs := sets.New("matching1", "matching2")
+	wantCQs := sets.New[kueue.ClusterQueueReference]("matching1", "matching2")
 
 	cache := New(utiltesting.NewFakeClient())
 	for _, cq := range clusterQueues {
@@ -3132,13 +3135,13 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 	tests := []struct {
 		name             string
 		clusterQueues    map[string]*clusterQueue
-		assumedWorkloads map[string]string
+		assumedWorkloads map[string]kueue.ClusterQueueReference
 		workload         workload.Info
 		expected         bool
 	}{
 		{
 			name:             "Workload Is Assumed and not Admitted",
-			assumedWorkloads: map[string]string{"workload_namespace/workload_name": "test", "test2": "test2"},
+			assumedWorkloads: map[string]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
 			workload: workload.Info{
 				ClusterQueue: "ClusterQueue1",
 				Obj: &kueue.Workload{
@@ -3190,7 +3193,7 @@ func TestIsAssumedOrAdmittedCheckWorkload(t *testing.T) {
 						},
 					}},
 				}},
-			assumedWorkloads: map[string]string{"workload_namespace/workload_name": "test", "test2": "test2"},
+			assumedWorkloads: map[string]kueue.ClusterQueueReference{"workload_namespace/workload_name": "test", "test2": "test2"},
 			workload: workload.Info{
 				ClusterQueue: "ClusterQueue1",
 				Obj: &kueue.Workload{
@@ -3272,17 +3275,17 @@ func TestClusterQueuesUsingAdmissionChecks(t *testing.T) {
 
 	cases := map[string]struct {
 		clusterQueues              []*kueue.ClusterQueue
-		wantInUseClusterQueueNames []string
+		wantInUseClusterQueueNames []kueue.ClusterQueueReference
 		check                      string
 	}{
 		"single clusterQueue with check in use": {
 			clusterQueues:              []*kueue.ClusterQueue{fooCq},
-			wantInUseClusterQueueNames: []string{fooCq.Name},
+			wantInUseClusterQueueNames: []kueue.ClusterQueueReference{kueue.ClusterQueueReference(fooCq.Name)},
 			check:                      "ac1",
 		},
 		"single clusterQueue with AdmissionCheckStrategy in use": {
 			clusterQueues:              []*kueue.ClusterQueue{strategyCq},
-			wantInUseClusterQueueNames: []string{strategyCq.Name},
+			wantInUseClusterQueueNames: []kueue.ClusterQueueReference{kueue.ClusterQueueReference(strategyCq.Name)},
 			check:                      "ac3",
 		},
 		"single clusterQueue with no checks": {
@@ -3296,8 +3299,12 @@ func TestClusterQueuesUsingAdmissionChecks(t *testing.T) {
 				fizzCq,
 				strategyCq,
 			},
-			wantInUseClusterQueueNames: []string{fooCq.Name, fizzCq.Name, strategyCq.Name},
-			check:                      "ac1",
+			wantInUseClusterQueueNames: []kueue.ClusterQueueReference{
+				kueue.ClusterQueueReference(fooCq.Name),
+				kueue.ClusterQueueReference(fizzCq.Name),
+				kueue.ClusterQueueReference(strategyCq.Name),
+			},
+			check: "ac1",
 		},
 	}
 	for name, tc := range cases {
@@ -3314,7 +3321,7 @@ func TestClusterQueuesUsingAdmissionChecks(t *testing.T) {
 			}
 
 			cqs := cache.ClusterQueuesUsingAdmissionCheck(tc.check)
-			if diff := cmp.Diff(tc.wantInUseClusterQueueNames, cqs, cmpopts.SortSlices(func(a, b string) bool {
+			if diff := cmp.Diff(tc.wantInUseClusterQueueNames, cqs, cmpopts.SortSlices(func(a, b kueue.ClusterQueueReference) bool {
 				return a < b
 			})); len(diff) != 0 {
 				t.Errorf("Unexpected AdmissionCheck is in use by clusterQueues (-want,+got):\n%s", diff)
@@ -3337,7 +3344,7 @@ func TestClusterQueueReadiness(t *testing.T) {
 		clusterQueues    []*kueue.ClusterQueue
 		resourceFlavors  []*kueue.ResourceFlavor
 		admissionChecks  []*kueue.AdmissionCheck
-		clusterQueueName string
+		clusterQueueName kueue.ClusterQueueReference
 		terminate        bool
 		wantStatus       metav1.ConditionStatus
 		wantReason       string
diff --git a/pkg/cache/clusterqueue_test.go b/pkg/cache/clusterqueue_test.go
index 5f7e1de62..27661e971 100644
--- a/pkg/cache/clusterqueue_test.go
+++ b/pkg/cache/clusterqueue_test.go
@@ -772,7 +772,7 @@ func TestClusterQueueReadinessWithTAS(t *testing.T) {
 				t.Fatalf("unexpected error while building snapshot: %v", err)
 			}
 
-			_, gotReason, gotMessage := cqCache.ClusterQueueReadiness(tc.cq.Name)
+			_, gotReason, gotMessage := cqCache.ClusterQueueReadiness(kueue.ClusterQueueReference(tc.cq.Name))
 			if diff := cmp.Diff(tc.wantReason, gotReason); diff != "" {
 				t.Errorf("Unexpected inactiveReason (-want,+got):\n%s", diff)
 			}
diff --git a/pkg/cache/fair_sharing_test.go b/pkg/cache/fair_sharing_test.go
index 055d0f0f2..de8e7075d 100644
--- a/pkg/cache/fair_sharing_test.go
+++ b/pkg/cache/fair_sharing_test.go
@@ -647,7 +647,7 @@ func TestDominantResourceShare(t *testing.T) {
 			for _, cq := range cacheClusterQueuesMap {
 				drVal, drName := dominantResourceShare(cq, tc.flvResQ)
 				gotCache = append(gotCache, fairSharingResult{
-					Name:     cq.Name,
+					Name:     string(cq.Name),
 					NodeType: nodeTypeCq,
 					DrValue:  drVal,
 					DrName:   drName,
@@ -656,7 +656,7 @@ func TestDominantResourceShare(t *testing.T) {
 			for _, cohort := range cacheCohortsMap {
 				drVal, drName := dominantResourceShare(cohort, tc.flvResQ)
 				gotCache = append(gotCache, fairSharingResult{
-					Name:     cohort.Name,
+					Name:     string(cohort.Name),
 					NodeType: nodeTypeCohort,
 					DrValue:  drVal,
 					DrName:   drName,
@@ -672,7 +672,7 @@ func TestDominantResourceShare(t *testing.T) {
 			for _, cq := range snapshotClusterQueuesMap {
 				drVal, drName := dominantResourceShare(cq, tc.flvResQ)
 				gotSnapshot = append(gotSnapshot, fairSharingResult{
-					Name:     cq.Name,
+					Name:     string(cq.Name),
 					NodeType: nodeTypeCq,
 					DrValue:  drVal,
 					DrName:   drName,
@@ -681,7 +681,7 @@ func TestDominantResourceShare(t *testing.T) {
 			for _, cohort := range snapshotCohortsMap {
 				drVal, drName := dominantResourceShare(cohort, tc.flvResQ)
 				gotSnapshot = append(gotSnapshot, fairSharingResult{
-					Name:     cohort.Name,
+					Name:     string(cohort.Name),
 					NodeType: nodeTypeCohort,
 					DrValue:  drVal,
 					DrName:   drName,
diff --git a/pkg/cache/resource_test.go b/pkg/cache/resource_test.go
index f855f83f5..b9dda5131 100644
--- a/pkg/cache/resource_test.go
+++ b/pkg/cache/resource_test.go
@@ -33,9 +33,9 @@ func TestAvailable(t *testing.T) {
 	cases := map[string]struct {
 		cohorts                  []kueuealpha.Cohort
 		clusterQueues            []kueue.ClusterQueue
-		usage                    map[string]resources.FlavorResourceQuantities
-		wantAvailable            map[string]resources.FlavorResourceQuantities
-		wantPotentiallyAvailable map[string]resources.FlavorResourceQuantities
+		usage                    map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities
+		wantAvailable            map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities
+		wantPotentiallyAvailable map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities
 	}{
 		"base cqs": {
 			clusterQueues: []kueue.ClusterQueue{
@@ -49,18 +49,18 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("blue").Resource("cpu", "10").Obj(),
 					).ClusterQueue,
 			},
-			usage: map[string]resources.FlavorResourceQuantities{
+			usage: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 1000},
 				"cq2": {
 					{Flavor: "red", Resource: "cpu"}:  2_500,
 					{Flavor: "blue", Resource: "cpu"}: 1_000,
 				},
 			},
-			wantAvailable: map[string]resources.FlavorResourceQuantities{
+			wantAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 0},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 2_500, {Flavor: "blue", Resource: "cpu"}: 9_000},
 			},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 0},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 5_000, {Flavor: "blue", Resource: "cpu"}: 10_000},
 			},
@@ -84,15 +84,15 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "10").Obj(),
 					).Cohort,
 			},
-			usage: map[string]resources.FlavorResourceQuantities{
+			usage: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 1000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 500},
 			},
-			wantAvailable: map[string]resources.FlavorResourceQuantities{
+			wantAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 28_000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 28_500},
 			},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 29_000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 30_000},
 			},
@@ -111,9 +111,9 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "10").Obj(),
 					).Cohort,
 			},
-			usage:                    map[string]resources.FlavorResourceQuantities{"cq1": {{Flavor: "red", Resource: "cpu"}: 11_000}},
-			wantAvailable:            map[string]resources.FlavorResourceQuantities{"cq1": {{Flavor: "red", Resource: "cpu"}: 9_000}},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{"cq1": {{Flavor: "red", Resource: "cpu"}: 20_000}},
+			usage:                    map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{"cq1": {{Flavor: "red", Resource: "cpu"}: 11_000}},
+			wantAvailable:            map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{"cq1": {{Flavor: "red", Resource: "cpu"}: 9_000}},
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{"cq1": {{Flavor: "red", Resource: "cpu"}: 20_000}},
 		},
 		"cq oversubscription spills into cohort": {
 			clusterQueues: []kueue.ClusterQueue{
@@ -134,10 +134,10 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "10").Obj(),
 					).Cohort,
 			},
-			usage: map[string]resources.FlavorResourceQuantities{
+			usage: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 31_000},
 			},
-			wantAvailable: map[string]resources.FlavorResourceQuantities{
+			wantAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 0},
 				// even though cq2 doesn't borrow/lend
 				// resources from Cohort, the
@@ -147,7 +147,7 @@ func TestAvailable(t *testing.T) {
 				// the CohortTree.
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 0},
 			},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 20_000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 10_000},
 			},
@@ -180,12 +180,12 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "10").Obj(),
 					).Cohort,
 			},
-			usage: map[string]resources.FlavorResourceQuantities{
+			usage: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 20_000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 10_000},
 				"cq3": {{Flavor: "red", Resource: "cpu"}: 6_000},
 			},
-			wantAvailable: map[string]resources.FlavorResourceQuantities{
+			wantAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				// cq1 uses 20k, cq2 uses 10k, and
 				// cq3 uses 1k (not counting first 5k
 				// in guaranteedQuota), resulting in
@@ -198,7 +198,7 @@ func TestAvailable(t *testing.T) {
 				// 40k - (20k + 10k + 6k) = 4k
 				"cq3": {{Flavor: "red", Resource: "cpu"}: 4_000},
 			},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 35_000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 12_000},
 				"cq3": {{Flavor: "red", Resource: "cpu"}: 40_000},
@@ -235,18 +235,18 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "10").Obj(),
 					).Cohort,
 			},
-			usage: map[string]resources.FlavorResourceQuantities{
+			usage: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 10_000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 5_000},
 			},
-			wantAvailable: map[string]resources.FlavorResourceQuantities{
+			wantAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				// 30k available - 10k usage.
 				// no capacity/usage from right subtree
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 20_000},
 				// 40k available - 15k usage.
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 25_000},
 			},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"cq1": {{Flavor: "red", Resource: "cpu"}: 30_000},
 				"cq2": {{Flavor: "red", Resource: "cpu"}: 40_000},
 			},
@@ -287,7 +287,7 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "10").Obj(),
 					).Cohort,
 			},
-			wantAvailable: map[string]resources.FlavorResourceQuantities{
+			wantAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				// 30k in "left" subtree + 5k limit above tree
 				"left-cq1": {{Flavor: "red", Resource: "cpu"}: 35_000},
 				// 10k + 5k lending limit
@@ -295,7 +295,7 @@ func TestAvailable(t *testing.T) {
 				// all 50k in "root" subtree
 				"right-cq": {{Flavor: "red", Resource: "cpu"}: 50_000},
 			},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"left-cq1": {{Flavor: "red", Resource: "cpu"}: 35_000},
 				"left-cq2": {{Flavor: "red", Resource: "cpu"}: 15_000},
 				"right-cq": {{Flavor: "red", Resource: "cpu"}: 50_000},
@@ -342,7 +342,7 @@ func TestAvailable(t *testing.T) {
 						*utiltesting.MakeFlavorQuotas("red").Resource("cpu", "0").Obj(),
 					).Cohort,
 			},
-			wantAvailable: map[string]resources.FlavorResourceQuantities{
+			wantAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"left-cq1": {{Flavor: "red", Resource: "cpu"}: 20_000},
 				// only 5k of left-cq1's resources are available,
 				// plus 10k of its own.
@@ -351,7 +351,7 @@ func TestAvailable(t *testing.T) {
 				"right-cq": {{Flavor: "red", Resource: "cpu"}: 5_000},
 				"root-cq":  {{Flavor: "red", Resource: "cpu"}: 5_000},
 			},
-			wantPotentiallyAvailable: map[string]resources.FlavorResourceQuantities{
+			wantPotentiallyAvailable: map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities{
 				"left-cq1": {{Flavor: "red", Resource: "cpu"}: 20_000},
 				"left-cq2": {{Flavor: "red", Resource: "cpu"}: 15_000},
 				"right-cq": {{Flavor: "red", Resource: "cpu"}: 5_000},
@@ -380,8 +380,8 @@ func TestAvailable(t *testing.T) {
 			// before adding usage
 			{
 				clusterQueues := snapshot.ClusterQueues()
-				gotAvailable := make(map[string]resources.FlavorResourceQuantities, len(clusterQueues))
-				gotPotentiallyAvailable := make(map[string]resources.FlavorResourceQuantities, len(clusterQueues))
+				gotAvailable := make(map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities, len(clusterQueues))
+				gotPotentiallyAvailable := make(map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities, len(clusterQueues))
 				for _, cq := range clusterQueues {
 					numFrs := len(cq.ResourceNode.Quotas)
 					gotAvailable[cq.Name] = make(resources.FlavorResourceQuantities, numFrs)
@@ -406,8 +406,8 @@ func TestAvailable(t *testing.T) {
 					snapshot.ClusterQueue(cqName).AddUsage(workload.Usage{Quota: usage})
 				}
 				clusterQueues := snapshot.ClusterQueues()
-				gotAvailable := make(map[string]resources.FlavorResourceQuantities, len(clusterQueues))
-				gotPotentiallyAvailable := make(map[string]resources.FlavorResourceQuantities, len(clusterQueues))
+				gotAvailable := make(map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities, len(clusterQueues))
+				gotPotentiallyAvailable := make(map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities, len(clusterQueues))
 				for _, cq := range clusterQueues {
 					numFrs := len(cq.ResourceNode.Quotas)
 					gotAvailable[cq.Name] = make(resources.FlavorResourceQuantities, numFrs)
@@ -431,8 +431,8 @@ func TestAvailable(t *testing.T) {
 					snapshot.ClusterQueue(cqName).RemoveUsage(workload.Usage{Quota: usage})
 				}
 				clusterQueues := snapshot.ClusterQueues()
-				gotAvailable := make(map[string]resources.FlavorResourceQuantities, len(clusterQueues))
-				gotPotentiallyAvailable := make(map[string]resources.FlavorResourceQuantities, len(clusterQueues))
+				gotAvailable := make(map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities, len(clusterQueues))
+				gotPotentiallyAvailable := make(map[kueue.ClusterQueueReference]resources.FlavorResourceQuantities, len(clusterQueues))
 				for _, cq := range clusterQueues {
 					numFrs := len(cq.ResourceNode.Quotas)
 					gotAvailable[cq.Name] = make(resources.FlavorResourceQuantities, numFrs)
diff --git a/pkg/cache/snapshot_test.go b/pkg/cache/snapshot_test.go
index 36ab6bb0a..5c2778ad5 100644
--- a/pkg/cache/snapshot_test.go
+++ b/pkg/cache/snapshot_test.go
@@ -70,8 +70,8 @@ func TestSnapshot(t *testing.T) {
 			},
 			wantSnapshot: Snapshot{
 				Manager: hierarchy.NewManagerForTest(
-					map[string]*CohortSnapshot{},
-					map[string]*ClusterQueueSnapshot{
+					map[kueue.CohortReference]*CohortSnapshot{},
+					map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 						"a": {
 							Name:                          "a",
 							NamespaceSelector:             labels.Everything(),
@@ -112,7 +112,7 @@ func TestSnapshot(t *testing.T) {
 					Obj(),
 			},
 			wantSnapshot: Snapshot{
-				InactiveClusterQueueSets: sets.New("flavor-nonexistent-cq"),
+				InactiveClusterQueueSets: sets.New[kueue.ClusterQueueReference]("flavor-nonexistent-cq"),
 			},
 		},
 		"resourceFlavors": {
@@ -129,8 +129,8 @@ func TestSnapshot(t *testing.T) {
 			},
 			wantSnapshot: Snapshot{
 				Manager: hierarchy.NewManagerForTest(
-					map[string]*CohortSnapshot{},
-					map[string]*ClusterQueueSnapshot{},
+					map[kueue.CohortReference]*CohortSnapshot{},
+					map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{},
 				),
 				ResourceFlavors: map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor{
 					"demand": utiltesting.MakeResourceFlavor("demand").
@@ -229,10 +229,10 @@ func TestSnapshot(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"borrowing": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"a": {
 								Name:                          "a",
 								AllocatableResourceGeneration: 2,
@@ -375,8 +375,8 @@ func TestSnapshot(t *testing.T) {
 			},
 			wantSnapshot: Snapshot{
 				Manager: hierarchy.NewManagerForTest(
-					map[string]*CohortSnapshot{},
-					map[string]*ClusterQueueSnapshot{
+					map[kueue.CohortReference]*CohortSnapshot{},
+					map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 						"with-preemption": {
 							Name:                          "with-preemption",
 							NamespaceSelector:             labels.Everything(),
@@ -400,8 +400,8 @@ func TestSnapshot(t *testing.T) {
 			},
 			wantSnapshot: Snapshot{
 				Manager: hierarchy.NewManagerForTest(
-					map[string]*CohortSnapshot{},
-					map[string]*ClusterQueueSnapshot{
+					map[kueue.CohortReference]*CohortSnapshot{},
+					map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 						"with-preemption": {
 							Name:                          "with-preemption",
 							NamespaceSelector:             labels.Everything(),
@@ -476,10 +476,10 @@ func TestSnapshot(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lending": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"a": {
 								Name:                          "a",
 								AllocatableResourceGeneration: 2,
@@ -631,10 +631,10 @@ func TestSnapshot(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lending": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"a": {
 								Name:                          "a",
 								AllocatableResourceGeneration: 2,
@@ -750,7 +750,7 @@ func TestSnapshot(t *testing.T) {
 			},
 			wantSnapshot: Snapshot{
 				Manager: hierarchy.NewManagerForTest(
-					map[string]*CohortSnapshot{
+					map[kueue.CohortReference]*CohortSnapshot{
 						"cohort": {
 							Name: "cohort",
 							ResourceNode: ResourceNode{
@@ -768,7 +768,7 @@ func TestSnapshot(t *testing.T) {
 							FairWeight: oneQuantity,
 						},
 					},
-					map[string]*ClusterQueueSnapshot{
+					map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 						"cq": {
 							Name:                          "cq",
 							AllocatableResourceGeneration: 2,
@@ -837,7 +837,7 @@ func TestSnapshot(t *testing.T) {
 			},
 			wantSnapshot: Snapshot{
 				Manager: hierarchy.NewManagerForTest(
-					map[string]*CohortSnapshot{
+					map[kueue.CohortReference]*CohortSnapshot{
 						"nocycle": {
 							Name: "nocycle",
 							ResourceNode: ResourceNode{
@@ -848,7 +848,7 @@ func TestSnapshot(t *testing.T) {
 							FairWeight: oneQuantity,
 						},
 					},
-					map[string]*ClusterQueueSnapshot{
+					map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 						"cq-nocycle": {
 							Name:                          "cq-nocycle",
 							AllocatableResourceGeneration: 2,
@@ -874,7 +874,7 @@ func TestSnapshot(t *testing.T) {
 						},
 					},
 				),
-				InactiveClusterQueueSets: sets.New("cq-autocycle", "cq-a", "cq-b"),
+				InactiveClusterQueueSets: sets.New[kueue.ClusterQueueReference]("cq-autocycle", "cq-a", "cq-b"),
 				ResourceFlavors: map[kueue.ResourceFlavorReference]*kueue.ResourceFlavor{
 					"arm": utiltesting.MakeResourceFlavor("arm").Obj(),
 				},
@@ -886,13 +886,13 @@ func TestSnapshot(t *testing.T) {
 			},
 			wantSnapshot: Snapshot{
 				Manager: hierarchy.NewManagerForTest(
-					map[string]*CohortSnapshot{
+					map[kueue.CohortReference]*CohortSnapshot{
 						"cohort": {
 							Name:       "cohort",
 							FairWeight: resource.MustParse("0.5"),
 						},
 					},
-					map[string]*ClusterQueueSnapshot{},
+					map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{},
 				),
 			},
 		},
@@ -1038,10 +1038,10 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"cohort": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name:              "c1",
 								Workloads:         make(map[string]*workload.Info),
@@ -1098,10 +1098,10 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"cohort": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name: "c1",
 								Workloads: map[string]*workload.Info{
@@ -1164,10 +1164,10 @@ func TestSnapshotAddRemoveWorkload(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"cohort": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"c1": {
 								Name: "c1",
 								Workloads: map[string]*workload.Info{
@@ -1330,10 +1330,10 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lend": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
 								Workloads:         make(map[string]*workload.Info),
@@ -1383,10 +1383,10 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lend": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
 								Workloads:         make(map[string]*workload.Info),
@@ -1437,10 +1437,10 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lend": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
 								Workloads:         make(map[string]*workload.Info),
@@ -1491,10 +1491,10 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lend": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
 								Workloads:         make(map[string]*workload.Info),
@@ -1546,10 +1546,10 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lend": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
 								Workloads:         make(map[string]*workload.Info),
@@ -1601,10 +1601,10 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lend": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
 								Workloads:         make(map[string]*workload.Info),
@@ -1655,10 +1655,10 @@ func TestSnapshotAddRemoveWorkloadWithLendingLimit(t *testing.T) {
 				}
 				return Snapshot{
 					Manager: hierarchy.NewManagerForTest(
-						map[string]*CohortSnapshot{
+						map[kueue.CohortReference]*CohortSnapshot{
 							"lend": cohort,
 						},
-						map[string]*ClusterQueueSnapshot{
+						map[kueue.ClusterQueueReference]*ClusterQueueSnapshot{
 							"lend-a": {
 								Name:              "lend-a",
 								Workloads:         make(map[string]*workload.Info),
diff --git a/pkg/hierarchy/manager_test.go b/pkg/hierarchy/manager_test.go
index b6062c3d8..8dd638b1e 100644
--- a/pkg/hierarchy/manager_test.go
+++ b/pkg/hierarchy/manager_test.go
@@ -22,6 +22,8 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"k8s.io/apimachinery/pkg/util/sets"
+
+	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 )
 
 func TestManager(t *testing.T) {
@@ -328,9 +330,9 @@ func TestManager(t *testing.T) {
 				gotCqs := sets.New[string]()
 				gotEdges := make([]edge, 0, len(tc.wantCqEdge))
 				for _, cq := range mgr.ClusterQueues() {
-					gotCqs.Insert(cq.GetName())
+					gotCqs.Insert(string(cq.GetName()))
 					if cq.HasParent() {
-						gotEdges = append(gotEdges, edge{cq.GetName(), cq.Parent().GetName()})
+						gotEdges = append(gotEdges, edge{string(cq.GetName()), string(cq.Parent().GetName())})
 					}
 				}
 				if diff := cmp.Diff(tc.wantCqs, gotCqs); diff != "" {
@@ -346,15 +348,15 @@ func TestManager(t *testing.T) {
 				gotCohortChildEdges := make([]edge, 0, len(tc.wantCohortEdge))
 				gotCohortParentEdges := make([]edge, 0, len(tc.wantCohortEdge))
 				for _, cohort := range mgr.Cohorts() {
-					gotCohorts.Insert(cohort.GetName())
+					gotCohorts.Insert(string(cohort.GetName()))
 					for _, cq := range cohort.ChildCQs() {
-						gotCqEdges = append(gotCqEdges, edge{cq.GetName(), cohort.GetName()})
+						gotCqEdges = append(gotCqEdges, edge{string(cq.GetName()), string(cohort.GetName())})
 					}
 					for _, childCohort := range cohort.ChildCohorts() {
-						gotCohortChildEdges = append(gotCohortChildEdges, edge{childCohort.GetName(), cohort.GetName()})
+						gotCohortChildEdges = append(gotCohortChildEdges, edge{string(childCohort.GetName()), string(cohort.GetName())})
 					}
 					if cohort.HasParent() {
-						gotCohortParentEdges = append(gotCohortParentEdges, edge{cohort.GetName(), cohort.Parent().GetName()})
+						gotCohortParentEdges = append(gotCohortParentEdges, edge{string(cohort.GetName()), string(cohort.Parent().GetName())})
 					}
 				}
 				if diff := cmp.Diff(tc.wantCohorts, gotCohorts); diff != "" {
@@ -378,7 +380,7 @@ func TestCycles(t *testing.T) {
 	type M = Manager[*testClusterQueue, *testCohort]
 	cases := map[string]struct {
 		operations func(M)
-		wantCycles map[string]bool
+		wantCycles map[kueue.CohortReference]bool
 	}{
 		"no cycles": {
 			operations: func(m M) {
@@ -388,7 +390,7 @@ func TestCycles(t *testing.T) {
 				m.UpdateCohortEdge("left", "root")
 				m.UpdateCohortEdge("right", "root")
 			},
-			wantCycles: map[string]bool{
+			wantCycles: map[kueue.CohortReference]bool{
 				"root":  false,
 				"left":  false,
 				"right": false,
@@ -399,7 +401,7 @@ func TestCycles(t *testing.T) {
 				m.AddCohort("root")
 				m.UpdateCohortEdge("root", "root")
 			},
-			wantCycles: map[string]bool{
+			wantCycles: map[kueue.CohortReference]bool{
 				"root": true,
 			},
 		},
@@ -411,7 +413,7 @@ func TestCycles(t *testing.T) {
 				m.CycleChecker.HasCycle(m.Cohort("root"))
 				m.UpdateCohortEdge("root", "")
 			},
-			wantCycles: map[string]bool{
+			wantCycles: map[kueue.CohortReference]bool{
 				"root": false,
 			},
 		},
@@ -422,7 +424,7 @@ func TestCycles(t *testing.T) {
 				m.UpdateCohortEdge("cohort-a", "cohort-b")
 				m.UpdateCohortEdge("cohort-b", "cohort-a")
 			},
-			wantCycles: map[string]bool{
+			wantCycles: map[kueue.CohortReference]bool{
 				"cohort-a": true,
 				"cohort-b": true,
 			},
@@ -439,7 +441,7 @@ func TestCycles(t *testing.T) {
 
 				m.UpdateCohortEdge("cohort-a", "cohort-c")
 			},
-			wantCycles: map[string]bool{
+			wantCycles: map[kueue.CohortReference]bool{
 				"cohort-a": false,
 				"cohort-b": false,
 				"cohort-c": false,
@@ -455,7 +457,7 @@ func TestCycles(t *testing.T) {
 
 				m.UpdateCohortEdge("cohort-a", "")
 			},
-			wantCycles: map[string]bool{
+			wantCycles: map[kueue.CohortReference]bool{
 				"cohort-a": false,
 				"cohort-b": false,
 			},
@@ -469,7 +471,7 @@ func TestCycles(t *testing.T) {
 				m.CycleChecker.HasCycle(m.Cohort("cohort-a"))
 				m.DeleteCohort("cohort-b")
 			},
-			wantCycles: map[string]bool{
+			wantCycles: map[kueue.CohortReference]bool{
 				"cohort-a": false,
 				"cohort-b": false,
 			},
@@ -494,34 +496,34 @@ func TestCycles(t *testing.T) {
 }
 
 type testCohort struct {
-	name string
+	name kueue.CohortReference
 	Cohort[*testClusterQueue, *testCohort]
 }
 
-func newCohort(name string) *testCohort {
+func newCohort(name kueue.CohortReference) *testCohort {
 	return &testCohort{
 		name:   name,
 		Cohort: NewCohort[*testClusterQueue, *testCohort](),
 	}
 }
 
-func (t *testCohort) GetName() string {
+func (t *testCohort) GetName() kueue.CohortReference {
 	return t.name
 }
 
-func (t *testCohort) CCParent() CycleCheckable {
+func (t *testCohort) CCParent() CycleCheckable[kueue.CohortReference] {
 	return t.Parent()
 }
 
 type testClusterQueue struct {
-	name string
+	name kueue.ClusterQueueReference
 	ClusterQueue[*testCohort]
 }
 
-func newCq(name string) *testClusterQueue {
+func newCq(name kueue.ClusterQueueReference) *testClusterQueue {
 	return &testClusterQueue{name: name}
 }
 
-func (t *testClusterQueue) GetName() string {
+func (t *testClusterQueue) GetName() kueue.ClusterQueueReference {
 	return t.name
 }
diff --git a/pkg/queue/manager_test.go b/pkg/queue/manager_test.go
index 309fca891..a4da5fa30 100644
--- a/pkg/queue/manager_test.go
+++ b/pkg/queue/manager_test.go
@@ -101,7 +101,7 @@ func TestAddClusterQueueOrphans(t *testing.T) {
 		}
 	}
 
-	wantActiveWorkloads := map[string][]string{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]string{
 		"cq": {"/a", "/b"},
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump(), cmpDump...); diff != "" {
@@ -152,7 +152,7 @@ func TestUpdateClusterQueue(t *testing.T) {
 			t.Fatalf("Failed adding clusterQueue %s: %v", cq.Name, err)
 		}
 		// Increase the popCycle to ensure that the workload will be added as inadmissible.
-		manager.getClusterQueue(cq.Name).popCycle++
+		manager.getClusterQueue(kueue.ClusterQueueReference(cq.Name)).popCycle++
 	}
 	for _, q := range queues {
 		if err := manager.AddLocalQueue(ctx, q); err != nil {
@@ -169,7 +169,7 @@ func TestUpdateClusterQueue(t *testing.T) {
 
 	// Verify that all workloads are marked as inadmissible after creation.
 	inadmissibleWorkloads := manager.DumpInadmissible()
-	wantInadmissibleWorkloads := map[string][]string{
+	wantInadmissibleWorkloads := map[kueue.ClusterQueueReference][]string{
 		"cq1": {"default/a"},
 		"cq2": {"default/b"},
 	}
@@ -177,7 +177,7 @@ func TestUpdateClusterQueue(t *testing.T) {
 		t.Errorf("Unexpected set of inadmissible workloads (-want +got):\n%s", diff)
 	}
 	activeWorkloads := manager.Dump()
-	if diff := cmp.Diff(map[string][]string(nil), activeWorkloads); diff != "" {
+	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]string(nil), activeWorkloads); diff != "" {
 		t.Errorf("Unexpected active workloads (-want +got):\n%s", diff)
 	}
 
@@ -187,12 +187,12 @@ func TestUpdateClusterQueue(t *testing.T) {
 		t.Fatalf("Failed to update ClusterQueue: %v", err)
 	}
 
-	wantCohorts := map[string]sets.Set[string]{
-		"alpha": sets.New("cq1", "cq2"),
+	wantCohorts := map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference]{
+		"alpha": sets.New[kueue.ClusterQueueReference]("cq1", "cq2"),
 	}
-	gotCohorts := make(map[string]sets.Set[string])
+	gotCohorts := make(map[kueue.CohortReference]sets.Set[kueue.ClusterQueueReference])
 	for name, cohort := range manager.hm.Cohorts() {
-		gotCohorts[name] = sets.New[string]()
+		gotCohorts[name] = sets.New[kueue.ClusterQueueReference]()
 		for _, cq := range cohort.ChildCQs() {
 			gotCohorts[name].Insert(cq.GetName())
 		}
@@ -203,11 +203,11 @@ func TestUpdateClusterQueue(t *testing.T) {
 
 	// Verify that all workloads are active after the update.
 	inadmissibleWorkloads = manager.DumpInadmissible()
-	if diff := cmp.Diff(map[string][]string(nil), inadmissibleWorkloads); diff != "" {
+	if diff := cmp.Diff(map[kueue.ClusterQueueReference][]string(nil), inadmissibleWorkloads); diff != "" {
 		t.Errorf("Unexpected set of inadmissible workloads (-want +got):\n%s", diff)
 	}
 	activeWorkloads = manager.Dump()
-	wantActiveWorkloads := map[string][]string{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]string{
 		"cq1": {"default/a"},
 		"cq2": {"default/b"},
 	}
@@ -358,11 +358,11 @@ func TestUpdateLocalQueue(t *testing.T) {
 	}
 
 	// Verification.
-	workloadOrders := make(map[string][]string)
+	workloadOrders := make(map[kueue.ClusterQueueReference][]string)
 	for name, cq := range manager.hm.ClusterQueues() {
 		workloadOrders[name] = popNamesFromCQ(cq)
 	}
-	wantWorkloadOrders := map[string][]string{
+	wantWorkloadOrders := map[kueue.ClusterQueueReference][]string{
 		"cq1": nil,
 		"cq2": {"/b", "/a"},
 	}
@@ -389,7 +389,7 @@ func TestDeleteLocalQueue(t *testing.T) {
 		t.Fatalf("Could not create LocalQueue: %v", err)
 	}
 
-	wantActiveWorkloads := map[string][]string{
+	wantActiveWorkloads := map[kueue.ClusterQueueReference][]string{
 		"cq": {"/a"},
 	}
 	if diff := cmp.Diff(wantActiveWorkloads, manager.Dump(), cmpDump...); diff != "" {
@@ -678,7 +678,7 @@ func TestUpdateWorkload(t *testing.T) {
 		workloads        []*kueue.Workload
 		update           func(*kueue.Workload)
 		wantUpdated      bool
-		wantQueueOrder   map[string][]string
+		wantQueueOrder   map[kueue.ClusterQueueReference][]string
 		wantQueueMembers map[string]sets.Set[string]
 		wantErr          error
 	}{
@@ -697,7 +697,7 @@ func TestUpdateWorkload(t *testing.T) {
 				w.CreationTimestamp = metav1.NewTime(now.Add(time.Minute))
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[string][]string{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]string{
 				"cq": {"/b", "/a"},
 			},
 			wantQueueMembers: map[string]sets.Set[string]{
@@ -719,7 +719,7 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[string][]string{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]string{
 				"cq": {"/a"},
 			},
 			wantQueueMembers: map[string]sets.Set[string]{
@@ -743,7 +743,7 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "bar"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[string][]string{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]string{
 				"cq1": nil,
 				"cq2": {"/a"},
 			},
@@ -765,7 +765,7 @@ func TestUpdateWorkload(t *testing.T) {
 			update: func(w *kueue.Workload) {
 				w.Spec.QueueName = "bar"
 			},
-			wantQueueOrder: map[string][]string{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]string{
 				"cq": nil,
 			},
 			wantQueueMembers: map[string]sets.Set[string]{
@@ -787,7 +787,7 @@ func TestUpdateWorkload(t *testing.T) {
 				w.Spec.QueueName = "foo"
 			},
 			wantUpdated: true,
-			wantQueueOrder: map[string][]string{
+			wantQueueOrder: map[kueue.ClusterQueueReference][]string{
 				"cq": {"/a"},
 			},
 			wantQueueMembers: map[string]sets.Set[string]{
@@ -837,7 +837,7 @@ func TestUpdateWorkload(t *testing.T) {
 					}
 				}
 			}
-			queueOrder := make(map[string][]string)
+			queueOrder := make(map[kueue.ClusterQueueReference][]string)
 			for name, cq := range manager.hm.ClusterQueues() {
 				queueOrder[name] = popNamesFromCQ(cq)
 			}
@@ -1201,8 +1201,8 @@ func workloadNamesFromLQ(q *LocalQueue) sets.Set[string] {
 
 type fakeStatusChecker struct{}
 
-func (c *fakeStatusChecker) ClusterQueueActive(name string) bool {
-	return strings.Contains(name, "active-")
+func (c *fakeStatusChecker) ClusterQueueActive(name kueue.ClusterQueueReference) bool {
+	return strings.Contains(string(name), "active-")
 }
 
 func TestGetPendingWorkloadsInfo(t *testing.T) {
@@ -1243,7 +1243,7 @@ func TestGetPendingWorkloadsInfo(t *testing.T) {
 	}
 
 	cases := map[string]struct {
-		cqName                   string
+		cqName                   kueue.ClusterQueueReference
 		wantPendingWorkloadsInfo []*workload.Info
 	}{
 		"Invalid ClusterQueue name": {
diff --git a/pkg/scheduler/flavorassigner/flavorassigner_test.go b/pkg/scheduler/flavorassigner/flavorassigner_test.go
index 83f0f97d3..fc333b18f 100644
--- a/pkg/scheduler/flavorassigner/flavorassigner_test.go
+++ b/pkg/scheduler/flavorassigner/flavorassigner_test.go
@@ -1961,7 +1961,7 @@ func TestAssignFlavors(t *testing.T) {
 			if err != nil {
 				t.Fatalf("unexpected error while building snapshot: %v", err)
 			}
-			clusterQueue := snapshot.ClusterQueue(tc.clusterQueue.Name)
+			clusterQueue := snapshot.ClusterQueue(kueue.ClusterQueueReference(tc.clusterQueue.Name))
 
 			if clusterQueue == nil {
 				t.Fatalf("Failed to create CQ snapshot")
@@ -1971,7 +1971,7 @@ func TestAssignFlavors(t *testing.T) {
 			}
 
 			if tc.secondaryClusterQueue != nil {
-				secondaryClusterQueue := snapshot.ClusterQueue(tc.secondaryClusterQueue.Name)
+				secondaryClusterQueue := snapshot.ClusterQueue(kueue.ClusterQueueReference(tc.secondaryClusterQueue.Name))
 				if secondaryClusterQueue == nil {
 					t.Fatalf("Failed to create secondary CQ snapshot")
 				}
@@ -2252,7 +2252,7 @@ func TestDeletedFlavors(t *testing.T) {
 			if err != nil {
 				t.Fatalf("unexpected error while building snapshot: %v", err)
 			}
-			clusterQueue := snapshot.ClusterQueue(tc.clusterQueue.Name)
+			clusterQueue := snapshot.ClusterQueue(kueue.ClusterQueueReference(tc.clusterQueue.Name))
 			if clusterQueue == nil {
 				t.Fatalf("Failed to create CQ snapshot")
 			}
diff --git a/pkg/scheduler/preemption/preemption_test.go b/pkg/scheduler/preemption/preemption_test.go
index e51ff02eb..364f323d5 100644
--- a/pkg/scheduler/preemption/preemption_test.go
+++ b/pkg/scheduler/preemption/preemption_test.go
@@ -41,6 +41,7 @@ import (
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
 	"sigs.k8s.io/kueue/pkg/cache"
 	"sigs.k8s.io/kueue/pkg/constants"
+	controllerconstants "sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/hierarchy"
 	"sigs.k8s.io/kueue/pkg/scheduler/flavorassigner"
@@ -56,8 +57,8 @@ var snapCmpOpts = []cmp.Option{
 	cmpopts.IgnoreUnexported(hierarchy.Manager[*cache.ClusterQueueSnapshot, *cache.CohortSnapshot]{}),
 	cmpopts.IgnoreUnexported(hierarchy.CycleChecker{}),
 	cmpopts.IgnoreFields(cache.ClusterQueueSnapshot{}, "AllocatableResourceGeneration"),
-	cmp.Transformer("Cohort.Members", func(s sets.Set[*cache.ClusterQueueSnapshot]) sets.Set[string] {
-		result := make(sets.Set[string], len(s))
+	cmp.Transformer("Cohort.Members", func(s sets.Set[*cache.ClusterQueueSnapshot]) sets.Set[kueue.ClusterQueueReference] {
+		result := make(sets.Set[kueue.ClusterQueueReference], len(s))
 		for cq := range s {
 			result.Insert(cq.Name)
 		}
@@ -284,7 +285,7 @@ func TestPreemption(t *testing.T) {
 		cohorts             []*kueuealpha.Cohort
 		admitted            []kueue.Workload
 		incoming            *kueue.Workload
-		targetCQ            string
+		targetCQ            kueue.ClusterQueueReference
 		assignment          flavorassigner.Assignment
 		wantPreempted       sets.Set[string]
 		disableLendingLimit bool
@@ -1935,7 +1936,7 @@ func TestFairPreemptions(t *testing.T) {
 		strategies    []config.PreemptionStrategy
 		admitted      []kueue.Workload
 		incoming      *kueue.Workload
-		targetCQ      string
+		targetCQ      kueue.ClusterQueueReference
 		wantPreempted sets.Set[string]
 	}{
 		"reclaim nominal from user using the most": {
@@ -2451,3 +2452,35 @@ func singlePodSetAssignment(assignments flavorassigner.ResourceAssignment) flavo
 		}},
 	}
 }
+
+func TestPreemptionMessage(t *testing.T) {
+	cases := []struct {
+		preemptor *kueue.Workload
+		reason    string
+		want      string
+	}{
+		{
+			preemptor: &kueue.Workload{},
+			want:      "Preempted to accommodate a workload (UID: UNKNOWN, JobUID: UNKNOWN) due to UNKNOWN",
+		},
+		{
+			preemptor: &kueue.Workload{ObjectMeta: metav1.ObjectMeta{UID: "uid"}},
+			want:      "Preempted to accommodate a workload (UID: uid, JobUID: UNKNOWN) due to UNKNOWN",
+		},
+		{
+			preemptor: &kueue.Workload{ObjectMeta: metav1.ObjectMeta{UID: "uid", Labels: map[string]string{controllerconstants.JobUIDLabel: "juid"}}},
+			want:      "Preempted to accommodate a workload (UID: uid, JobUID: juid) due to UNKNOWN",
+		},
+		{
+			preemptor: &kueue.Workload{ObjectMeta: metav1.ObjectMeta{UID: "uid", Labels: map[string]string{controllerconstants.JobUIDLabel: "juid"}}},
+			reason:    kueue.InClusterQueueReason,
+			want:      "Preempted to accommodate a workload (UID: uid, JobUID: juid) due to prioritization in the ClusterQueue",
+		},
+	}
+	for _, tc := range cases {
+		got := preemptionMessage(tc.preemptor, tc.reason)
+		if got != tc.want {
+			t.Errorf("preemptionMessage(preemptor=kueue.Workload{UID:%v, Labels:%v}, reason=%q) returned %q, want %q", tc.preemptor.UID, tc.preemptor.Labels, tc.reason, got, tc.want)
+		}
+	}
+}
diff --git a/pkg/scheduler/scheduler_test.go b/pkg/scheduler/scheduler_test.go
index 387769da1..8d652d52e 100644
--- a/pkg/scheduler/scheduler_test.go
+++ b/pkg/scheduler/scheduler_test.go
@@ -265,9 +265,9 @@ func TestSchedule(t *testing.T) {
 		// wantWorkloads is the subset of workloads that got admitted in this cycle.
 		wantWorkloads []kueue.Workload
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[string][]string
+		wantLeft map[kueue.ClusterQueueReference][]string
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[string][]string
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]string
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
 		wantPreempted sets.Set[string]
 		// wantEvents ignored if empty, the Message is ignored (it contains the duration)
@@ -413,7 +413,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			admissionError: errors.New("admission"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"sales": {"sales/foo"},
 			},
 		},
@@ -449,7 +449,7 @@ func TestSchedule(t *testing.T) {
 					},
 				},
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"sales": {"sales/new"},
 			},
 		},
@@ -462,7 +462,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-alpha": {"sales/new"},
 			},
 		},
@@ -643,7 +643,7 @@ func TestSchedule(t *testing.T) {
 				},
 			},
 			wantScheduled: []string{"eng-alpha/new"},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -715,7 +715,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-beta").Assignment(corev1.ResourceCPU, "spot", "1000m").Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-alpha": {"eng-alpha/can-reclaim"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -741,7 +741,7 @@ func TestSchedule(t *testing.T) {
 			wantAssignments: map[string]kueue.Admission{
 				"lend/a": *utiltesting.MakeAdmission("lend-b").Assignment(corev1.ResourceCPU, "default", "2000m").Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"lend-b": {"lend/b"},
 			},
 		},
@@ -790,7 +790,7 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("eng-alpha").Assignment(corev1.ResourceCPU, "on-demand", "60000m").Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				// Preemptor is not admitted in this cycle.
 				"eng-beta": {"eng-beta/preemptor"},
 			},
@@ -844,11 +844,11 @@ func TestSchedule(t *testing.T) {
 					ReserveQuota(utiltesting.MakeAdmission("other-alpha").Assignment(corev1.ResourceCPU, "on-demand", "100").Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				// Preemptor is not admitted in this cycle.
 				"other-beta": {"eng-beta/preemptor"},
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/pending"},
 			},
 			wantPreempted: sets.New("eng-alpha/use-all"),
@@ -864,7 +864,7 @@ func TestSchedule(t *testing.T) {
 					Request("example.com/gpu", "1").
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-alpha": {"eng-alpha/new"},
 			},
 		},
@@ -932,7 +932,7 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "1").
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"flavor-nonexistent-cq": {"sales/foo"},
 			},
 		},
@@ -1048,7 +1048,7 @@ func TestSchedule(t *testing.T) {
 				"eng-alpha/new-alpha": *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "1").AssignmentPodCount(1).Obj(),
 			},
 			wantScheduled: []string{"eng-beta/new", "eng-alpha/new-alpha"},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-gamma": {"eng-gamma/new-gamma"},
 			},
 			wantSkippedPreemptions: map[string]int{
@@ -1122,7 +1122,7 @@ func TestSchedule(t *testing.T) {
 				},
 			},
 			wantPreempted: sets.New("eng-beta/old"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -1162,7 +1162,7 @@ func TestSchedule(t *testing.T) {
 				},
 			},
 			wantPreempted: sets.New("eng-beta/old"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-beta": {"eng-beta/new"},
 			},
 		},
@@ -1243,7 +1243,7 @@ func TestSchedule(t *testing.T) {
 					).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"sales": {"sales/new"},
 			},
 			disablePartialAdmission: true,
@@ -1349,7 +1349,7 @@ func TestSchedule(t *testing.T) {
 					Assignment("r1", "default", "16").AssignmentPodCount(1).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"cq2": {"sales/wl2"},
 			},
 		},
@@ -1480,7 +1480,7 @@ func TestSchedule(t *testing.T) {
 			wantScheduled: []string{
 				"eng-beta/b",
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"cq_a": {"eng-alpha/a"},
 			},
 		},
@@ -1532,7 +1532,7 @@ func TestSchedule(t *testing.T) {
 				"eng-alpha/new":         *utiltesting.MakeAdmission("eng-alpha", "one").Assignment(corev1.ResourceCPU, "on-demand", "5").AssignmentPodCount(5).Obj(),
 			},
 			wantScheduled: []string{"eng-alpha/new"},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"eng-beta": {"eng-beta/older_new"},
 			},
 		},
@@ -1667,7 +1667,7 @@ func TestSchedule(t *testing.T) {
 				"eng-alpha/d1": *utiltesting.MakeAdmission("d", "one").Assignment(corev1.ResourceCPU, "on-demand", "70").Obj(),
 			},
 			wantScheduled: []string{"eng-alpha/d1"},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"e": {"eng-alpha/e1"},
 				"g": {"eng-alpha/g1"},
 				"f": {"eng-alpha/f1"},
@@ -1733,7 +1733,7 @@ func TestSchedule(t *testing.T) {
 				"eng-alpha/b1": *utiltesting.MakeAdmission("b", "one").Assignment(corev1.ResourceCPU, "on-demand", "50").Obj(),
 			},
 			wantScheduled: []string{"eng-alpha/b1"},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"c": {"eng-alpha/c1"},
 			},
 		},
@@ -1863,7 +1863,7 @@ func TestSchedule(t *testing.T) {
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
 			wantScheduled: []string{"eng-alpha/c1"},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"b": {"eng-alpha/b1"},
 			},
 		},
@@ -1919,7 +1919,7 @@ func TestSchedule(t *testing.T) {
 				"eng-alpha/c1": *utiltesting.MakeAdmission("c", "one").Assignment(corev1.ResourceCPU, "on-demand", "10").Obj(),
 			},
 			wantScheduled: []string{"eng-alpha/c1"},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"b": {"eng-alpha/b1"},
 			},
 		},
@@ -2000,7 +2000,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/a1", "eng-alpha/a2"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/incoming"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -2056,7 +2056,7 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "3").
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/incoming"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -2108,7 +2108,7 @@ func TestSchedule(t *testing.T) {
 					Request(corev1.ResourceCPU, "30").Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/alpha1", "eng-gamma/gamma1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				// Preemptor is not admitted in this cycle.
 				"eng-beta": {"eng-beta/preemptor"},
 			},
@@ -2179,7 +2179,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/a1", "eng-beta/b1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/preemptor"},
 			},
@@ -2241,7 +2241,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-beta/b1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-beta": {"eng-beta/preemptor"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -2327,7 +2327,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/a1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/pretending-preemptor"},
 			},
@@ -2431,7 +2431,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/a1", "eng-beta/b1", "eng-gamma/c1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/preemptor"},
 				"other-gamma": {"eng-gamma/preemptor"},
@@ -2545,7 +2545,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/a1", "eng-gamma/c1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/preemptor"},
 				"other-beta":  {"eng-beta/pretending-preemptor"},
 			},
@@ -2572,7 +2572,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"sales": {"sales/new"},
 			},
 		},
@@ -2591,7 +2591,7 @@ func TestSchedule(t *testing.T) {
 					WithValue("Max", corev1.ResourceCPU, "300m").
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"sales": {"sales/new"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -2620,7 +2620,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"sales": {"sales/new"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -2648,7 +2648,7 @@ func TestSchedule(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"sales": {"sales/new"},
 			},
 		},
@@ -2705,7 +2705,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-beta/b1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -2767,7 +2767,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/a1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -2832,7 +2832,7 @@ func TestSchedule(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("eng-alpha/a1"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"other-alpha": {"eng-alpha/preemptor"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -2933,10 +2933,10 @@ func TestSchedule(t *testing.T) {
 			wantPreempted: sets.Set[string](
 				sets.NewString("eng-gamma/Admitted-Workload-2"),
 			),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"CQ2": {"eng-beta/WL2"},
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"CQ1": {"eng-alpha/WL1"},
 			},
 			wantAssignments: map[string]kueue.Admission{
@@ -3060,7 +3060,7 @@ func TestSchedule(t *testing.T) {
 					switch {
 					case !workload.HasQuotaReservation(w.Obj):
 						t.Errorf("Workload %s is not admitted by a clusterQueue, but it is found as member of clusterQueue %s in the cache", name, cqName)
-					case string(w.Obj.Status.Admission.ClusterQueue) != cqName:
+					case w.Obj.Status.Admission.ClusterQueue != cqName:
 						t.Errorf("Workload %s is admitted by clusterQueue %s, but it is found as member of clusterQueue %s in the cache", name, w.Obj.Status.Admission.ClusterQueue, cqName)
 					default:
 						gotAssignments[name] = *w.Obj.Status.Admission
@@ -3866,7 +3866,7 @@ func TestLastSchedulingContext(t *testing.T) {
 					switch {
 					case !workload.IsAdmitted(w.Obj):
 						t.Errorf("Workload %s is not admitted by a clusterQueue, but it is found as member of clusterQueue %s in the cache", name, cqName)
-					case string(w.Obj.Status.Admission.ClusterQueue) != cqName:
+					case w.Obj.Status.Admission.ClusterQueue != cqName:
 						t.Errorf("Workload %s is admitted by clusterQueue %s, but it is found as member of clusterQueue %s in the cache", name, w.Obj.Status.Admission.ClusterQueue, cqName)
 					default:
 						gotAssignments[name] = *w.Obj.Status.Admission
@@ -3890,8 +3890,8 @@ func TestRequeueAndUpdate(t *testing.T) {
 	cases := []struct {
 		name              string
 		e                 entry
-		wantWorkloads     map[string][]string
-		wantInadmissible  map[string][]string
+		wantWorkloads     map[kueue.ClusterQueueReference][]string
+		wantInadmissible  map[kueue.ClusterQueueReference][]string
 		wantStatus        kueue.WorkloadStatus
 		wantStatusUpdates int
 	}{
@@ -3911,7 +3911,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				},
 				ResourceRequests: []kueue.PodSetRequest{{Name: kueue.DefaultPodSetName}},
 			},
-			wantInadmissible: map[string][]string{
+			wantInadmissible: map[kueue.ClusterQueueReference][]string{
 				"cq": {workload.Key(w1)},
 			},
 			wantStatusUpdates: 1,
@@ -3922,7 +3922,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          assumed,
 				inadmissibleMsg: "",
 			},
-			wantWorkloads: map[string][]string{
+			wantWorkloads: map[kueue.ClusterQueueReference][]string{
 				"cq": {workload.Key(w1)},
 			},
 		},
@@ -3932,7 +3932,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				status:          nominated,
 				inadmissibleMsg: "failed to admit workload",
 			},
-			wantWorkloads: map[string][]string{
+			wantWorkloads: map[kueue.ClusterQueueReference][]string{
 				"cq": {workload.Key(w1)},
 			},
 		},
@@ -3953,7 +3953,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 				},
 				ResourceRequests: []kueue.PodSetRequest{{Name: kueue.DefaultPodSetName}},
 			},
-			wantWorkloads: map[string][]string{
+			wantWorkloads: map[kueue.ClusterQueueReference][]string{
 				"cq": {workload.Key(w1)},
 			},
 			wantStatusUpdates: 1,
@@ -3987,7 +3987,7 @@ func TestRequeueAndUpdate(t *testing.T) {
 			if err := cqCache.AddClusterQueue(ctx, cq); err != nil {
 				t.Fatalf("Inserting clusterQueue %s to cache: %v", cq.Name, err)
 			}
-			if !cqCache.ClusterQueueActive(cq.Name) {
+			if !cqCache.ClusterQueueActive(kueue.ClusterQueueReference(cq.Name)) {
 				t.Fatalf("Status of ClusterQueue %s should be active", cq.Name)
 			}
 
@@ -4277,9 +4277,9 @@ func TestScheduleForTAS(t *testing.T) {
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
 		wantNewAssignments map[string]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[string][]string
+		wantLeft map[kueue.ClusterQueueReference][]string
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[string][]string
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]string
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
 		wantEvents []utiltesting.EventRecord
 		// eventCmpOpts are the comparison options for the events
@@ -4513,7 +4513,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -4610,7 +4610,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -4660,7 +4660,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -4692,7 +4692,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -4898,7 +4898,7 @@ func TestScheduleForTAS(t *testing.T) {
 							Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -5374,7 +5374,7 @@ func TestScheduleForTAS(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -5476,7 +5476,7 @@ func TestScheduleForTAS(t *testing.T) {
 					switch {
 					case !workload.HasQuotaReservation(w.Obj):
 						t.Fatalf("Workload %s is not admitted by a clusterQueue, but it is found as member of clusterQueue %s in the cache", name, cqName)
-					case string(w.Obj.Status.Admission.ClusterQueue) != cqName:
+					case w.Obj.Status.Admission.ClusterQueue != cqName:
 						t.Fatalf("Workload %s is admitted by clusterQueue %s, but it is found as member of clusterQueue %s in the cache", name, w.Obj.Status.Admission.ClusterQueue, cqName)
 					default:
 						gotAssignments[name] = *w.Obj.Status.Admission
@@ -5569,9 +5569,9 @@ func TestScheduleForTASPreemption(t *testing.T) {
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
 		wantNewAssignments map[string]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[string][]string
+		wantLeft map[kueue.ClusterQueueReference][]string
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[string][]string
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]string
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
 		wantPreempted sets.Set[string]
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
@@ -5622,7 +5622,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("default/low-priority-admitted"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -5630,7 +5630,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Key:       types.NamespacedName{Namespace: "default", Name: "low-priority-admitted"},
 					EventType: "Normal",
 					Reason:    "Preempted",
-					Message:   "Preempted to accommodate a workload (UID: ) due to prioritization in the ClusterQueue",
+					Message:   "Preempted to accommodate a workload (UID: UNKNOWN, JobUID: UNKNOWN) due to prioritization in the ClusterQueue",
 				},
 				{
 					Key:       types.NamespacedName{Namespace: "default", Name: "foo"},
@@ -5687,7 +5687,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("default/low-priority-admitted"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/high-priority-waiting"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -5695,7 +5695,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Key:       types.NamespacedName{Namespace: "default", Name: "low-priority-admitted"},
 					EventType: "Normal",
 					Reason:    "Preempted",
-					Message:   "Preempted to accommodate a workload (UID: ) due to prioritization in the ClusterQueue",
+					Message:   "Preempted to accommodate a workload (UID: UNKNOWN, JobUID: UNKNOWN) due to prioritization in the ClusterQueue",
 				},
 				{
 					Key:       types.NamespacedName{Namespace: "default", Name: "high-priority-waiting"},
@@ -5773,7 +5773,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("default/low-priority-admitted"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -5781,7 +5781,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Key:       types.NamespacedName{Namespace: "default", Name: "low-priority-admitted"},
 					EventType: "Normal",
 					Reason:    "Preempted",
-					Message:   "Preempted to accommodate a workload (UID: ) due to prioritization in the ClusterQueue",
+					Message:   "Preempted to accommodate a workload (UID: UNKNOWN, JobUID: UNKNOWN) due to prioritization in the ClusterQueue",
 				},
 				{
 					Key:       types.NamespacedName{Namespace: "default", Name: "foo"},
@@ -5861,7 +5861,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Obj(),
 			},
 			wantPreempted: sets.New("default/low-priority-admitted"),
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/foo"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -5869,7 +5869,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					Key:       types.NamespacedName{Namespace: "default", Name: "low-priority-admitted"},
 					EventType: "Normal",
 					Reason:    "Preempted",
-					Message:   "Preempted to accommodate a workload (UID: ) due to prioritization in the ClusterQueue",
+					Message:   "Preempted to accommodate a workload (UID: UNKNOWN, JobUID: UNKNOWN) due to prioritization in the ClusterQueue",
 				},
 				{
 					Key:       types.NamespacedName{Namespace: "default", Name: "foo"},
@@ -5932,10 +5932,10 @@ func TestScheduleForTASPreemption(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/low-priority-which-would-fit"},
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-main": {"default/mid-priority-waiting"},
 			},
 			wantEvents: []utiltesting.EventRecord{
@@ -6048,7 +6048,7 @@ func TestScheduleForTASPreemption(t *testing.T) {
 					switch {
 					case !workload.HasQuotaReservation(w.Obj):
 						t.Fatalf("Workload %s is not admitted by a clusterQueue, but it is found as member of clusterQueue %s in the cache", name, cqName)
-					case string(w.Obj.Status.Admission.ClusterQueue) != cqName:
+					case w.Obj.Status.Admission.ClusterQueue != cqName:
 						t.Fatalf("Workload %s is admitted by clusterQueue %s, but it is found as member of clusterQueue %s in the cache", name, w.Obj.Status.Admission.ClusterQueue, cqName)
 					default:
 						gotAssignments[name] = *w.Obj.Status.Admission
@@ -6169,9 +6169,9 @@ func TestScheduleForTASCohorts(t *testing.T) {
 		// wantNewAssignments is a summary of all new admissions in the cache after this cycle.
 		wantNewAssignments map[string]kueue.Admission
 		// wantLeft is the workload keys that are left in the queues after this cycle.
-		wantLeft map[string][]string
+		wantLeft map[kueue.ClusterQueueReference][]string
 		// wantInadmissibleLeft is the workload keys that are left in the inadmissible state after this cycle.
-		wantInadmissibleLeft map[string][]string
+		wantInadmissibleLeft map[kueue.ClusterQueueReference][]string
 		// wantPreempted is the keys of the workloads that get preempted in the scheduling cycle.
 		wantPreempted sets.Set[string]
 		// wantEvents asserts on the events, the comparison options are passed by eventCmpOpts
@@ -6269,7 +6269,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 			},
 			wantPreempted: sets.New("default/a1-admitted"),
@@ -6380,7 +6380,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 			},
 			wantPreempted: sets.New("default/a1-admitted"),
@@ -6469,7 +6469,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 			},
 			wantPreempted: sets.New("default/a2-admitted"),
@@ -6594,7 +6594,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 				"tas-cq-c": {"default/c1"},
 			},
@@ -6816,7 +6816,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						},
 					}).Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 			},
 			eventCmpOpts: []cmp.Option{eventIgnoreMessage},
@@ -6861,7 +6861,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 			},
 			wantNewAssignments: map[string]kueue.Admission{
@@ -6940,7 +6940,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						},
 					}).Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 			},
 			eventCmpOpts: []cmp.Option{eventIgnoreMessage},
@@ -7019,7 +7019,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-a": {"default/a2"},
 				"tas-cq-b": {"default/b1"},
 			},
@@ -7100,10 +7100,10 @@ func TestScheduleForTASCohorts(t *testing.T) {
 						Obj()).
 					Obj(),
 			},
-			wantLeft: map[string][]string{
+			wantLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-b": {"default/b1"},
 			},
-			wantInadmissibleLeft: map[string][]string{
+			wantInadmissibleLeft: map[kueue.ClusterQueueReference][]string{
 				"tas-cq-a": {"default/a2"},
 			},
 			eventCmpOpts: []cmp.Option{eventIgnoreMessage},
@@ -7221,7 +7221,7 @@ func TestScheduleForTASCohorts(t *testing.T) {
 					switch {
 					case !workload.HasQuotaReservation(w.Obj):
 						t.Fatalf("Workload %s is not admitted by a clusterQueue, but it is found as member of clusterQueue %s in the cache", name, cqName)
-					case string(w.Obj.Status.Admission.ClusterQueue) != cqName:
+					case w.Obj.Status.Admission.ClusterQueue != cqName:
 						t.Fatalf("Workload %s is admitted by clusterQueue %s, but it is found as member of clusterQueue %s in the cache", name, w.Obj.Status.Admission.ClusterQueue, cqName)
 					default:
 						gotAssignments[name] = *w.Obj.Status.Admission
diff --git a/pkg/util/testing/wrappers.go b/pkg/util/testing/wrappers.go
index d524ef93d..5cc5f68b2 100644
--- a/pkg/util/testing/wrappers.go
+++ b/pkg/util/testing/wrappers.go
@@ -688,10 +688,10 @@ type CohortWrapper struct {
 	kueuealpha.Cohort
 }
 
-func MakeCohort(name string) *CohortWrapper {
+func MakeCohort(name kueue.CohortReference) *CohortWrapper {
 	return &CohortWrapper{kueuealpha.Cohort{
 		ObjectMeta: metav1.ObjectMeta{
-			Name: name,
+			Name: string(name),
 		},
 	}}
 }
@@ -700,7 +700,7 @@ func (c *CohortWrapper) Obj() *kueuealpha.Cohort {
 	return &c.Cohort
 }
 
-func (c *CohortWrapper) Parent(parentName string) *CohortWrapper {
+func (c *CohortWrapper) Parent(parentName kueue.CohortReference) *CohortWrapper {
 	c.Cohort.Spec.Parent = parentName
 	return c
 }
@@ -746,7 +746,7 @@ func (c *ClusterQueueWrapper) Obj() *kueue.ClusterQueue {
 }
 
 // Cohort sets the borrowing cohort.
-func (c *ClusterQueueWrapper) Cohort(cohort string) *ClusterQueueWrapper {
+func (c *ClusterQueueWrapper) Cohort(cohort kueue.CohortReference) *ClusterQueueWrapper {
 	c.Spec.Cohort = cohort
 	return c
 }
diff --git a/pkg/util/testingjobs/rayjob/wrappers.go b/pkg/util/testingjobs/rayjob/wrappers.go
index b8c6ec7c7..703001245 100644
--- a/pkg/util/testingjobs/rayjob/wrappers.go
+++ b/pkg/util/testingjobs/rayjob/wrappers.go
@@ -227,7 +227,7 @@ func (j *JobWrapper) Request(rayType rayv1.RayNodeType, r corev1.ResourceName, v
 	return j
 }
 
-func (j *JobWrapper) Image(rayType rayv1.RayNodeType, image string, args []string) *JobWrapper {
+func (j *JobWrapper) Image(rayType rayv1.RayNodeType, image string, args ...string) *JobWrapper {
 	if rayType == rayv1.HeadNode {
 		j.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Containers[0].Image = image
 		j.Spec.RayClusterSpec.HeadGroupSpec.Template.Spec.Containers[0].Args = args
diff --git a/test/e2e/multikueue/e2e_test.go b/test/e2e/multikueue/e2e_test.go
index e06e1a726..390369b29 100644
--- a/test/e2e/multikueue/e2e_test.go
+++ b/test/e2e/multikueue/e2e_test.go
@@ -773,8 +773,8 @@ var _ = ginkgo.Describe("MultiKueue", func() {
 				Request(rayv1.HeadNode, corev1.ResourceCPU, "1").
 				Request(rayv1.WorkerNode, corev1.ResourceCPU, "0.5").
 				Entrypoint("python -c \"import ray; ray.init(); print(ray.cluster_resources())\"").
-				Image(rayv1.HeadNode, kuberayTestImage, []string{}).
-				Image(rayv1.WorkerNode, kuberayTestImage, []string{}).
+				Image(rayv1.HeadNode, kuberayTestImage).
+				Image(rayv1.WorkerNode, kuberayTestImage).
 				Obj()
 
 			ginkgo.By("Creating the RayJob", func() {
diff --git a/test/e2e/tas/rayjob_test.go b/test/e2e/tas/rayjob_test.go
index b23eedcdf..20f8aad69 100644
--- a/test/e2e/tas/rayjob_test.go
+++ b/test/e2e/tas/rayjob_test.go
@@ -183,8 +183,8 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for RayJob", ginkgo.Ordered, fu
 						},
 					},
 				}).
-				Image(rayv1.HeadNode, kuberayTestImage, []string{}).
-				Image(rayv1.WorkerNode, kuberayTestImage, []string{}).
+				Image(rayv1.HeadNode, kuberayTestImage).
+				Image(rayv1.WorkerNode, kuberayTestImage).
 				Obj()
 
 			gomega.Expect(k8sClient.Create(ctx, rayjob)).Should(gomega.Succeed())
@@ -227,7 +227,7 @@ var _ = ginkgo.Describe("TopologyAwareScheduling for RayJob", ginkgo.Ordered, fu
 })
 
 func readAssignedNodes(pods []corev1.Pod) set.Set[string] {
-	assignment := set.Set[string]{}
+	assignment := set.New[string]()
 	for _, pod := range pods {
 		if role := pod.Labels["ray.io/node-type"]; role == "worker" {
 			assignment = assignment.Insert(pod.Spec.NodeName)
diff --git a/test/integration/singlecluster/kueuectl/create_test.go b/test/integration/singlecluster/kueuectl/create_test.go
index 8a4dea0b3..e96896972 100644
--- a/test/integration/singlecluster/kueuectl/create_test.go
+++ b/test/integration/singlecluster/kueuectl/create_test.go
@@ -204,7 +204,7 @@ var _ = ginkgo.Describe("Kueuectl Create", ginkgo.Ordered, ginkgo.ContinueOnFail
 				gomega.Eventually(func(g gomega.Gomega) {
 					g.Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cqName, Namespace: ns.Name}, &createdQueue)).To(gomega.Succeed())
 					g.Expect(createdQueue.Name).Should(gomega.Equal(cqName))
-					g.Expect(createdQueue.Spec.Cohort).Should(gomega.Equal("cohort"))
+					g.Expect(createdQueue.Spec.Cohort).Should(gomega.Equal(v1beta1.CohortReference("cohort")))
 					g.Expect(createdQueue.Spec.QueueingStrategy).Should(gomega.Equal(v1beta1.StrictFIFO))
 					g.Expect(*createdQueue.Spec.NamespaceSelector).Should(gomega.Equal(metav1.LabelSelector{
 						MatchLabels: map[string]string{"fooX": "barX", "fooY": "barY"},
@@ -392,7 +392,7 @@ var _ = ginkgo.Describe("Kueuectl Create", ginkgo.Ordered, ginkgo.ContinueOnFail
 				gomega.Eventually(func(g gomega.Gomega) {
 					g.Expect(k8sClient.Get(ctx, types.NamespacedName{Name: cqName, Namespace: ns.Name}, &createdQueue)).To(gomega.Succeed())
 					g.Expect(createdQueue.Name).Should(gomega.Equal(cqName))
-					g.Expect(createdQueue.Spec.Cohort).Should(gomega.Equal("cohort"))
+					g.Expect(createdQueue.Spec.Cohort).Should(gomega.Equal(v1beta1.CohortReference("cohort")))
 					g.Expect(createdQueue.Spec.QueueingStrategy).Should(gomega.Equal(v1beta1.StrictFIFO))
 					g.Expect(*createdQueue.Spec.NamespaceSelector).Should(gomega.Equal(metav1.LabelSelector{
 						MatchLabels: map[string]string{"fooX": "barX", "fooY": "barY"},
diff --git a/test/integration/singlecluster/scheduler/preemption_test.go b/test/integration/singlecluster/scheduler/preemption_test.go
index 70a615232..4295c1a8a 100644
--- a/test/integration/singlecluster/scheduler/preemption_test.go
+++ b/test/integration/singlecluster/scheduler/preemption_test.go
@@ -29,6 +29,7 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/client"
 
 	kueue "sigs.k8s.io/kueue/apis/kueue/v1beta1"
+	"sigs.k8s.io/kueue/pkg/controller/constants"
 	"sigs.k8s.io/kueue/pkg/features"
 	"sigs.k8s.io/kueue/pkg/scheduler/preemption"
 	"sigs.k8s.io/kueue/pkg/util/testing"
@@ -187,6 +188,29 @@ var _ = ginkgo.Describe("Preemption", func() {
 			util.ExpectWorkloadsToHaveQuotaReservation(ctx, k8sClient, cq.Name, wl3)
 			util.ExpectWorkloadsToBePending(ctx, k8sClient, wl4)
 		})
+
+		ginkgo.It("Should include job UID in preemption condition when the label is set", func() {
+			ginkgo.By("Creating a low priority Workload")
+			lowWl := testing.MakeWorkload("low", ns.Name).
+				Queue(q.Name).
+				Priority(lowPriority).
+				Request(corev1.ResourceCPU, "4").
+				Obj()
+			gomega.Expect(k8sClient.Create(ctx, lowWl)).To(gomega.Succeed())
+
+			util.ExpectWorkloadsToHaveQuotaReservation(ctx, k8sClient, cq.Name, lowWl)
+
+			ginkgo.By("Creating a high priority Workload with JobUID label")
+			highWl := testing.MakeWorkload("high", ns.Name).
+				Label(constants.JobUIDLabel, "job-uid").
+				Queue(q.Name).
+				Priority(highPriority).
+				Request(corev1.ResourceCPU, "4").
+				Obj()
+			gomega.Expect(k8sClient.Create(ctx, highWl)).To(gomega.Succeed())
+
+			util.ExpectPreemptedCondition(ctx, k8sClient, kueue.InClusterQueueReason, metav1.ConditionTrue, lowWl, highWl, string(highWl.UID), "job-uid")
+		})
 	})
 
 	ginkgo.Context("In a ClusterQueue that is part of a cohort", func() {
@@ -278,8 +302,8 @@ var _ = ginkgo.Describe("Preemption", func() {
 
 			conditionCmpOpts := cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime")
 			ginkgo.By("Verify the Preempted condition", func() {
-				util.ExpectPreemptedCondition(ctx, k8sClient, kueue.InClusterQueueReason, metav1.ConditionTrue, alphaLowWl, alphaMidWl)
-				util.ExpectPreemptedCondition(ctx, k8sClient, kueue.InCohortReclamationReason, metav1.ConditionTrue, betaMidWl, alphaMidWl)
+				util.ExpectPreemptedCondition(ctx, k8sClient, kueue.InClusterQueueReason, metav1.ConditionTrue, alphaLowWl, alphaMidWl, string(alphaMidWl.UID), "UNKNOWN")
+				util.ExpectPreemptedCondition(ctx, k8sClient, kueue.InCohortReclamationReason, metav1.ConditionTrue, betaMidWl, alphaMidWl, string(alphaMidWl.UID), "UNKNOWN")
 				util.ExpectPreemptedWorkloadsTotalMetric(alphaCQ.Name, kueue.InClusterQueueReason, 1)
 				util.ExpectPreemptedWorkloadsTotalMetric(alphaCQ.Name, kueue.InCohortReclamationReason, 1)
 				util.ExpectPreemptedWorkloadsTotalMetric(betaCQ.Name, kueue.InClusterQueueReason, 0)
@@ -297,7 +321,7 @@ var _ = ginkgo.Describe("Preemption", func() {
 						Type:    kueue.WorkloadPreempted,
 						Status:  metav1.ConditionFalse,
 						Reason:  "QuotaReserved",
-						Message: fmt.Sprintf("Previously: Preempted to accommodate a workload (UID: %s) due to %s", alphaMidWl.UID, preemption.HumanReadablePreemptionReasons[kueue.InClusterQueueReason]),
+						Message: fmt.Sprintf("Previously: Preempted to accommodate a workload (UID: %s, JobUID: UNKNOWN) due to %s", alphaMidWl.UID, preemption.HumanReadablePreemptionReasons[kueue.InClusterQueueReason]),
 					}, conditionCmpOpts))
 				}, util.Timeout, util.Interval).Should(gomega.Succeed())
 
@@ -307,7 +331,7 @@ var _ = ginkgo.Describe("Preemption", func() {
 						Type:    kueue.WorkloadPreempted,
 						Status:  metav1.ConditionFalse,
 						Reason:  "QuotaReserved",
-						Message: fmt.Sprintf("Previously: Preempted to accommodate a workload (UID: %s) due to %s", alphaMidWl.UID, preemption.HumanReadablePreemptionReasons[kueue.InCohortReclamationReason]),
+						Message: fmt.Sprintf("Previously: Preempted to accommodate a workload (UID: %s, JobUID: UNKNOWN) due to %s", alphaMidWl.UID, preemption.HumanReadablePreemptionReasons[kueue.InCohortReclamationReason]),
 					}, conditionCmpOpts))
 				}, util.Timeout, util.Interval).Should(gomega.Succeed())
 			})
@@ -689,7 +713,7 @@ var _ = ginkgo.Describe("Preemption", func() {
 				Obj()
 			gomega.Expect(k8sClient.Create(ctx, aStandardVeryHighWl)).To(gomega.Succeed())
 
-			util.ExpectPreemptedCondition(ctx, k8sClient, kueue.InCohortReclaimWhileBorrowingReason, metav1.ConditionTrue, aBestEffortLowWl, aStandardVeryHighWl)
+			util.ExpectPreemptedCondition(ctx, k8sClient, kueue.InCohortReclaimWhileBorrowingReason, metav1.ConditionTrue, aBestEffortLowWl, aStandardVeryHighWl, string(aStandardVeryHighWl.UID), "UNKNOWN")
 			util.ExpectPreemptedWorkloadsTotalMetric(aStandardCQ.Name, kueue.InCohortReclaimWhileBorrowingReason, 1)
 			util.ExpectPreemptedWorkloadsTotalMetric(aBestEffortCQ.Name, kueue.InCohortReclaimWhileBorrowingReason, 0)
 
diff --git a/test/integration/singlecluster/scheduler/scheduler_test.go b/test/integration/singlecluster/scheduler/scheduler_test.go
index 4ccd0d699..27aeb4cf9 100644
--- a/test/integration/singlecluster/scheduler/scheduler_test.go
+++ b/test/integration/singlecluster/scheduler/scheduler_test.go
@@ -1660,7 +1660,7 @@ var _ = ginkgo.Describe("Scheduler", func() {
 		var (
 			strictFIFOClusterQ *kueue.ClusterQueue
 			matchingNS         *corev1.Namespace
-			chName             string
+			chName             kueue.CohortReference
 		)
 
 		ginkgo.BeforeEach(func() {
diff --git a/test/integration/singlecluster/tas/tas_test.go b/test/integration/singlecluster/tas/tas_test.go
index a2e3a6517..18c20a584 100644
--- a/test/integration/singlecluster/tas/tas_test.go
+++ b/test/integration/singlecluster/tas/tas_test.go
@@ -63,36 +63,35 @@ var _ = ginkgo.Describe("Topology Aware Scheduling", ginkgo.Ordered, func() {
 
 	ginkgo.When("Delete Topology", func() {
 		var (
-			topology *kueuealpha.Topology
+			tasFlavor *kueue.ResourceFlavor
+			topology  *kueuealpha.Topology
 		)
 
-		ginkgo.BeforeEach(func() {
-			topology = testing.MakeDefaultOneLevelTopology("topology")
-			gomega.Expect(k8sClient.Create(ctx, topology)).Should(gomega.Succeed())
-		})
-
 		ginkgo.AfterEach(func() {
+			util.ExpectObjectToBeDeleted(ctx, k8sClient, tasFlavor, true)
 			util.ExpectObjectToBeDeleted(ctx, k8sClient, topology, true)
 		})
 
-		ginkgo.It("should allow to delete topology", func() {
-			util.ExpectObjectToBeDeleted(ctx, k8sClient, topology, true)
-		})
+		ginkgo.When("ResourceFlavor does not exist", func() {
+			ginkgo.BeforeEach(func() {
+				topology = testing.MakeDefaultOneLevelTopology("topology")
+				gomega.Expect(k8sClient.Create(ctx, topology)).Should(gomega.Succeed())
+			})
 
-		ginkgo.When("ResourceFlavor exist", func() {
-			var (
-				tasFlavor *kueue.ResourceFlavor
-			)
+			ginkgo.It("should allow to delete topology", func() {
+				util.ExpectObjectToBeDeleted(ctx, k8sClient, topology, true)
+			})
+		})
 
+		ginkgo.When("ResourceFlavor exists", func() {
 			ginkgo.BeforeEach(func() {
 				tasFlavor = testing.MakeResourceFlavor("tas-flavor").
 					NodeLabel("node-group", "tas").
 					TopologyName(topology.Name).Obj()
 				gomega.Expect(k8sClient.Create(ctx, tasFlavor)).Should(gomega.Succeed())
-			})
 
-			ginkgo.AfterEach(func() {
-				util.ExpectObjectToBeDeleted(ctx, k8sClient, tasFlavor, true)
+				topology = testing.MakeDefaultOneLevelTopology("topology")
+				gomega.Expect(k8sClient.Create(ctx, topology)).Should(gomega.Succeed())
 			})
 
 			ginkgo.It("should not allow to delete topology", func() {
@@ -106,9 +105,7 @@ var _ = ginkgo.Describe("Topology Aware Scheduling", ginkgo.Ordered, func() {
 				})
 
 				ginkgo.By("delete topology", func() {
-					gomega.Eventually(func(g gomega.Gomega) {
-						g.Expect(k8sClient.Delete(ctx, topology)).Should(gomega.Succeed())
-					}, util.Timeout, util.Interval).Should(gomega.Succeed())
+					gomega.Expect(k8sClient.Delete(ctx, topology)).Should(gomega.Succeed())
 				})
 
 				ginkgo.By("check topology still present", func() {
diff --git a/test/performance/scheduler/runner/generator/generator.go b/test/performance/scheduler/runner/generator/generator.go
index 9cd810287..570db79ff 100644
--- a/test/performance/scheduler/runner/generator/generator.go
+++ b/test/performance/scheduler/runner/generator/generator.go
@@ -131,7 +131,7 @@ func generateWlSet(ctx context.Context, c client.Client, wlSet WorkloadsSet, nam
 	return nil
 }
 
-func generateQueue(ctx context.Context, c client.Client, qSet QueuesSet, cohortName string, queueSetIdx int, queueIndex int) error {
+func generateQueue(ctx context.Context, c client.Client, qSet QueuesSet, cohortName kueue.CohortReference, queueSetIdx int, queueIndex int) error {
 	log := ctrl.LoggerFrom(ctx).WithName("generate queue").WithValues("idx", queueIndex, "prefix", qSet.ClassName)
 	log.Info("Start generation")
 	defer log.Info("End generation")
@@ -170,7 +170,7 @@ func generateQueue(ctx context.Context, c client.Client, qSet QueuesSet, cohortN
 	})
 }
 
-func generateQueueSet(ctx context.Context, c client.Client, qSet QueuesSet, cohortName string, queueSetIdx int) error {
+func generateQueueSet(ctx context.Context, c client.Client, qSet QueuesSet, cohortName kueue.CohortReference, queueSetIdx int) error {
 	log := ctrl.LoggerFrom(ctx).WithName("generate queue set").WithValues("count", qSet.Count, "prefix", qSet.ClassName)
 	log.Info("Start generation")
 	defer log.Info("End generation")
@@ -185,7 +185,7 @@ func generateCohort(ctx context.Context, c client.Client, cSet CohortSet, cohort
 	defer log.Info("End generation")
 	cohortName := fmt.Sprintf("%s-%d", cSet.ClassName, cohortIdx)
 	return concurrent(cSet, func(cs CohortSet) int { return len(cs.QueuesSets) }, func(idx int) error {
-		return generateQueueSet(ctx, c, cSet.QueuesSets[idx], cohortName, idx)
+		return generateQueueSet(ctx, c, cSet.QueuesSets[idx], kueue.CohortReference(cohortName), idx)
 	})
 }
 
diff --git a/test/performance/scheduler/runner/recorder/recorder.go b/test/performance/scheduler/runner/recorder/recorder.go
index 737e2b248..e05914923 100644
--- a/test/performance/scheduler/runner/recorder/recorder.go
+++ b/test/performance/scheduler/runner/recorder/recorder.go
@@ -34,9 +34,9 @@ import (
 
 type CQEvent struct {
 	Time      time.Time
-	Name      string
+	Name      kueue.ClusterQueueReference
 	ClassName string
-	Cohort    string
+	Cohort    kueue.CohortReference
 	UID       types.UID
 
 	CPUReservation     int64
@@ -69,8 +69,8 @@ var CQStateCsvHeader = []string{
 func (cqs *CQState) CsvRecord() []string {
 	monitoringTimeMs := cqs.LastEvent.Time.Sub(cqs.FirstEventTime).Milliseconds()
 	return []string{
-		cqs.LastEvent.Name,
-		cqs.LastEvent.Cohort,
+		string(cqs.LastEvent.Name),
+		string(cqs.LastEvent.Cohort),
 		cqs.LastEvent.ClassName,
 		strconv.FormatInt(cqs.LastEvent.CPUQuota, 10),
 		strconv.FormatInt(cqs.CPUUsed, 10),
@@ -154,13 +154,13 @@ func New(maxRecording time.Duration) *Recorder {
 }
 
 func (r *Recorder) recordCQEvent(ev *CQEvent) {
-	state, found := r.Store.CQ[ev.Name]
+	state, found := r.Store.CQ[string(ev.Name)]
 	if !found {
 		state = &CQState{
 			FirstEventTime: ev.Time,
 			LastEvent:      ev,
 		}
-		r.Store.CQ[ev.Name] = state
+		r.Store.CQ[string(ev.Name)] = state
 	} else {
 		if state.LastEvent.CPUUsage > 0 {
 			state.CPUUsed += state.LastEvent.CPUUsage * ev.Time.Sub(state.LastEvent.Time).Milliseconds()
@@ -449,7 +449,7 @@ func (r *Recorder) RecordCQState(cq *kueue.ClusterQueue) {
 
 	r.cqEvChan <- &CQEvent{
 		Time:      time.Now(),
-		Name:      cq.Name,
+		Name:      kueue.ClusterQueueReference(cq.Name),
 		ClassName: cq.Labels[generator.ClassLabel],
 		Cohort:    cq.Spec.Cohort,
 		UID:       cq.UID,
diff --git a/test/util/util.go b/test/util/util.go
index da89131ac..8054d8e22 100644
--- a/test/util/util.go
+++ b/test/util/util.go
@@ -603,7 +603,7 @@ func ExpectLocalQueueResourceReservationsMetric(queue *kueue.LocalQueue, flavorN
 }
 
 func ExpectCQResourceNominalQuota(cq *kueue.ClusterQueue, flavor, resource string, value float64) {
-	metric := metrics.ClusterQueueResourceNominalQuota.WithLabelValues(cq.Spec.Cohort, cq.Name, flavor, resource)
+	metric := metrics.ClusterQueueResourceNominalQuota.WithLabelValues(string(cq.Spec.Cohort), cq.Name, flavor, resource)
 	gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
 		v, err := testutil.GetGaugeMetricValue(metric)
 		g.Expect(err).ToNot(gomega.HaveOccurred())
@@ -612,7 +612,7 @@ func ExpectCQResourceNominalQuota(cq *kueue.ClusterQueue, flavor, resource strin
 }
 
 func ExpectCQResourceBorrowingQuota(cq *kueue.ClusterQueue, flavor, resource string, value float64) {
-	metric := metrics.ClusterQueueResourceBorrowingLimit.WithLabelValues(cq.Spec.Cohort, cq.Name, flavor, resource)
+	metric := metrics.ClusterQueueResourceBorrowingLimit.WithLabelValues(string(cq.Spec.Cohort), cq.Name, flavor, resource)
 	gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
 		v, err := testutil.GetGaugeMetricValue(metric)
 		g.Expect(err).ToNot(gomega.HaveOccurred())
@@ -621,7 +621,7 @@ func ExpectCQResourceBorrowingQuota(cq *kueue.ClusterQueue, flavor, resource str
 }
 
 func ExpectCQResourceReservations(cq *kueue.ClusterQueue, flavor, resource string, value float64) {
-	metric := metrics.ClusterQueueResourceReservations.WithLabelValues(cq.Spec.Cohort, cq.Name, flavor, resource)
+	metric := metrics.ClusterQueueResourceReservations.WithLabelValues(string(cq.Spec.Cohort), cq.Name, flavor, resource)
 	gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
 		v, err := testutil.GetGaugeMetricValue(metric)
 		g.Expect(err).ToNot(gomega.HaveOccurred())
@@ -828,7 +828,7 @@ readCh:
 	gomega.ExpectWithOffset(1, gotObjs).To(gomega.Equal(objs))
 }
 
-func ExpectPreemptedCondition(ctx context.Context, k8sClient client.Client, reason string, status metav1.ConditionStatus, preemptedWl, preempteeWl *kueue.Workload) {
+func ExpectPreemptedCondition(ctx context.Context, k8sClient client.Client, reason string, status metav1.ConditionStatus, preemptedWl, preempteeWl *kueue.Workload, preemteeWorkloadUID, preempteeJobUID string) {
 	conditionCmpOpts := cmpopts.IgnoreFields(metav1.Condition{}, "LastTransitionTime", "ObservedGeneration")
 	gomega.EventuallyWithOffset(1, func(g gomega.Gomega) {
 		g.Expect(k8sClient.Get(ctx, client.ObjectKeyFromObject(preemptedWl), preemptedWl)).To(gomega.Succeed())
@@ -836,7 +836,7 @@ func ExpectPreemptedCondition(ctx context.Context, k8sClient client.Client, reas
 			Type:    kueue.WorkloadPreempted,
 			Status:  status,
 			Reason:  reason,
-			Message: fmt.Sprintf("Preempted to accommodate a workload (UID: %s) due to %s", preempteeWl.UID, preemption.HumanReadablePreemptionReasons[reason]),
+			Message: fmt.Sprintf("Preempted to accommodate a workload (UID: %s, JobUID: %s) due to %s", preemteeWorkloadUID, preempteeJobUID, preemption.HumanReadablePreemptionReasons[reason]),
 		}, conditionCmpOpts)))
 	}, Timeout, Interval).Should(gomega.Succeed())
 }
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go b/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go
index 73e265565..b4ecc7cb8 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go
@@ -1,6 +1,7 @@
 package testingtproxy
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"os"
@@ -19,9 +20,9 @@ type addReportEntryFunc func(names string, args ...any)
 type ginkgoWriterInterface interface {
 	io.Writer
 
-	Print(a ...interface{})
-	Printf(format string, a ...interface{})
-	Println(a ...interface{})
+	Print(a ...any)
+	Printf(format string, a ...any)
+	Println(a ...any)
 }
 type ginkgoRecoverFunc func()
 type attachProgressReporterFunc func(func() string) func()
@@ -80,11 +81,31 @@ func (t *ginkgoTestingTProxy) Setenv(key, value string) {
 	}
 }
 
-func (t *ginkgoTestingTProxy) Error(args ...interface{}) {
+func (t *ginkgoTestingTProxy) Chdir(dir string) {
+	currentDir, err := os.Getwd()
+	if err != nil {
+		t.fail(fmt.Sprintf("Failed to get current directory: %v", err), 1)
+	}
+
+	t.cleanup(os.Chdir, currentDir, internal.Offset(1))
+
+	err = os.Chdir(dir)
+	if err != nil {
+		t.fail(fmt.Sprintf("Failed to change directory: %v", err), 1)
+	}
+}
+
+func (t *ginkgoTestingTProxy) Context() context.Context {
+	ctx, cancel := context.WithCancel(context.Background())
+	t.cleanup(cancel, internal.Offset(1))
+	return ctx
+}
+
+func (t *ginkgoTestingTProxy) Error(args ...any) {
 	t.fail(fmt.Sprintln(args...), t.offset)
 }
 
-func (t *ginkgoTestingTProxy) Errorf(format string, args ...interface{}) {
+func (t *ginkgoTestingTProxy) Errorf(format string, args ...any) {
 	t.fail(fmt.Sprintf(format, args...), t.offset)
 }
 
@@ -100,11 +121,11 @@ func (t *ginkgoTestingTProxy) Failed() bool {
 	return t.report().Failed()
 }
 
-func (t *ginkgoTestingTProxy) Fatal(args ...interface{}) {
+func (t *ginkgoTestingTProxy) Fatal(args ...any) {
 	t.fail(fmt.Sprintln(args...), t.offset)
 }
 
-func (t *ginkgoTestingTProxy) Fatalf(format string, args ...interface{}) {
+func (t *ginkgoTestingTProxy) Fatalf(format string, args ...any) {
 	t.fail(fmt.Sprintf(format, args...), t.offset)
 }
 
@@ -112,11 +133,11 @@ func (t *ginkgoTestingTProxy) Helper() {
 	types.MarkAsHelper(1)
 }
 
-func (t *ginkgoTestingTProxy) Log(args ...interface{}) {
+func (t *ginkgoTestingTProxy) Log(args ...any) {
 	fmt.Fprintln(t.writer, args...)
 }
 
-func (t *ginkgoTestingTProxy) Logf(format string, args ...interface{}) {
+func (t *ginkgoTestingTProxy) Logf(format string, args ...any) {
 	t.Log(fmt.Sprintf(format, args...))
 }
 
@@ -128,7 +149,7 @@ func (t *ginkgoTestingTProxy) Parallel() {
 	// No-op
 }
 
-func (t *ginkgoTestingTProxy) Skip(args ...interface{}) {
+func (t *ginkgoTestingTProxy) Skip(args ...any) {
 	t.skip(fmt.Sprintln(args...), t.offset)
 }
 
@@ -136,7 +157,7 @@ func (t *ginkgoTestingTProxy) SkipNow() {
 	t.skip("skip", t.offset)
 }
 
-func (t *ginkgoTestingTProxy) Skipf(format string, args ...interface{}) {
+func (t *ginkgoTestingTProxy) Skipf(format string, args ...any) {
 	t.skip(fmt.Sprintf(format, args...), t.offset)
 }