From cd0298d93508b012604cad54f083e3d86acb549e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 25 Oct 2026 09:06:20 +0000
Subject: [PATCH 1/6] chore(deps): Bump github/codeql-action from 4.38.3 to
 4.39.1

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.38.3 to 4.39.1.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/v4.38.3...v4.39.1)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.39.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Carlos Eduardo Arango Gutierrez <eduardoa@nvidia.com>
---
 .github/workflows/code_scanning.yaml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/code_scanning.yaml b/.github/workflows/code_scanning.yaml
index c9fcec1a..d74bc680 100644
--- a/.github/workflows/code_scanning.yaml
+++ b/.github/workflows/code_scanning.yaml
@@ -39,7 +39,7 @@ jobs:
       uses: actions/checkout@v7
 
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v4.38.3
+      uses: github/codeql-action/init@v4.39.1
       with:
         config-file: ./.github/codeql/codeql-config.yaml
         languages: go
@@ -50,6 +50,6 @@ jobs:
         make build-cli
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v4.38.3
+      uses: github/codeql-action/analyze@v4.39.1
       with:
         category: "/language:go"

From a9774f286ff317b97d95ee34ec21400d8ce619d2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 16 Oct 2026 00:33:28 +0000
Subject: [PATCH 2/6] chore(deps): Bump NVIDIA/holodeck from 0.4.0 to 0.5.0

Bumps [NVIDIA/holodeck](https://github.com/nvidia/holodeck) from 0.4.0 to 0.5.0.
- [Release notes](https://github.com/nvidia/holodeck/releases)
- [Changelog](https://github.com/NVIDIA/holodeck/blob/main/CHANGELOG.md)
- [Commits](https://github.com/nvidia/holodeck/compare/v0.4.0...v0.5.0)

---
updated-dependencies:
- dependency-name: NVIDIA/holodeck
  dependency-version: 0.5.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Carlos Eduardo Arango Gutierrez <eduardoa@nvidia.com>
---
 .github/workflows/periodic.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/periodic.yaml b/.github/workflows/periodic.yaml
index a30ebe19..9fae4b7f 100644
--- a/.github/workflows/periodic.yaml
+++ b/.github/workflows/periodic.yaml
@@ -39,7 +39,7 @@ jobs:
 
       - name: Clean up VPCs
         if: steps.identify-resources.outputs.AWS_VPC_IDS != ''
-        uses: NVIDIA/holodeck@v0.4.0
+        uses: NVIDIA/holodeck@v0.5.0
         with:
           action: cleanup
           vpc_ids: ${{ steps.identify-resources.outputs.AWS_VPC_IDS }}

From 937830bc9722233fa3b2b875d09199ef1476509b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 11:09:46 +0000
Subject: [PATCH 3/6] chore(deps): Bump golang.org/x/crypto from 0.57.0 to
 0.58.0

Bumps [golang.org/x/crypto](https://github.com/golang/crypto) from 0.57.0 to 0.58.0.
- [Commits](https://github.com/golang/crypto/compare/v0.57.0...v0.58.0)

---
updated-dependencies:
- dependency-name: golang.org/x/crypto
  dependency-version: 0.58.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Carlos Eduardo Arango Gutierrez <eduardoa@nvidia.com>
---
 go.mod                                        |   8 +-
 go.sum                                        |  20 +-
 .../x/crypto/chacha20/chacha_loong64.go       |  22 +
 .../x/crypto/chacha20/chacha_loong64.s        | 342 +++++++++++
 .../x/crypto/chacha20/chacha_noasm.go         |   2 +-
 .../golang.org/x/crypto/ssh/agent/client.go   |   3 +
 vendor/golang.org/x/crypto/ssh/certs.go       |  12 +
 vendor/golang.org/x/crypto/ssh/cipher.go      | 212 ++++---
 vendor/golang.org/x/crypto/ssh/common.go      |  17 +-
 vendor/golang.org/x/crypto/ssh/doc.go         |   1 +
 vendor/golang.org/x/crypto/ssh/keys.go        |  75 ++-
 .../x/crypto/ssh/knownhosts/knownhosts.go     |   4 +-
 vendor/golang.org/x/crypto/ssh/mldsa.go       | 133 +++++
 .../x/crypto/ssh/mldsa_unsupported.go         |  29 +
 vendor/golang.org/x/sys/cpu/cpu.go            |   5 +
 vendor/golang.org/x/sys/cpu/cpu_x86.go        |  23 +
 .../golang.org/x/sys/unix/asm_linux_ppc64x.s  |  20 +
 .../golang.org/x/sys/unix/asm_linux_sparc64.s |  48 ++
 vendor/golang.org/x/sys/unix/asm_zos_s390x.s  | 190 +------
 vendor/golang.org/x/sys/unix/bpxsvc_zos.s     |  18 +-
 vendor/golang.org/x/sys/unix/fcntl_darwin.go  |   4 +-
 vendor/golang.org/x/sys/unix/mkerrors.sh      |   2 +-
 vendor/golang.org/x/sys/unix/ptrace_zos.go    | 537 ++++++++++++++++++
 .../x/sys/unix/ptrace_zos_singlestep.go       | 425 ++++++++++++++
 .../golang.org/x/sys/unix/syscall_darwin.go   |   1 +
 .../golang.org/x/sys/unix/syscall_freebsd.go  |   9 +
 vendor/golang.org/x/sys/unix/syscall_linux.go |  21 +-
 .../x/sys/unix/syscall_linux_sparc64.go       |   6 +-
 .../golang.org/x/sys/unix/syscall_netbsd.go   |   9 +
 .../golang.org/x/sys/unix/syscall_unix_gc.go  |   2 +-
 .../x/sys/unix/syscall_unix_gc_ppc64x.go      |  22 -
 .../x/sys/unix/syscall_zos_s390x.go           |   4 -
 vendor/golang.org/x/sys/unix/xattr_bsd.go     |  24 +-
 .../x/sys/unix/zerrors_darwin_amd64.go        |   6 +
 .../x/sys/unix/zerrors_darwin_arm64.go        |   6 +
 vendor/golang.org/x/sys/unix/zerrors_linux.go |  32 ++
 .../x/sys/unix/zerrors_linux_386.go           |   2 +
 .../x/sys/unix/zerrors_linux_amd64.go         |   2 +
 .../x/sys/unix/zerrors_linux_arm.go           |   2 +
 .../x/sys/unix/zerrors_linux_arm64.go         |   2 +
 .../x/sys/unix/zerrors_linux_loong64.go       |   2 +
 .../x/sys/unix/zerrors_linux_mips.go          |   2 +
 .../x/sys/unix/zerrors_linux_mips64.go        |   2 +
 .../x/sys/unix/zerrors_linux_mips64le.go      |   2 +
 .../x/sys/unix/zerrors_linux_mipsle.go        |   2 +
 .../x/sys/unix/zerrors_linux_ppc.go           |   2 +
 .../x/sys/unix/zerrors_linux_ppc64.go         |   2 +
 .../x/sys/unix/zerrors_linux_ppc64le.go       |   2 +
 .../x/sys/unix/zerrors_linux_riscv64.go       |   2 +
 .../x/sys/unix/zerrors_linux_s390x.go         |   2 +
 .../x/sys/unix/zerrors_linux_sparc64.go       |   2 +
 .../x/sys/unix/zsyscall_darwin_amd64.go       |  11 +
 .../x/sys/unix/zsyscall_darwin_arm64.go       |  11 +
 .../x/sys/unix/zsyscall_freebsd_386.go        | 159 ++++++
 .../x/sys/unix/zsyscall_freebsd_amd64.go      | 159 ++++++
 .../x/sys/unix/zsyscall_freebsd_arm.go        | 159 ++++++
 .../x/sys/unix/zsyscall_freebsd_arm64.go      | 159 ++++++
 .../x/sys/unix/zsyscall_freebsd_riscv64.go    | 159 ++++++
 .../golang.org/x/sys/unix/zsyscall_linux.go   |  29 +-
 .../x/sys/unix/zsyscall_linux_sparc64.go      |   6 +-
 .../x/sys/unix/zsyscall_netbsd_386.go         | 159 ++++++
 .../x/sys/unix/zsyscall_netbsd_amd64.go       | 159 ++++++
 .../x/sys/unix/zsyscall_netbsd_arm.go         | 159 ++++++
 .../x/sys/unix/zsyscall_netbsd_arm64.go       | 159 ++++++
 .../x/sys/unix/zsysnum_zos_s390x.go           |  13 +
 vendor/golang.org/x/sys/unix/ztypes_linux.go  | 101 ++--
 .../golang.org/x/sys/unix/ztypes_linux_386.go |   6 +
 .../x/sys/unix/ztypes_linux_amd64.go          |   7 +
 .../golang.org/x/sys/unix/ztypes_linux_arm.go |   6 +
 .../x/sys/unix/ztypes_linux_arm64.go          |   7 +
 .../x/sys/unix/ztypes_linux_loong64.go        |   7 +
 .../x/sys/unix/ztypes_linux_mips.go           |   6 +
 .../x/sys/unix/ztypes_linux_mips64.go         |   7 +
 .../x/sys/unix/ztypes_linux_mips64le.go       |   7 +
 .../x/sys/unix/ztypes_linux_mipsle.go         |   6 +
 .../golang.org/x/sys/unix/ztypes_linux_ppc.go |   6 +
 .../x/sys/unix/ztypes_linux_ppc64.go          |   7 +
 .../x/sys/unix/ztypes_linux_ppc64le.go        |   7 +
 .../x/sys/unix/ztypes_linux_riscv64.go        |   7 +
 .../x/sys/unix/ztypes_linux_s390x.go          |   7 +
 .../x/sys/unix/ztypes_linux_sparc64.go        |  15 +-
 .../golang.org/x/sys/unix/ztypes_zos_s390x.go |  78 +++
 .../x/sys/windows/types_windows_arm.go        |  35 --
 .../x/text/secure/bidirule/bidirule.go        |   8 +-
 vendor/golang.org/x/text/unicode/bidi/core.go | 105 ++--
 .../x/tools/go/gcexportdata/gcexportdata.go   | 125 ++--
 .../golang.org/x/tools/go/packages/golist.go  |  82 +--
 .../x/tools/go/packages/golist_overlay.go     |  11 +-
 .../x/tools/go/packages/packages.go           |   2 +-
 .../x/tools/go/types/objectpath/objectpath.go |  12 +-
 .../x/tools/internal/aliases/aliases.go       |  18 -
 .../x/tools/internal/gcimporter/bimport.go    |   1 +
 .../x/tools/internal/gcimporter/exportdata.go |   1 +
 .../x/tools/internal/gcimporter/gcimporter.go |  14 +
 .../x/tools/internal/gcimporter/iexport.go    |  23 +-
 .../x/tools/internal/gcimporter/iimport.go    |  32 +-
 .../tools/internal/gcimporter/predeclared.go  |   1 +
 .../x/tools/internal/gcimporter/support.go    |   1 +
 .../x/tools/internal/gcimporter/ureader.go    |  64 ++-
 .../x/tools/internal/pkgbits/codes.go         |   2 +
 .../x/tools/internal/pkgbits/decoder.go       |   1 +
 .../x/tools/internal/pkgbits/doc.go           |   2 +
 .../x/tools/internal/pkgbits/encoder.go       |   1 +
 .../x/tools/internal/pkgbits/reloc.go         |   2 +
 .../x/tools/internal/pkgbits/support.go       |   1 +
 .../x/tools/internal/pkgbits/sync.go          |   1 +
 .../x/tools/internal/pkgbits/version.go       |  11 +
 .../x/tools/internal/stdlib/deps.go           |   6 +-
 .../x/tools/internal/typesinternal/isnamed.go |  10 +-
 .../x/tools/internal/typesinternal/recv.go    |  35 +-
 .../x/tools/internal/typesinternal/types.go   |  16 +-
 .../x/tools/internal/typesinternal/varkind.go |  23 -
 .../internal/typesinternal/varkind_go124.go   |  39 --
 vendor/modules.txt                            |  11 +-
 114 files changed, 4052 insertions(+), 756 deletions(-)
 create mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_loong64.go
 create mode 100644 vendor/golang.org/x/crypto/chacha20/chacha_loong64.s
 create mode 100644 vendor/golang.org/x/crypto/ssh/mldsa.go
 create mode 100644 vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go
 create mode 100644 vendor/golang.org/x/sys/unix/asm_linux_sparc64.s
 create mode 100644 vendor/golang.org/x/sys/unix/ptrace_zos.go
 create mode 100644 vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go
 delete mode 100644 vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go
 delete mode 100644 vendor/golang.org/x/sys/windows/types_windows_arm.go
 delete mode 100644 vendor/golang.org/x/tools/internal/aliases/aliases.go
 delete mode 100644 vendor/golang.org/x/tools/internal/typesinternal/varkind.go
 delete mode 100644 vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go

diff --git a/go.mod b/go.mod
index 1db0e5d1..b1089210 100644
--- a/go.mod
+++ b/go.mod
@@ -14,7 +14,7 @@ require (
 	github.com/pkg/sftp v1.13.11
 	github.com/stretchr/testify v1.11.1
 	github.com/urfave/cli/v3 v3.10.1
-	golang.org/x/crypto v0.57.0
+	golang.org/x/crypto v0.58.0
 	golang.org/x/sync v0.24.0
 	gopkg.in/yaml.v3 v3.0.1
 	k8s.io/apimachinery v0.37.1
@@ -51,9 +51,9 @@ require (
 	go.yaml.in/yaml/v3 v3.0.4 // indirect
 	golang.org/x/mod v0.41.0 // indirect
 	golang.org/x/net v0.60.0 // indirect
-	golang.org/x/sys v0.48.0 // indirect
-	golang.org/x/text v0.42.0 // indirect
-	golang.org/x/tools v0.49.0 // indirect
+	golang.org/x/sys v0.49.0 // indirect
+	golang.org/x/text v0.43.0 // indirect
+	golang.org/x/tools v0.51.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	k8s.io/klog/v2 v2.140.0 // indirect
 	k8s.io/kube-openapi v0.0.0-20260721132016-d427ff9ee9ad // indirect
diff --git a/go.sum b/go.sum
index f9e2cc2d..2943b054 100644
--- a/go.sum
+++ b/go.sum
@@ -112,22 +112,22 @@ go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
 go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
 go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
-golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
+golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
+golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
 golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c=
 golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o=
 golang.org/x/net v0.60.0 h1:79p50tfZlm0J9YfoDsSi639qSXNGVwEzOPLCxM2FsYU=
 golang.org/x/net v0.60.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
 golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA=
 golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0=
-golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
-golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
-golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE=
-golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc=
-golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
-golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
-golang.org/x/tools v0.49.0 h1:3NI7VXzL9+1WZD52Dx2ttoPwD5DWrFGpl9mFZDlmisI=
-golang.org/x/tools v0.49.0/go.mod h1:SJNXV9DBKT0UbdttsQjbfJlAE/q+y36++zo3uL3N0Oo=
+golang.org/x/sys v0.49.0 h1:XbzkgYJHdqh/8m2Uu0W/dQv8nktxx4BFHp1M0gROTXA=
+golang.org/x/sys v0.49.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
+golang.org/x/term v0.47.0 h1:cpyOwQkr2Nzxe2p6KnrTG7Ei2wtzjsuSjhpXXepZ/BM=
+golang.org/x/term v0.47.0/go.mod h1:efAfAuG6RKABvg1ArGebRkvX6LXul14SM67o2e4mUCY=
+golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc=
+golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s=
+golang.org/x/tools v0.51.0 h1:k4Xc/1Om9jwkBJBo4NVLMSARBoWtK10mx+W5BnXCeAI=
+golang.org/x/tools v0.51.0/go.mod h1:9eEncMayCV6zRMGhR5eZEC2iBx98qWcF1HZ9Z7wJOoA=
 google.golang.org/protobuf v1.36.12-0.20260120151049-f2248ac996af h1:+5/Sw3GsDNlEmu7TfklWKPdQ0Ykja5VEmq2i817+jbI=
 google.golang.org/protobuf v1.36.12-0.20260120151049-f2248ac996af/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/vendor/golang.org/x/crypto/chacha20/chacha_loong64.go b/vendor/golang.org/x/crypto/chacha20/chacha_loong64.go
new file mode 100644
index 00000000..9679f9ee
--- /dev/null
+++ b/vendor/golang.org/x/crypto/chacha20/chacha_loong64.go
@@ -0,0 +1,22 @@
+// Copyright 2026 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 gc && !purego
+
+package chacha20
+
+import "golang.org/x/sys/cpu"
+
+const bufSize = 256
+
+//go:noescape
+func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32)
+
+func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) {
+	if cpu.Loong64.HasLSX {
+		xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter)
+	} else {
+		c.xorKeyStreamBlocksGeneric(dst, src)
+	}
+}
diff --git a/vendor/golang.org/x/crypto/chacha20/chacha_loong64.s b/vendor/golang.org/x/crypto/chacha20/chacha_loong64.s
new file mode 100644
index 00000000..e377b432
--- /dev/null
+++ b/vendor/golang.org/x/crypto/chacha20/chacha_loong64.s
@@ -0,0 +1,342 @@
+// Copyright 2026 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.
+
+// derived from chacha_arm64.s
+
+//go:build gc && !purego
+
+#include "textflag.h"
+
+DATA	·constants+0x00(SB)/4, $0x61707865
+DATA	·constants+0x04(SB)/4, $0x3320646e
+DATA	·constants+0x08(SB)/4, $0x79622d32
+DATA	·constants+0x0c(SB)/4, $0x6b206574
+GLOBL	·constants(SB), NOPTR|RODATA, $32
+
+DATA	·incRotMatrix+0x00(SB)/4, $0x00000000
+DATA	·incRotMatrix+0x04(SB)/4, $0x00000001
+DATA	·incRotMatrix+0x08(SB)/4, $0x00000002
+DATA	·incRotMatrix+0x0c(SB)/4, $0x00000003
+GLOBL	·incRotMatrix(SB), NOPTR|RODATA, $32
+
+#define NUM_ROUNDS 10
+
+// func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32)
+TEXT ·xorKeyStreamVX(SB), NOSPLIT, $0
+	MOVV	dst+0(FP), R4
+	MOVV	src+24(FP), R5
+	MOVV	src_len+32(FP), R6
+	MOVV	key+48(FP), R7
+	MOVV	nonce+56(FP), R8
+	MOVV	counter+64(FP), R9
+
+	MOVV	$·constants(SB), R10
+	MOVV	$·incRotMatrix(SB), R11
+
+	MOVW	(R9), R12
+
+loop:
+	MOVV	$NUM_ROUNDS, R15
+	// load 4-32bit data from incRotMatrix added to counter
+	VMOVQ	(R11), V30
+
+	// load contants
+	VMOVQ	(R10), V0.W4
+	VMOVQ	4(R10), V1.W4
+	VMOVQ	8(R10), V2.W4
+	VMOVQ	12(R10), V3.W4
+
+	// load keys
+	VMOVQ	(R7), V4.W4
+	VMOVQ	4(R7), V5.W4
+	VMOVQ	8(R7), V6.W4
+	VMOVQ	12(R7), V7.W4
+	VMOVQ	16(R7), V8.W4
+	VMOVQ	20(R7), V9.W4
+	VMOVQ	24(R7), V10.W4
+	VMOVQ	28(R7), V11.W4
+
+	// load counter + nonce
+	VMOVQ	(R9), V12.W4
+
+	VMOVQ	(R8), V13.W4
+	VMOVQ	4(R8), V14.W4
+	VMOVQ	8(R8), V15.W4
+
+	// update counter
+	VADDW	V30, V12, V12
+
+chacha:
+	// V0..V3 += V4..V7
+	// V12..V15 <<<= ((V12..V15 XOR V0..V3), 16)
+	VADDW	V0, V4, V0
+	VADDW	V1, V5, V1
+	VADDW	V2, V6, V2
+	VADDW	V3, V7, V3
+	VXORV	V12, V0, V12
+	VXORV	V13, V1, V13
+	VXORV	V14, V2, V14
+	VXORV	V15, V3, V15
+	VROTRW	$16, V12, V12
+	VROTRW	$16, V13, V13
+	VROTRW	$16, V14, V14
+	VROTRW	$16, V15, V15
+
+	// V8..V11 += V12..V15
+	// V4..V7 <<<= ((V4..V7 XOR V8..V11), 12)
+	VADDW	V8, V12, V8
+	VADDW	V9, V13, V9
+	VADDW	V10, V14, V10
+	VADDW	V11, V15, V11
+	VXORV	V4, V8, V4
+	VXORV	V5, V9, V5
+	VXORV	V6, V10, V6
+	VXORV	V7, V11, V7
+	VROTRW	$20, V4, V4
+	VROTRW	$20, V5, V5
+	VROTRW	$20, V6, V6
+	VROTRW	$20, V7, V7
+
+	// V0..V3 += V4..V7
+	// V12..V15 <<<= ((V12..V15 XOR V0..V3), 8)
+	VADDW	V0, V4, V0
+	VADDW	V1, V5, V1
+	VADDW	V2, V6, V2
+	VADDW	V3, V7, V3
+	VXORV	V12, V0, V12
+	VXORV	V13, V1, V13
+	VXORV	V14, V2, V14
+	VXORV	V15, V3, V15
+	VROTRW	$24, V12, V12
+	VROTRW	$24, V13, V13
+	VROTRW	$24, V14, V14
+	VROTRW	$24, V15, V15
+
+	// V8..V11 += V12..V15
+	// V4..V7 <<<= ((V4..V7 XOR V8..V11), 7)
+	VADDW	V12, V8, V8
+	VADDW	V13, V9, V9
+	VADDW	V14, V10, V10
+	VADDW	V15, V11, V11
+	VXORV	V4, V8, V4
+	VXORV	V5, V9, V5
+	VXORV	V6, V10, V6
+	VXORV	V7, V11, V7
+	VROTRW	$25, V4, V4
+	VROTRW	$25, V5, V5
+	VROTRW	$25, V6, V6
+	VROTRW	$25, V7, V7
+
+	// V0..V3 += V5..V7, V4
+	// V15,V12-V14 <<<= ((V15,V12-V14 XOR V0..V3), 16)
+	VADDW	V0, V5, V0
+	VADDW	V1, V6, V1
+	VADDW	V2, V7, V2
+	VADDW	V3, V4, V3
+	VXORV	V15, V0, V15
+	VXORV	V12, V1, V12
+	VXORV	V13, V2, V13
+	VXORV	V14, V3, V14
+	VROTRW	$16, V15, V15
+	VROTRW	$16, V12, V12
+	VROTRW	$16, V13, V13
+	VROTRW	$16, V14, V14
+
+	// V10,V11,V8,V9 += V15,V12,V13,V14
+	// V5,V6,V7,V4 <<<= ((V5,V6,V7,V4 XOR V10,V11,V8,V9), 12)
+	VADDW	V10, V15, V10
+	VADDW	V11, V12, V11
+	VADDW	V8, V13, V8
+	VADDW	V9, V14, V9
+	VXORV	V5, V10, V5
+	VXORV	V6, V11, V6
+	VXORV	V7, V8, V7
+	VXORV	V4, V9, V4
+	VROTRW	$20, V5, V5
+	VROTRW	$20, V6, V6
+	VROTRW	$20, V7, V7
+	VROTRW	$20, V4, V4
+
+	// V0..V3 += V5..V7, V4
+	// V15,V12-V14 <<<= ((V15,V12-V14 XOR V0..V3), 8)
+	VADDW	V5, V0, V0
+	VADDW	V6, V1, V1
+	VADDW	V7, V2, V2
+	VADDW	V4, V3, V3
+	VXORV	V15, V0, V15
+	VXORV	V12, V1, V12
+	VXORV	V13, V2, V13
+	VXORV	V14, V3, V14
+	VROTRW	$24, V15, V15
+	VROTRW	$24, V12, V12
+	VROTRW	$24, V13, V13
+	VROTRW	$24, V14, V14
+
+	// V10,V11,V8,V9 += V15,V12,V13,V14
+	// V5,V6,V7,V4 <<<= ((V5,V6,V7,V4 XOR V10,V11,V8,V9), 7)
+	VADDW	V15, V10, V10
+	VADDW	V12, V11, V11
+	VADDW	V13, V8, V8
+	VADDW	V14, V9, V9
+	VXORV	V5, V10, V5
+	VXORV	V6, V11, V6
+	VXORV	V7, V8, V7
+	VXORV	V4, V9, V4
+	VROTRW	$25, V5, V5
+	VROTRW	$25, V6, V6
+	VROTRW	$25, V7, V7
+	VROTRW	$25, V4, V4
+
+	SUBV	$1, R15
+	BNE	R15, R0, chacha
+
+	// load origin contants
+	VMOVQ	(R10), V16.W4
+	VMOVQ	4(R10), V17.W4
+	VMOVQ	8(R10), V18.W4
+	VMOVQ	12(R10), V19.W4
+
+	// load origin keys
+	VMOVQ	(R7), V20.W4
+	VMOVQ	4(R7), V21.W4
+	VMOVQ	8(R7), V22.W4
+	VMOVQ	12(R7), V23.W4
+	VMOVQ	16(R7), V24.W4
+	VMOVQ	20(R7), V25.W4
+	VMOVQ	24(R7), V26.W4
+	VMOVQ	28(R7), V27.W4
+
+	// add back the initial state to generate the key stream
+	VADDW	V30, V12, V12	// update counter in advance to prevent V30 from being overwritten
+	VADDW	V16, V0, V0
+	VADDW	V17, V1, V1
+	VADDW	V18, V2, V2
+	VADDW	V19, V3, V3
+
+	// load origin counter + nonce
+	VMOVQ	(R9), V28.W4
+	VMOVQ	(R8), V29.W4
+	VMOVQ	4(R8), V30.W4
+	VMOVQ	8(R8), V31.W4
+
+	VADDW	V20, V4, V4
+	VADDW	V21, V5, V5
+	VADDW	V22, V6, V6
+	VADDW	V23, V7, V7
+	VADDW	V24, V8, V8
+	VADDW	V25, V9, V9
+	VADDW	V26, V10, V10
+	VADDW	V27, V11, V11
+	VADDW	V28, V12, V12
+	VADDW	V29, V13, V13
+	VADDW	V30, V14, V14
+	VADDW	V31, V15, V15
+
+	// shuffle
+	VILVLW	V0, V1, V16
+	VILVHW	V0, V1, V17
+	VILVLW	V2, V3, V18
+	VILVHW	V2, V3, V19
+	VILVLW	V4, V5 ,V20
+	VILVHW	V4, V5, V21
+	VILVLW	V6, V7, V22
+	VILVHW	V6, V7, V23
+	VILVLW	V8, V9, V24
+	VILVHW	V8, V9, V25
+	VILVLW	V10, V11, V26
+	VILVHW	V10, V11, V27
+	VILVLW	V12, V13, V28
+	VILVHW	V12, V13, V29
+	VILVLW	V14, V15, V30
+	VILVHW	V14, V15, V31
+	VILVLV	V16, V18, V0
+	VILVHV	V16, V18, V4
+	VILVLV	V17, V19, V8
+	VILVHV	V17, V19, V12
+
+	// load src data from R5
+	VMOVQ	0(R5), V16
+	VMOVQ	16(R5), V17
+	VMOVQ	32(R5), V18
+	VMOVQ	48(R5), V19
+
+	VILVLV	V20, V22, V1
+	VILVHV	V20, V22, V5
+	VILVLV	V21, V23, V9
+	VILVHV	V21, V23, V13
+
+	VMOVQ	64(R5), V20
+	VMOVQ	80(R5), V21
+	VMOVQ	96(R5), V22
+	VMOVQ	112(R5), V23
+
+	VILVLV	V24, V26, V2
+	VILVHV	V24, V26, V6
+	VILVLV	V25, V27, V10
+	VILVHV	V25, V27, V14
+
+	VMOVQ	128(R5), V24
+	VMOVQ	144(R5), V25
+	VMOVQ	160(R5), V26
+	VMOVQ	176(R5), V27
+
+	VILVLV	V28, V30, V3
+	VILVHV	V28, V30, V7
+	VILVLV	V29, V31, V11
+	VILVHV	V29, V31, V15
+
+	VMOVQ	192(R5), V28
+	VMOVQ	208(R5), V29
+	VMOVQ	224(R5), V30
+	VMOVQ	240(R5), V31
+
+	VXORV	V0, V16, V16
+	VXORV	V1, V17, V17
+	VXORV	V2, V18, V18
+	VXORV	V3, V19, V19
+
+	VMOVQ	V16, 0(R4)
+	VMOVQ	V17, 16(R4)
+	VMOVQ	V18, 32(R4)
+	VMOVQ	V19, 48(R4)
+
+	VXORV	V4, V20, V20
+	VXORV	V5, V21, V21
+	VXORV	V6, V22, V22
+	VXORV	V7, V23, V23
+
+	VMOVQ	V20, 64(R4)
+	VMOVQ	V21, 80(R4)
+	VMOVQ	V22, 96(R4)
+	VMOVQ	V23, 112(R4)
+
+	VXORV	V8, V24, V24
+	VXORV	V9, V25, V25
+	VXORV	V10, V26, V26
+	VXORV	V11, V27, V27
+
+	VMOVQ	V24, 128(R4)
+	VMOVQ	V25, 144(R4)
+	VMOVQ	V26, 160(R4)
+	VMOVQ	V27, 176(R4)
+
+	VXORV	V12, V28, V28
+	VXORV	V13, V29, V29
+	VXORV	V14, V30, V30
+	VXORV	V15, V31, V31
+
+	VMOVQ	V28, 192(R4)
+	VMOVQ	V29, 208(R4)
+	VMOVQ	V30, 224(R4)
+	VMOVQ	V31, 240(R4)
+
+	ADD	$4, R12, R12
+	MOVW	R12, (R9) // update counter
+
+	ADDV	$256, R4, R4
+	ADDV	$256, R5, R5
+	SUBV    $256, R6, R6
+	BNE     R6, R0, loop
+
+	RET
diff --git a/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go b/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go
index c709b728..3853cc0e 100644
--- a/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go
+++ b/vendor/golang.org/x/crypto/chacha20/chacha_noasm.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (!arm64 && !s390x && !ppc64 && !ppc64le) || !gc || purego
+//go:build (!arm64 && !loong64 && !s390x && !ppc64 && !ppc64le) || !gc || purego
 
 package chacha20
 
diff --git a/vendor/golang.org/x/crypto/ssh/agent/client.go b/vendor/golang.org/x/crypto/ssh/agent/client.go
index eb96184e..fad53dcc 100644
--- a/vendor/golang.org/x/crypto/ssh/agent/client.go
+++ b/vendor/golang.org/x/crypto/ssh/agent/client.go
@@ -878,6 +878,9 @@ var certKeyAlgoNames = map[string]string{
 	ssh.CertAlgoSKECDSA256v01:  ssh.KeyAlgoSKECDSA256,
 	ssh.CertAlgoED25519v01:     ssh.KeyAlgoED25519,
 	ssh.CertAlgoSKED25519v01:   ssh.KeyAlgoSKED25519,
+	ssh.CertAlgoMLDSA44v01Go:   ssh.KeyAlgoMLDSA44,
+	ssh.CertAlgoMLDSA65v01Go:   ssh.KeyAlgoMLDSA65,
+	ssh.CertAlgoMLDSA87v01Go:   ssh.KeyAlgoMLDSA87,
 }
 
 // underlyingAlgo returns the signature algorithm associated with algo (which is
diff --git a/vendor/golang.org/x/crypto/ssh/certs.go b/vendor/golang.org/x/crypto/ssh/certs.go
index a3b802e4..8788a94b 100644
--- a/vendor/golang.org/x/crypto/ssh/certs.go
+++ b/vendor/golang.org/x/crypto/ssh/certs.go
@@ -35,6 +35,15 @@ const (
 	CertAlgoED25519v01     = "ssh-ed25519-cert-v01@openssh.com"
 	CertAlgoSKED25519v01   = "sk-ssh-ed25519-cert-v01@openssh.com"
 
+	// CertAlgoMLDSA44v01Go, CertAlgoMLDSA65v01Go and CertAlgoMLDSA87v01Go
+	// are certificate algorithms based on ML-DSA. No specification defines
+	// them, so these are vendor names as per RFC 4251, Section 4.2. The
+	// format is that of [SSH-CERTS], with the public key encoded as in
+	// [SSH-MLDSA], Section 4.
+	CertAlgoMLDSA44v01Go = "ssh-mldsa-44-cert-v01@golang.org"
+	CertAlgoMLDSA65v01Go = "ssh-mldsa-65-cert-v01@golang.org"
+	CertAlgoMLDSA87v01Go = "ssh-mldsa-87-cert-v01@golang.org"
+
 	// CertAlgoRSASHA256v01 and CertAlgoRSASHA512v01 can't appear as a
 	// Certificate.Type (or PublicKey.Type), but only in
 	// ClientConfig.HostKeyAlgorithms.
@@ -525,6 +534,9 @@ var certKeyAlgoNames = map[string]string{
 	CertAlgoSKECDSA256v01:  KeyAlgoSKECDSA256,
 	CertAlgoED25519v01:     KeyAlgoED25519,
 	CertAlgoSKED25519v01:   KeyAlgoSKED25519,
+	CertAlgoMLDSA44v01Go:   KeyAlgoMLDSA44,
+	CertAlgoMLDSA65v01Go:   KeyAlgoMLDSA65,
+	CertAlgoMLDSA87v01Go:   KeyAlgoMLDSA87,
 }
 
 // underlyingAlgo returns the signature algorithm associated with algo (which is
diff --git a/vendor/golang.org/x/crypto/ssh/cipher.go b/vendor/golang.org/x/crypto/ssh/cipher.go
index 48d01995..d83cacfd 100644
--- a/vendor/golang.org/x/crypto/ssh/cipher.go
+++ b/vendor/golang.org/x/crypto/ssh/cipher.go
@@ -414,10 +414,34 @@ func (c *gcmCipher) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error)
 	return plain, nil
 }
 
-// cbcCipher implements aes128-cbc cipher defined in RFC 4253 section 6.1
+// cbcCipher implements the CBC ciphers defined in RFC 4253 section 6.1, in
+// MAC-then-encrypt mode and, for the *-etm@openssh.com MACs, in the
+// encrypt-then-MAC mode defined in [PROTOCOL], section 1.5.
+//
+//	0               4                prefixLen                   macStart
+//	|               |                |                           |
+//	+---------------+----------------+---------+-----------------+-----------+
+//	| packet_length | padding_length | payload | random padding  |    mac    |
+//	+---------------+----------------+---------+-----------------+-----------+
+//	                |<--------- length = packet_length --------->|< macSize >|
+//	                                           |< paddingLength >|
+//	|<-------------------------- entirePacketSize -------------------------->|
+//
+//	MAC-then-encrypt (encStart = 0)
+//	|<----------------------- encLength ------------------------>|
+//	|<-------------- MAC'd (seqNum || plaintext) --------------->|
+//
+//	encrypt-then-MAC (encStart = 4)
+//	                |<--------------- encLength ---------------->|
+//	|<-------------- MAC'd (seqNum || ciphertext) -------------->|
+//
+// encLength is always a multiple of effectiveBlockSize, and in ETM mode the
+// packet_length field is not part of it. The padding is only trustworthy once
+// the MAC has been verified.
 type cbcCipher struct {
 	mac       hash.Hash
 	macSize   uint32
+	etm       bool
 	decrypter cipher.BlockMode
 	encrypter cipher.BlockMode
 
@@ -431,16 +455,20 @@ type cbcCipher struct {
 	oracleCamouflage uint32
 }
 
-func newCBCCipher(c cipher.Block, key, iv, macKey []byte, algs DirectionAlgorithms) (packetCipher, error) {
+func newCBCCipher(c cipher.Block, _, iv, macKey []byte, algs DirectionAlgorithms) (packetCipher, error) {
+	macMode := macModes[algs.MAC]
+	if macMode == nil {
+		return nil, fmt.Errorf("ssh: unsupported MAC %v", algs.MAC)
+	}
+	mac := macMode.new(macKey)
 	cbc := &cbcCipher{
-		mac:        macModes[algs.MAC].new(macKey),
+		mac:        mac,
+		macSize:    uint32(mac.Size()),
+		etm:        macMode.etm,
 		decrypter:  cipher.NewCBCDecrypter(c, iv),
 		encrypter:  cipher.NewCBCEncrypter(c, iv),
 		packetData: make([]byte, 1024),
 	}
-	if cbc.mac != nil {
-		cbc.macSize = uint32(cbc.mac.Size())
-	}
 
 	return cbc, nil
 }
@@ -473,13 +501,6 @@ func newTripleDESCBCCipher(key, iv, macKey []byte, algs DirectionAlgorithms) (pa
 	return cbc, nil
 }
 
-func maxUInt32(a, b int) uint32 {
-	if a > b {
-		return uint32(a)
-	}
-	return uint32(b)
-}
-
 const (
 	cbcMinPacketSizeMultiple = 8
 	cbcMinPacketSize         = 16
@@ -493,25 +514,38 @@ func (e cbcError) Error() string { return string(e) }
 
 func (c *cbcCipher) readCipherPacket(seqNum uint32, r io.Reader) ([]byte, error) {
 	p, err := c.readCipherPacketLeaky(seqNum, r)
-	if err != nil {
-		if _, ok := err.(cbcError); ok {
-			// Verification error: read a fixed amount of
-			// data, to make distinguishing between
-			// failing MAC and failing length check more
-			// difficult.
-			io.CopyN(io.Discard, r, int64(c.oracleCamouflage))
-		}
+	if _, ok := err.(cbcError); ok {
+		// Verification error: read a fixed amount of
+		// data, to make distinguishing between
+		// failing MAC and failing length check more
+		// difficult.
+		io.CopyN(io.Discard, r, int64(c.oracleCamouflage))
 	}
 	return p, err
 }
 
 func (c *cbcCipher) readCipherPacketLeaky(seqNum uint32, r io.Reader) ([]byte, error) {
 	blockSize := c.decrypter.BlockSize()
+	// The encrypted portion of a packet is a multiple of the cipher block size
+	// or 8, whichever is larger.
+	effectiveBlockSize := uint32(max(cbcMinPacketSizeMultiple, blockSize))
+	encStart := uint32(0)
+	// A packet is at least 16 bytes, or the cipher block size if larger. This does
+	// not apply to EtM (but the encrypted length still can't be zero).
+	minEncLength := uint32(max(cbcMinPacketSize, blockSize))
+	// For EtM MACs the packet length is transmitted in the clear and is not part
+	// of the encrypted data, which starts after it.
+	if c.etm {
+		encStart = 4
+		minEncLength = effectiveBlockSize
+	}
 
 	// Read the header, which will include some of the subsequent data in the
-	// case of block ciphers - this is copied back to the payload later.
-	// How many bytes of payload/padding will be read with this first read.
-	firstBlockLength := uint32((prefixLen + blockSize - 1) / blockSize * blockSize)
+	// case of block ciphers - this is copied back to the payload later. The
+	// rounding up to the block size covers at least prefixLen bytes, so the
+	// padding length is always within firstBlock.
+	headerEncLength := prefixLen - encStart
+	firstBlockLength := encStart + (headerEncLength+uint32(blockSize)-1)/uint32(blockSize)*uint32(blockSize)
 	firstBlock := c.packetData[:firstBlockLength]
 	if _, err := io.ReadFull(r, firstBlock); err != nil {
 		return nil, err
@@ -519,30 +553,49 @@ func (c *cbcCipher) readCipherPacketLeaky(seqNum uint32, r io.Reader) ([]byte, e
 
 	c.oracleCamouflage = maxPacket + 4 + c.macSize - firstBlockLength
 
-	c.decrypter.CryptBlocks(firstBlock, firstBlock)
-	length := binary.BigEndian.Uint32(firstBlock[:4])
+	c.mac.Reset()
+	binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
+	c.mac.Write(c.seqNumBytes[:])
+
+	var length uint32
+	if c.etm {
+		// For EtM MACs the MAC is computed over the cleartext packet length
+		// followed by the ciphertext, so it is updated before decrypting.
+		length = binary.BigEndian.Uint32(firstBlock[:encStart])
+		c.mac.Write(firstBlock[:encStart])
+		c.mac.Write(firstBlock[encStart:])
+		c.decrypter.CryptBlocks(firstBlock[encStart:], firstBlock[encStart:])
+	} else {
+		c.decrypter.CryptBlocks(firstBlock, firstBlock)
+		length = binary.BigEndian.Uint32(firstBlock[:4])
+	}
+
 	if length > maxPacket {
 		return nil, cbcError("ssh: packet too large")
 	}
-	if length+4 < maxUInt32(cbcMinPacketSize, blockSize) {
-		// The minimum size of a packet is 16 (or the cipher block size, whichever
-		// is larger) bytes.
+	// Length of the encrypted portion of the packet, which includes the packet
+	// length field only for non-EtM MACs.
+	encLength := 4 + length - encStart
+	if encLength < minEncLength {
 		return nil, cbcError("ssh: packet too small")
 	}
-	// The length of the packet (including the length field but not the MAC) must
-	// be a multiple of the block size or 8, whichever is larger.
-	if (length+4)%maxUInt32(cbcMinPacketSizeMultiple, blockSize) != 0 {
+	if encLength%effectiveBlockSize != 0 {
 		return nil, cbcError("ssh: invalid packet length multiple")
 	}
 
+	// The padding length is part of the encrypted data. For EtM MACs it is not
+	// acted upon before the MAC is verified, otherwise the CBC padding would
+	// still be usable as an oracle, which is what EtM prevents.
 	paddingLength := uint32(firstBlock[4])
-	if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 {
-		return nil, cbcError("ssh: invalid packet length")
+	if !c.etm {
+		if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 {
+			return nil, cbcError("ssh: invalid packet length")
+		}
 	}
 
-	// Positions within the c.packetData buffer:
-	macStart := 4 + length
-	paddingStart := macStart - paddingLength
+	// Positions within the c.packetData buffer: the MAC follows the encrypted
+	// data.
+	macStart := encStart + encLength
 
 	// Entire packet size, starting before length, ending at end of mac.
 	entirePacketSize := macStart + c.macSize
@@ -564,42 +617,58 @@ func (c *cbcCipher) readCipherPacketLeaky(seqNum uint32, r io.Reader) ([]byte, e
 	c.oracleCamouflage -= uint32(n)
 
 	remainingCrypted := c.packetData[firstBlockLength:macStart]
+	if c.etm {
+		c.mac.Write(remainingCrypted)
+	}
 	c.decrypter.CryptBlocks(remainingCrypted, remainingCrypted)
 
-	mac := c.packetData[macStart:]
-	if c.mac != nil {
-		c.mac.Reset()
-		binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
-		c.mac.Write(c.seqNumBytes[:])
+	if !c.etm {
 		c.mac.Write(c.packetData[:macStart])
-		c.macResult = c.mac.Sum(c.macResult[:0])
-		if subtle.ConstantTimeCompare(c.macResult, mac) != 1 {
-			return nil, cbcError("ssh: MAC failure")
+	}
+	c.macResult = c.mac.Sum(c.macResult[:0])
+	if subtle.ConstantTimeCompare(c.macResult, c.packetData[macStart:]) != 1 {
+		return nil, cbcError("ssh: MAC failure")
+	}
+
+	if c.etm {
+		if paddingLength < cbcMinPaddingSize || length <= paddingLength+1 {
+			return nil, cbcError("ssh: invalid packet length")
 		}
 	}
 
-	return c.packetData[prefixLen:paddingStart], nil
+	return c.packetData[prefixLen : macStart-paddingLength], nil
 }
 
-func (c *cbcCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, packet []byte) error {
-	effectiveBlockSize := maxUInt32(cbcMinPacketSizeMultiple, c.encrypter.BlockSize())
-
-	// Length of encrypted portion of the packet (header, payload, padding).
-	// Enforce minimum padding and packet size.
-	encLength := maxUInt32(prefixLen+len(packet)+cbcMinPaddingSize, cbcMinPacketSize)
+func (c *cbcCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader, payload []byte) error {
+	blockSize := c.encrypter.BlockSize()
+	// The encrypted portion of a packet is a multiple of the cipher block size
+	// or 8, whichever is larger.
+	effectiveBlockSize := uint32(max(cbcMinPacketSizeMultiple, blockSize))
+	// For EtM MACs the packet length is transmitted in the clear and is not part
+	// of the encrypted data, which starts after it.
+	encStart := uint32(0)
+	if c.etm {
+		encStart = 4
+	}
+	// Length of the encrypted portion of the packet (header, payload, padding),
+	// enforcing the minimum padding and the minimum packet size of RFC 4253,
+	// Section 6: 16 bytes, or the cipher block size if larger, excluding the
+	// MAC.
+	encLength := uint32(max(prefixLen-int(encStart)+len(payload)+cbcMinPaddingSize, cbcMinPacketSize-int(encStart)))
 	// Enforce block size.
 	encLength = (encLength + effectiveBlockSize - 1) / effectiveBlockSize * effectiveBlockSize
-
-	length := encLength - 4
-	paddingLength := int(length) - (1 + len(packet))
+	// The packet length field covers the whole packet except the field itself.
+	length := encStart + encLength - 4
+	paddingLength := int(length) - (1 + len(payload))
 
 	// Overall buffer contains: header, payload, padding, mac.
 	// Space for the MAC is reserved in the capacity but not the slice length.
-	bufferSize := encLength + c.macSize
-	if uint32(cap(c.packetData)) < bufferSize {
-		c.packetData = make([]byte, encLength, bufferSize)
+	macStart := encStart + encLength
+	entirePacketSize := macStart + c.macSize
+	if uint32(cap(c.packetData)) < entirePacketSize {
+		c.packetData = make([]byte, macStart, entirePacketSize)
 	} else {
-		c.packetData = c.packetData[:encLength]
+		c.packetData = c.packetData[:macStart]
 	}
 
 	p := c.packetData
@@ -611,24 +680,29 @@ func (c *cbcCipher) writeCipherPacket(seqNum uint32, w io.Writer, rand io.Reader
 
 	// Payload.
 	p = p[1:]
-	copy(p, packet)
+	copy(p, payload)
 
 	// Padding.
-	p = p[len(packet):]
+	p = p[len(payload):]
 	if _, err := io.ReadFull(rand, p); err != nil {
 		return err
 	}
 
-	if c.mac != nil {
-		c.mac.Reset()
-		binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
-		c.mac.Write(c.seqNumBytes[:])
+	c.mac.Reset()
+	binary.BigEndian.PutUint32(c.seqNumBytes[:], seqNum)
+	c.mac.Write(c.seqNumBytes[:])
+	if c.etm {
+		// For EtM MACs the MAC is computed over the cleartext packet length
+		// followed by the ciphertext.
+		c.mac.Write(c.packetData[:encStart])
+		c.encrypter.CryptBlocks(c.packetData[encStart:], c.packetData[encStart:])
+		c.mac.Write(c.packetData[encStart:])
+	} else {
 		c.mac.Write(c.packetData)
-		// The MAC is now appended into the capacity reserved for it earlier.
-		c.packetData = c.mac.Sum(c.packetData)
+		c.encrypter.CryptBlocks(c.packetData, c.packetData)
 	}
-
-	c.encrypter.CryptBlocks(c.packetData[:encLength], c.packetData[:encLength])
+	// The MAC is now appended into the capacity reserved for it earlier.
+	c.packetData = c.mac.Sum(c.packetData)
 
 	if _, err := w.Write(c.packetData); err != nil {
 		return err
diff --git a/vendor/golang.org/x/crypto/ssh/common.go b/vendor/golang.org/x/crypto/ssh/common.go
index aed0fd92..544eb93d 100644
--- a/vendor/golang.org/x/crypto/ssh/common.go
+++ b/vendor/golang.org/x/crypto/ssh/common.go
@@ -258,6 +258,11 @@ type Algorithms struct {
 }
 
 func init() {
+	supportedHostKeyAlgos = slices.Concat(supportedHostKeyAlgos, mldsaCertAlgos, mldsaKeyAlgos)
+	defaultHostKeyAlgos = slices.Concat(defaultHostKeyAlgos, mldsaCertAlgos, mldsaKeyAlgos)
+	supportedPubKeyAuthAlgos = slices.Concat(supportedPubKeyAuthAlgos, mldsaKeyAlgos)
+	defaultPubKeyAuthAlgos = slices.Concat(defaultPubKeyAuthAlgos, mldsaKeyAlgos)
+
 	if fips140.Enabled() {
 		defaultHostKeyAlgos = slices.DeleteFunc(defaultHostKeyAlgos, func(algo string) bool {
 			_, err := hashFunc(underlyingAlgo(algo))
@@ -281,6 +286,10 @@ func hashFunc(format string) (crypto.Hash, error) {
 	case KeyAlgoED25519:
 		// KeyAlgoED25519 doesn't pre-hash.
 		return 0, nil
+	case KeyAlgoMLDSA44, KeyAlgoMLDSA65, KeyAlgoMLDSA87:
+		// ML-DSA doesn't pre-hash. This case is not build tagged, availability
+		// is decided by mldsaKeyAlgos.
+		return 0, nil
 	case KeyAlgoRSA, InsecureKeyAlgoDSA:
 		if fips140.Enabled() {
 			return 0, fmt.Errorf("ssh: hash algorithm for format %q not allowed in FIPS 140 mode", format)
@@ -354,7 +363,13 @@ func keyFormatForAlgorithm(sigAlgo string) string {
 		CertAlgoECDSA521v01,
 		CertAlgoSKECDSA256v01,
 		CertAlgoED25519v01,
-		CertAlgoSKED25519v01:
+		CertAlgoSKED25519v01,
+		KeyAlgoMLDSA44,
+		KeyAlgoMLDSA65,
+		KeyAlgoMLDSA87,
+		CertAlgoMLDSA44v01Go,
+		CertAlgoMLDSA65v01Go,
+		CertAlgoMLDSA87v01Go:
 		return sigAlgo
 	default:
 		return ""
diff --git a/vendor/golang.org/x/crypto/ssh/doc.go b/vendor/golang.org/x/crypto/ssh/doc.go
index 5b4de9ef..39ac133e 100644
--- a/vendor/golang.org/x/crypto/ssh/doc.go
+++ b/vendor/golang.org/x/crypto/ssh/doc.go
@@ -17,6 +17,7 @@ References:
 	[PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD
 	[SSH-PARAMETERS]:    http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1
 	[SSH-CERTS]:	https://datatracker.ietf.org/doc/html/draft-miller-ssh-cert-01
+	[SSH-MLDSA]:	https://datatracker.ietf.org/doc/html/draft-sfluhrer-ssh-mldsa-08
 	[FIPS 140-3 mode]: https://go.dev/doc/security/fips140
 
 This package does not fall under the stability promise of the Go language itself,
diff --git a/vendor/golang.org/x/crypto/ssh/keys.go b/vendor/golang.org/x/crypto/ssh/keys.go
index fbbfb6cf..eb052381 100644
--- a/vendor/golang.org/x/crypto/ssh/keys.go
+++ b/vendor/golang.org/x/crypto/ssh/keys.go
@@ -51,6 +51,12 @@ const (
 	KeyAlgoED25519     = "ssh-ed25519"
 	KeyAlgoSKED25519   = "sk-ssh-ed25519@openssh.com"
 
+	// KeyAlgoMLDSA44, KeyAlgoMLDSA65 and KeyAlgoMLDSA87 are the ML-DSA
+	// algorithms of [SSH-MLDSA].
+	KeyAlgoMLDSA44 = "ssh-mldsa-44"
+	KeyAlgoMLDSA65 = "ssh-mldsa-65"
+	KeyAlgoMLDSA87 = "ssh-mldsa-87"
+
 	// KeyAlgoRSASHA256 and KeyAlgoRSASHA512 are only public key algorithms, not
 	// public key formats, so they can't appear as a PublicKey.Type. The
 	// corresponding PublicKey.Type is KeyAlgoRSA. See RFC 8332, Section 2.
@@ -83,7 +89,10 @@ func parsePubKey(in []byte, algo string) (pubKey PublicKey, rest []byte, err err
 		return parseED25519(in)
 	case KeyAlgoSKED25519:
 		return parseSKEd25519(in)
-	case CertAlgoRSAv01, InsecureCertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoSKECDSA256v01, CertAlgoED25519v01, CertAlgoSKED25519v01:
+	case KeyAlgoMLDSA44, KeyAlgoMLDSA65, KeyAlgoMLDSA87:
+		return parseMLDSA(in, algo)
+	case CertAlgoRSAv01, InsecureCertAlgoDSAv01, CertAlgoECDSA256v01, CertAlgoECDSA384v01, CertAlgoECDSA521v01, CertAlgoSKECDSA256v01, CertAlgoED25519v01, CertAlgoSKED25519v01,
+		CertAlgoMLDSA44v01Go, CertAlgoMLDSA65v01Go, CertAlgoMLDSA87v01Go:
 		cert, err := parseCert(in, certKeyAlgoNames[algo])
 		if err != nil {
 			return nil, nil, err
@@ -98,11 +107,30 @@ func parsePubKey(in []byte, algo string) (pubKey PublicKey, rest []byte, err err
 	return nil, nil, fmt.Errorf("ssh: unknown key algorithm: %v", algo)
 }
 
+// trimSpace removes leading and trailing ASCII space and tab.
+func trimSpace(in []byte) []byte {
+	return bytes.Trim(in, " \t")
+}
+
+// asciiFields splits in around each run of ASCII space and tab.
+func asciiFields(in []byte) [][]byte {
+	return bytes.FieldsFunc(in, func(r rune) bool {
+		return r == ' ' || r == '\t'
+	})
+}
+
+// dropCR removes a single trailing carriage return, so that an entry written
+// with CRLF line endings is read like one written with LF endings. A carriage
+// return anywhere else belongs to the field that holds it.
+func dropCR(in []byte) []byte {
+	return bytes.TrimSuffix(in, []byte("\r"))
+}
+
 // parseAuthorizedKey parses a public key in OpenSSH authorized_keys format
 // (see sshd(8) manual page) once the options and key type fields have been
 // removed.
 func parseAuthorizedKey(in []byte) (out PublicKey, comment string, err error) {
-	in = bytes.TrimSpace(in)
+	in = trimSpace(in)
 
 	i := bytes.IndexAny(in, " \t")
 	if i == -1 {
@@ -120,7 +148,7 @@ func parseAuthorizedKey(in []byte) (out PublicKey, comment string, err error) {
 	if err != nil {
 		return nil, "", err
 	}
-	comment = string(bytes.TrimSpace(in[i:]))
+	comment = string(trimSpace(in[i:]))
 	return out, comment, nil
 }
 
@@ -149,12 +177,9 @@ func ParseKnownHosts(in []byte) (marker string, hosts []string, pubKey PublicKey
 			rest = nil
 		}
 
-		end = bytes.IndexByte(in, '\r')
-		if end != -1 {
-			in = in[:end]
-		}
+		in = dropCR(in)
 
-		in = bytes.TrimSpace(in)
+		in = trimSpace(in)
 		if len(in) == 0 || in[0] == '#' {
 			in = rest
 			continue
@@ -168,8 +193,10 @@ func ParseKnownHosts(in []byte) (marker string, hosts []string, pubKey PublicKey
 
 		// Strip out the beginning of the known_host key.
 		// This is either an optional marker or a (set of) hostname(s).
-		keyFields := bytes.Fields(in)
-		if len(keyFields) < 3 || len(keyFields) > 5 {
+		// The comment is not delimited, so there is no upper bound on the
+		// number of fields.
+		keyFields := asciiFields(in)
+		if len(keyFields) < 3 {
 			return "", nil, nil, "", nil, errors.New("ssh: invalid entry in known_hosts data")
 		}
 
@@ -215,12 +242,9 @@ func ParseAuthorizedKey(in []byte) (out PublicKey, comment string, options []str
 			rest = nil
 		}
 
-		end = bytes.IndexByte(in, '\r')
-		if end != -1 {
-			in = in[:end]
-		}
+		in = dropCR(in)
 
-		in = bytes.TrimSpace(in)
+		in = trimSpace(in)
 		if len(in) == 0 || in[0] == '#' {
 			in = rest
 			continue
@@ -334,7 +358,8 @@ func MarshalAuthorizedKey(key PublicKey) []byte {
 }
 
 // MarshalPrivateKey returns a PEM block with the private key serialized in the
-// OpenSSH format.
+// OpenSSH format. ML-DSA keys are not supported, since no OpenSSH format is
+// defined for them: use [x509.MarshalPKCS8PrivateKey] instead.
 func MarshalPrivateKey(key crypto.PrivateKey, comment string) (*pem.Block, error) {
 	return marshalOpenSSHPrivateKey(key, comment, unencryptedOpenSSHMarshaler)
 }
@@ -1173,9 +1198,9 @@ func (k *skEd25519PublicKey) CryptoPublicKey() crypto.PublicKey {
 }
 
 // NewSignerFromKey takes an *rsa.PrivateKey, *dsa.PrivateKey,
-// *ecdsa.PrivateKey or any other crypto.Signer and returns a
-// corresponding Signer instance. ECDSA keys must use P-256, P-384 or
-// P-521. DSA keys must use parameter size L1024N160.
+// *ecdsa.PrivateKey, *mldsa.PrivateKey, or any other crypto.Signer and returns
+// a corresponding Signer instance. ECDSA keys must use P-256, P-384 or P-521.
+// DSA keys must use parameter size L1024N160.
 func NewSignerFromKey(key interface{}) (Signer, error) {
 	switch key := key.(type) {
 	case crypto.Signer:
@@ -1285,8 +1310,8 @@ func (s *wrappedSigner) SignWithAlgorithm(rand io.Reader, data []byte, algorithm
 }
 
 // NewPublicKey takes an *rsa.PublicKey, *dsa.PublicKey, *ecdsa.PublicKey,
-// or ed25519.PublicKey returns a corresponding PublicKey instance.
-// ECDSA keys must use P-256, P-384 or P-521.
+// ed25519.PublicKey, or an *mldsa.PublicKey, and returns a corresponding
+// PublicKey instance. ECDSA keys must use P-256, P-384 or P-521.
 func NewPublicKey(key interface{}) (PublicKey, error) {
 	switch key := key.(type) {
 	case *rsa.PublicKey:
@@ -1304,7 +1329,13 @@ func NewPublicKey(key interface{}) (PublicKey, error) {
 		}
 		return ed25519PublicKey(key), nil
 	default:
-		return nil, fmt.Errorf("ssh: unsupported key type %T", key)
+		pub, err := newMLDSAPublicKey(key)
+		if errors.Is(err, errNotMLDSAKey) {
+			return nil, fmt.Errorf("ssh: unsupported key type %T", key)
+		} else if err != nil {
+			return nil, err
+		}
+		return pub, nil
 	}
 }
 
diff --git a/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.go b/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.go
index 017c696a..40de8787 100644
--- a/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.go
+++ b/vendor/golang.org/x/crypto/ssh/knownhosts/knownhosts.go
@@ -554,9 +554,7 @@ func (h *hashedHost) match(a addr) bool {
 	return bytes.Equal(hashHost(Normalize(a.String()), h.salt), h.hash)
 }
 
-// trimSpace removes leading and trailing ASCII whitespace (space and tab). It
-// is used instead of bytes.TrimSpace to match OpenSSH behavior, which strictly
-// parses only ASCII space (0x20) and tab (0x09) as whitespace.
+// trimSpace removes leading and trailing ASCII space and tab.
 func trimSpace(in []byte) []byte {
 	return bytes.Trim(in, " \t")
 }
diff --git a/vendor/golang.org/x/crypto/ssh/mldsa.go b/vendor/golang.org/x/crypto/ssh/mldsa.go
new file mode 100644
index 00000000..09176b65
--- /dev/null
+++ b/vendor/golang.org/x/crypto/ssh/mldsa.go
@@ -0,0 +1,133 @@
+// Copyright 2026 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.27 && !fips140v1.0
+
+package ssh
+
+import (
+	"crypto"
+	"crypto/mldsa"
+	"errors"
+	"fmt"
+)
+
+// mldsaKeyAlgos are the ML-DSA public key algorithms implemented by this
+// package.
+var mldsaKeyAlgos = []string{
+	KeyAlgoMLDSA44,
+	KeyAlgoMLDSA65,
+	KeyAlgoMLDSA87,
+}
+
+// mldsaCertAlgos are the certificate algorithms for the keys in mldsaKeyAlgos.
+var mldsaCertAlgos = []string{
+	CertAlgoMLDSA44v01Go,
+	CertAlgoMLDSA65v01Go,
+	CertAlgoMLDSA87v01Go,
+}
+
+var errNotMLDSAKey = errors.New("ssh: not an ML-DSA key")
+
+// mldsaParameters returns the ML-DSA parameter set for the given public key
+// algorithm name.
+func mldsaParameters(algo string) (mldsa.Parameters, error) {
+	switch algo {
+	case KeyAlgoMLDSA44:
+		return mldsa.MLDSA44(), nil
+	case KeyAlgoMLDSA65:
+		return mldsa.MLDSA65(), nil
+	case KeyAlgoMLDSA87:
+		return mldsa.MLDSA87(), nil
+	default:
+		return mldsa.Parameters{}, fmt.Errorf("ssh: not an ML-DSA algorithm: %q", algo)
+	}
+}
+
+// mldsaKeyAlgo returns the public key algorithm name for the given ML-DSA
+// parameter set.
+func mldsaKeyAlgo(params mldsa.Parameters) string {
+	switch params {
+	case mldsa.MLDSA44():
+		return KeyAlgoMLDSA44
+	case mldsa.MLDSA65():
+		return KeyAlgoMLDSA65
+	case mldsa.MLDSA87():
+		return KeyAlgoMLDSA87
+	default:
+		panic("ssh: internal error: unknown ML-DSA parameter set: " + params.String())
+	}
+}
+
+// mldsaPublicKey implements PublicKey for the ML-DSA algorithms of [SSH-MLDSA].
+type mldsaPublicKey struct {
+	key *mldsa.PublicKey
+}
+
+func (k *mldsaPublicKey) Type() string {
+	return mldsaKeyAlgo(k.key.Parameters())
+}
+
+func parseMLDSA(in []byte, algo string) (out PublicKey, rest []byte, err error) {
+	params, err := mldsaParameters(algo)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var w struct {
+		KeyBytes []byte
+		Rest     []byte `ssh:"rest"`
+	}
+
+	if err := Unmarshal(in, &w); err != nil {
+		return nil, nil, err
+	}
+
+	key, err := mldsa.NewPublicKey(params, w.KeyBytes)
+	if err != nil {
+		return nil, nil, fmt.Errorf("ssh: invalid %s public key: %v", params, err)
+	}
+
+	return &mldsaPublicKey{key: key}, w.Rest, nil
+}
+
+func (k *mldsaPublicKey) Marshal() []byte {
+	w := struct {
+		Name     string
+		KeyBytes []byte
+	}{
+		k.Type(),
+		k.key.Bytes(),
+	}
+	return Marshal(&w)
+}
+
+func (k *mldsaPublicKey) Verify(b []byte, sig *Signature) error {
+	if sig.Format != k.Type() {
+		return fmt.Errorf("ssh: signature type %s for key type %s", sig.Format, k.Type())
+	}
+	// nil options select pure ML-DSA with an empty context, as required by
+	// [SSH-MLDSA], Sections 6 and 8.
+	if err := mldsa.Verify(k.key, b, sig.Blob, nil); err != nil {
+		return errors.New("ssh: signature did not verify")
+	}
+
+	return nil
+}
+
+func (k *mldsaPublicKey) CryptoPublicKey() crypto.PublicKey {
+	return k.key
+}
+
+// newMLDSAPublicKey returns a PublicKey wrapping key.
+func newMLDSAPublicKey(key crypto.PublicKey) (PublicKey, error) {
+	k, ok := key.(*mldsa.PublicKey)
+	if !ok {
+		return nil, errNotMLDSAKey
+	}
+	if k == nil || *k == (mldsa.PublicKey{}) {
+		return nil, errors.New("ssh: invalid ML-DSA public key")
+	}
+	return &mldsaPublicKey{key: k}, nil
+}
diff --git a/vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go b/vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go
new file mode 100644
index 00000000..9fec354a
--- /dev/null
+++ b/vendor/golang.org/x/crypto/ssh/mldsa_unsupported.go
@@ -0,0 +1,29 @@
+// Copyright 2026 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.27 || fips140v1.0
+
+package ssh
+
+import (
+	"crypto"
+	"errors"
+	"fmt"
+)
+
+var mldsaKeyAlgos, mldsaCertAlgos []string
+
+var errMLDSAUnsupported = fmt.Errorf("ssh: ML-DSA is not available in this build: %w",
+	errors.ErrUnsupported)
+
+var errNotMLDSAKey = errors.New("ssh: not an ML-DSA key")
+
+func parseMLDSA(in []byte, algo string) (out PublicKey, rest []byte, err error) {
+	return nil, nil, errMLDSAUnsupported
+}
+
+func newMLDSAPublicKey(key crypto.PublicKey) (PublicKey, error) {
+	// In this version of Go, *mldsa.PublicKey does not exist.
+	return nil, errNotMLDSAKey
+}
diff --git a/vendor/golang.org/x/sys/cpu/cpu.go b/vendor/golang.org/x/sys/cpu/cpu.go
index df8dbd1d..422b139c 100644
--- a/vendor/golang.org/x/sys/cpu/cpu.go
+++ b/vendor/golang.org/x/sys/cpu/cpu.go
@@ -61,7 +61,11 @@ var X86 struct {
 	HasBMI2             bool // Bit manipulation instruction set 2
 	HasCX16             bool // Compare and exchange 16 Bytes
 	HasERMS             bool // Enhanced REP for MOVSB and STOSB
+	HasF16C             bool // 16-bit floating-point conversion instructions
 	HasFMA              bool // Fused-multiply-add instructions
+	HasLAHF             bool // LAHF/SAHF available in 64-bit mode
+	HasLZCNT            bool // Leading zeros count instruction
+	HasMOVBE            bool // Move data after byte swap
 	HasOSXSAVE          bool // OS supports XSAVE/XRESTOR for saving/restoring XMM registers.
 	HasPCLMULQDQ        bool // PCLMULQDQ instruction - most often used for AES-GCM
 	HasPOPCNT           bool // Hamming weight instruction POPCNT.
@@ -75,6 +79,7 @@ var X86 struct {
 	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
+	HasXSAVE            bool // XSAVE/XRSTOR/XSETBV/XGETBV instructions (hardware support; see also HasOSXSAVE)
 	_                   CacheLinePad
 }
 
diff --git a/vendor/golang.org/x/sys/cpu/cpu_x86.go b/vendor/golang.org/x/sys/cpu/cpu_x86.go
index f5723d4f..7e6cead5 100644
--- a/vendor/golang.org/x/sys/cpu/cpu_x86.go
+++ b/vendor/golang.org/x/sys/cpu/cpu_x86.go
@@ -43,7 +43,11 @@ func initOptions() {
 		{Name: "bmi2", Feature: &X86.HasBMI2},
 		{Name: "cx16", Feature: &X86.HasCX16},
 		{Name: "erms", Feature: &X86.HasERMS},
+		{Name: "f16c", Feature: &X86.HasF16C},
 		{Name: "fma", Feature: &X86.HasFMA},
+		{Name: "lahf", Feature: &X86.HasLAHF},
+		{Name: "lzcnt", Feature: &X86.HasLZCNT},
+		{Name: "movbe", Feature: &X86.HasMOVBE},
 		{Name: "osxsave", Feature: &X86.HasOSXSAVE},
 		{Name: "pclmulqdq", Feature: &X86.HasPCLMULQDQ},
 		{Name: "popcnt", Feature: &X86.HasPOPCNT},
@@ -56,6 +60,7 @@ func initOptions() {
 		{Name: "avxifma", Feature: &X86.HasAVXIFMA},
 		{Name: "avxvnni", Feature: &X86.HasAVXVNNI},
 		{Name: "avxvnniint8", Feature: &X86.HasAVXVNNIInt8},
+		{Name: "xsave", Feature: &X86.HasXSAVE},
 
 		// These capabilities should always be enabled on amd64:
 		{Name: "sse2", Feature: &X86.HasSSE2, Required: runtime.GOARCH == "amd64"},
@@ -83,10 +88,13 @@ func archInit() {
 		cpuid_AVX512VPOPCNTDQ = 1 << 14
 		cpuid_SSE41           = 1 << 19
 		cpuid_SSE42           = 1 << 20
+		cpuid_MOVBE           = 1 << 22
 		cpuid_POPCNT          = 1 << 23
 		cpuid_AES             = 1 << 25
+		cpuid_XSAVE           = 1 << 26
 		cpuid_OSXSAVE         = 1 << 27
 		cpuid_AVX             = 1 << 28
+		cpuid_F16C            = 1 << 29
 
 		// "Extended Feature Flag" bits returned in EBX for CPUID EAX=0x7 ECX=0x0
 		cpuid_BMI1     = 1 << 3
@@ -110,6 +118,9 @@ func archInit() {
 
 		// edx bits
 		cpuid_FSRM = 1 << 4
+		// ecx bits for CPUID 0x80000001
+		cpuid_LAHF  = 1 << 0
+		cpuid_LZCNT = 1 << 5
 		// edx bits for CPUID 0x80000001
 		cpuid_RDTSCP = 1 << 27
 	)
@@ -158,9 +169,21 @@ func archInit() {
 	X86.HasSSE42 = isSet(ecx1, cpuid_SSE42)
 	X86.HasPOPCNT = isSet(ecx1, cpuid_POPCNT)
 	X86.HasAES = isSet(ecx1, cpuid_AES)
+	X86.HasXSAVE = isSet(ecx1, cpuid_XSAVE)
 	X86.HasOSXSAVE = isSet(ecx1, cpuid_OSXSAVE)
+	X86.HasF16C = isSet(ecx1, cpuid_F16C)
+	X86.HasMOVBE = isSet(ecx1, cpuid_MOVBE)
 	X86.HasRDRAND = isSet(ecx1, cpuid_RDRAND)
 
+	// Extended processor info and feature bits, under the separate extended
+	// (0x8000_0000-prefixed) leaf hierarchy, so maxID (the basic leaf count)
+	// doesn't gate it.
+	if maxExtID, _, _, _ := cpuid(0x80000000, 0); maxExtID >= 0x80000001 {
+		_, _, ecxExt1, _ := cpuid(0x80000001, 0)
+		X86.HasLAHF = isSet(ecxExt1, cpuid_LAHF)
+		X86.HasLZCNT = isSet(ecxExt1, cpuid_LZCNT)
+	}
+
 	var osSupportsAVX, osSupportsAVX512 bool
 	// For XGETBV, OSXSAVE bit is required and sufficient.
 	if X86.HasOSXSAVE {
diff --git a/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s b/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
index bdfc024d..2e1f4c3e 100644
--- a/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
+++ b/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s
@@ -13,6 +13,16 @@
 // Just jump to package syscall's implementation for all these functions.
 // The runtime may know about them.
 
+TEXT ·Syscall(SB),NOSPLIT,$0-56
+	MOVD	$syscall·Syscall(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
+TEXT ·Syscall6(SB),NOSPLIT,$0-80
+	MOVD	$syscall·Syscall6(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
 TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·entersyscall(SB)
 	MOVD	a1+8(FP), R3
@@ -28,6 +38,16 @@ TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
 	BL	runtime·exitsyscall(SB)
 	RET
 
+TEXT ·RawSyscall(SB),NOSPLIT,$0-56
+	MOVD	$syscall·RawSyscall(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
+	MOVD	$syscall·RawSyscall6(SB), R31
+	MOVD	R31, CTR
+	JMP	(CTR)
+
 TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
 	MOVD	a1+8(FP), R3
 	MOVD	a2+16(FP), R4
diff --git a/vendor/golang.org/x/sys/unix/asm_linux_sparc64.s b/vendor/golang.org/x/sys/unix/asm_linux_sparc64.s
new file mode 100644
index 00000000..77e1e327
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/asm_linux_sparc64.s
@@ -0,0 +1,48 @@
+// Copyright 2026 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 linux && sparc64 && gc
+
+#include "textflag.h"
+
+//
+// System calls for sparc64, Linux
+//
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT ·Syscall(SB), NOSPLIT, $0-56
+	JMP	syscall·Syscall(SB)
+
+TEXT ·Syscall6(SB), NOSPLIT, $0-80
+	JMP	syscall·Syscall6(SB)
+
+TEXT ·SyscallNoError(SB), NOSPLIT, $0-48
+	CALL	runtime·entersyscall(SB)
+	MOVD	trap+0(FP), R1	// syscall entry
+	MOVD	a1+8(FP), R8
+	MOVD	a2+16(FP), R9
+	MOVD	a3+24(FP), R10
+	TA	$0x6d
+	MOVD	R8, r1+32(FP)
+	MOVD	R9, r2+40(FP)
+	CALL	runtime·exitsyscall(SB)
+	RET
+
+TEXT ·RawSyscall(SB), NOSPLIT, $0-56
+	JMP	syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB), NOSPLIT, $0-80
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·RawSyscallNoError(SB), NOSPLIT, $0-48
+	MOVD	trap+0(FP), R1	// syscall entry
+	MOVD	a1+8(FP), R8
+	MOVD	a2+16(FP), R9
+	MOVD	a3+24(FP), R10
+	TA	$0x6d
+	MOVD	R8, r1+32(FP)
+	MOVD	R9, r2+40(FP)
+	RET
diff --git a/vendor/golang.org/x/sys/unix/asm_zos_s390x.s b/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
index 813dfad7..980f07a3 100644
--- a/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
+++ b/vendor/golang.org/x/sys/unix/asm_zos_s390x.s
@@ -30,21 +30,8 @@
 #define SVC_LOAD   BYTE $0x0A; BYTE $0x08 // SVC 08 LOAD
 #define SVC_DELETE BYTE $0x0A; BYTE $0x09 // SVC 09 DELETE
 
-DATA zosLibVec<>(SB)/8, $0
-GLOBL zosLibVec<>(SB), NOPTR, $8
-
-TEXT ·initZosLibVec(SB), NOSPLIT|NOFRAME, $0-0
-	MOVW PSALAA, R8
-	MOVD LCA64(R8), R8
-	MOVD CAA(R8), R8
-	MOVD EDCHPXV(R8), R8
-	MOVD R8, zosLibVec<>(SB)
-	RET
-
 TEXT ·GetZosLibVec(SB), NOSPLIT|NOFRAME, $0-0
-	MOVD zosLibVec<>(SB), R8
-	MOVD R8, ret+0(FP)
-	RET
+	JMP  runtime·GetZosLibVec(SB)
 
 TEXT ·clearErrno(SB), NOSPLIT, $0-0
 	BL   addrerrno<>(SB)
@@ -160,163 +147,13 @@ TEXT ·gettid(SB), NOSPLIT, $0
 // errno and errno2 is retrieved
 //
 TEXT ·CallLeFuncWithErr(SB), NOSPLIT, $0
-	MOVW PSALAA, R8
-	MOVD LCA64(R8), R8
-	MOVD CAA(R8), R9
-	MOVD g, GOCB(R9)
-
-	// Restore LE stack.
-	MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address
-	MOVD 0(R9), R4              // R4-> restore previously saved stack frame pointer
-
-	MOVD parms_base+8(FP), R7 // R7 -> argument array
-	MOVD parms_len+16(FP), R8 // R8 number of arguments
-
-	//  arg 1 ---> R1
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	MOVD 0(R7), R1
-
-	//  arg 2 ---> R2
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R2
-
-	//  arg 3 --> R3
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R3
-
-	CMP  R8, $0
-	BEQ  docall
-	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument
-
-repeat:
-	ADD  $8, R7
-	MOVD 0(R7), R0      // advance arg pointer by 8 byte
-	ADD  $8, R6         // advance LE argument address by 8 byte
-	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
-	SUB  $1, R8
-	CMP  R8, $0
-	BNE  repeat
-
-docall:
-	MOVD funcdesc+0(FP), R8 // R8-> function descriptor
-	LMG  0(R8), R5, R6
-	MOVD $0, 0(R9)          // R9 address of SAVSTACK_ASYNC
-	LE_CALL                 // balr R7, R6 (return #1)
-	NOPH
-	MOVD R3, ret+32(FP)
-	CMP  R3, $-1            // compare result to -1
-	BNE  done
-
-	// retrieve errno and errno2
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__errno), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __errno (return #3)
-	NOPH
-	MOVWZ 0(R3), R3
-	MOVD  R3, err+48(FP)
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__err2ad), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __err2ad (return #2)
-	NOPH
-	MOVW  (R3), R2            // retrieve errno2
-	MOVD  R2, errno2+40(FP)   // store in return area
-
-done:
-	MOVD R4, 0(R9)            // Save stack pointer.
-	RET
-
+        JMP  runtime·CallLeFuncWithErr(SB)
 //
 // Call LE function, if the return is 0
 // errno and errno2 is retrieved
 //
 TEXT ·CallLeFuncWithPtrReturn(SB), NOSPLIT, $0
-	MOVW PSALAA, R8
-	MOVD LCA64(R8), R8
-	MOVD CAA(R8), R9
-	MOVD g, GOCB(R9)
-
-	// Restore LE stack.
-	MOVD SAVSTACK_ASYNC(R8), R9 // R9-> LE stack frame saving address
-	MOVD 0(R9), R4              // R4-> restore previously saved stack frame pointer
-
-	MOVD parms_base+8(FP), R7 // R7 -> argument array
-	MOVD parms_len+16(FP), R8 // R8 number of arguments
-
-	//  arg 1 ---> R1
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	MOVD 0(R7), R1
-
-	//  arg 2 ---> R2
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R2
-
-	//  arg 3 --> R3
-	CMP  R8, $0
-	BEQ  docall
-	SUB  $1, R8
-	ADD  $8, R7
-	MOVD 0(R7), R3
-
-	CMP  R8, $0
-	BEQ  docall
-	MOVD $2176+16, R6 // starting LE stack address-8 to store 4th argument
-
-repeat:
-	ADD  $8, R7
-	MOVD 0(R7), R0      // advance arg pointer by 8 byte
-	ADD  $8, R6         // advance LE argument address by 8 byte
-	MOVD R0, (R4)(R6*1) // copy argument from go-slice to le-frame
-	SUB  $1, R8
-	CMP  R8, $0
-	BNE  repeat
-
-docall:
-	MOVD funcdesc+0(FP), R8 // R8-> function descriptor
-	LMG  0(R8), R5, R6
-	MOVD $0, 0(R9)          // R9 address of SAVSTACK_ASYNC
-	LE_CALL                 // balr R7, R6 (return #1)
-	NOPH
-	MOVD R3, ret+32(FP)
-	CMP  R3, $0             // compare result to 0
-	BNE  done
-
-	// retrieve errno and errno2
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__errno), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __errno (return #3)
-	NOPH
-	MOVWZ 0(R3), R3
-	MOVD  R3, err+48(FP)
-	MOVD  zosLibVec<>(SB), R8
-	ADD   $(__err2ad), R8
-	LMG   0(R8), R5, R6
-	LE_CALL                   // balr R7, R6 __err2ad (return #2)
-	NOPH
-	MOVW  (R3), R2            // retrieve errno2
-	MOVD  R2, errno2+40(FP)   // store in return area
-	XOR   R2, R2
-	MOVWZ R2, (R3)            // clear errno2
-
-done:
-	MOVD R4, 0(R9)            // Save stack pointer.
-	RET
-
+        JMP runtime·CallLeFuncWithPtrReturn(SB)
 //
 // function to test if a pointer can be safely dereferenced (content read)
 // return 0 for succces
@@ -360,23 +197,4 @@ TEXT ·ptrtest(SB), NOSPLIT, $0-16
 //
 // func safeload(ptr uintptr) ( value uintptr, error uintptr)
 TEXT ·safeload(SB), NOSPLIT, $0-24
-	MOVD ptr+0(FP), R10                                                    // test pointer in R10
-	MOVD $0x0, R6
-	BYTE $0xE3; BYTE $0x20; BYTE $0x04; BYTE $0xB8; BYTE $0x00; BYTE $0x17 // llgt  2,1208
-	BYTE $0xB9; BYTE $0x17; BYTE $0x00; BYTE $0x22                         // llgtr 2,2
-	BYTE $0xA5; BYTE $0x26; BYTE $0x7F; BYTE $0xFF                         // nilh  2,32767
-	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x58; BYTE $0x00; BYTE $0x04 // lg    2,88(2)
-	BYTE $0xE3; BYTE $0x22; BYTE $0x00; BYTE $0x08; BYTE $0x00; BYTE $0x04 // lg    2,8(2)
-	BYTE $0x41; BYTE $0x22; BYTE $0x03; BYTE $0x68                         // la    2,872(2)
-	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x33                         // xgr   3,3
-	BYTE $0xA7; BYTE $0x55; BYTE $0x00; BYTE $0x04                         // bras  5,lbl1
-	BYTE $0xA7; BYTE $0x39; BYTE $0x00; BYTE $0x01                         // lghi  3,1
-	BYTE $0xB9; BYTE $0x02; BYTE $0x00; BYTE $0x33                         // lbl1     ltgr  3,3
-	BYTE $0xA7; BYTE $0x74; BYTE $0x00; BYTE $0x08                         // brc   b'0111',lbl2
-	BYTE $0xE3; BYTE $0x52; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg 5,0(2)
-	BYTE $0xE3; BYTE $0x6A; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x04 // lg    6,0(10)
-	BYTE $0xB9; BYTE $0x82; BYTE $0x00; BYTE $0x99                         // lbl2     xgr   9,9
-	BYTE $0xE3; BYTE $0x92; BYTE $0x00; BYTE $0x00; BYTE $0x00; BYTE $0x24 // stg   9,0(2)
-	MOVD R6, value+8(FP)                                                   // result in R6
-	MOVD R3, error+16(FP)                                                  // error in R3
-	RET
+        JMP  runtime·ZosSafeLoad(SB)
diff --git a/vendor/golang.org/x/sys/unix/bpxsvc_zos.s b/vendor/golang.org/x/sys/unix/bpxsvc_zos.s
index 4bd4a179..1236e1e9 100644
--- a/vendor/golang.org/x/sys/unix/bpxsvc_zos.s
+++ b/vendor/golang.org/x/sys/unix/bpxsvc_zos.s
@@ -20,15 +20,15 @@ TEXT ·bpxcall(SB), NOSPLIT|NOFRAME, $0
 	MOVD  plist_base+0(FP), R1  // r1 points to plist
 	MOVD  bpx_offset+24(FP), R2 // r2 offset to BPX vector table
 	MOVD  R14, R7               // save r14
-	MOVD  R15, R8               // save r15
-	MOVWZ 16(R0), R9
-	MOVWZ 544(R9), R9
-	MOVWZ 24(R9), R9            // call vector in r9
-	ADD   R2, R9                // add offset to vector table
-	MOVWZ (R9), R9              // r9 points to entry point
-	BYTE  $0x0D                 // BL R14,R9 --> basr r14,r9
-	BYTE  $0xE9                 // clobbers 0,1,14,15
-	MOVD  R8, R15               // restore 15
+	MOVD  R15, R9               // save r15
+	MOVWZ 16(R0), R15
+	MOVWZ 544(R15), R15
+	MOVWZ 24(R15), R15          // call vector in r15
+	ADD   R2, R15               // add offset to vector table
+	MOVWZ (R15), R15            // r15 points to entry point
+	BYTE  $0x0D                 // BL R14,R15 --> basr r14,r15
+	BYTE  $0xEF                 // clobbers 0,1,14,15
+	MOVD  R9, R15               // restore 15
 	JMP   R7                    // return via saved return address
 
 //   func A2e(arr [] byte)
diff --git a/vendor/golang.org/x/sys/unix/fcntl_darwin.go b/vendor/golang.org/x/sys/unix/fcntl_darwin.go
index a9911c7c..78c28a3d 100644
--- a/vendor/golang.org/x/sys/unix/fcntl_darwin.go
+++ b/vendor/golang.org/x/sys/unix/fcntl_darwin.go
@@ -13,12 +13,12 @@ func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
 
 // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
 func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
-	_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk))))
+	_, err := fcntlPtr(int(fd), cmd, unsafe.Pointer(lk))
 	return err
 }
 
 // FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command.
 func FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error {
-	_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore))))
+	_, err := fcntlPtr(int(fd), cmd, unsafe.Pointer(fstore))
 	return err
 }
diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh
index 9e907ac2..e95eecd5 100644
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -579,7 +579,7 @@ ccflags="$@"
 		$2 ~ /^DIOC/ ||
 		$2 ~ /^RUSAGE_(SELF|CHILDREN|THREAD)/ ||
 		$2 ~ /^RLIMIT_(AS|CORE|CPU|DATA|FSIZE|LOCKS|MEMLOCK|MSGQUEUE|NICE|NOFILE|NPROC|RSS|RTPRIO|RTTIME|SIGPENDING|STACK)|RLIM_INFINITY/ ||
-		$2 ~ /^PRIO_(PROCESS|PGRP|USER)/ ||
+		$2 ~ /^PRIO_(PROCESS|PGRP|USER|DARWIN_(THREAD|PROCESS|BG|NONUI))/ ||
 		$2 ~ /^CLONE_[A-Z_]+/ ||
 		$2 !~ /^(BPF_TIMEVAL|BPF_FIB_LOOKUP_[A-Z]+|BPF_F_LINK)$/ &&
 		$2 ~ /^(BPF|DLT)_/ ||
diff --git a/vendor/golang.org/x/sys/unix/ptrace_zos.go b/vendor/golang.org/x/sys/unix/ptrace_zos.go
new file mode 100644
index 00000000..394fbd71
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/ptrace_zos.go
@@ -0,0 +1,537 @@
+// Copyright 2026 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 zos
+
+package unix
+
+import "unsafe"
+
+// z/OS ptrace implementation notes:
+//
+// This file provides ptrace wrappers for z/OS that match the Linux API as closely
+// as possible. However, there are fundamental differences in how z/OS implements
+// process tracing compared to Linux:
+//
+// 1. SYSTEM CALL INTERFACE:
+//    - z/OS uses BPX4PTR (5 parameters) vs Linux ptrace syscall (4 parameters)
+//    - The 5th parameter (buffer) is used for block operations
+//
+// 2. MEMORY OPERATIONS:
+//    - z/OS: PT_READ_BLOCK/PT_WRITE_BLOCK for efficient block transfers
+//    - Linux: PTRACE_PEEKTEXT/POKETEXT for word-by-word access
+//
+// 3. REGISTER OPERATIONS:
+//    - z/OS: PT_READ_GPR/PT_WRITE_GPR with register number for 64-bit values
+//    - Linux: PTRACE_GETREGSET/SETREGSET with iovec structure
+//
+// 4. SINGLE-STEPPING:
+//    - z/OS: No native single-step; requires temporary breakpoints or PER
+//    - Linux: PTRACE_SINGLESTEP natively supported
+//      a) Read instruction at current PSW
+//      b) Calculate next instruction address (handle branches)
+//      c) Set temporary breakpoint (SVC 144 = 0x0A90) at next address
+//      d) Continue execution until breakpoint hit
+//      e) Restore original instruction and adjust PSW
+//
+// 5. SYSCALL TRACING:
+//    - z/OS: No PTRACE_SYSCALL equivalent; requires breakpoint-based approach
+//    - Linux: PTRACE_SYSCALL stops at syscall entry/exit
+//      a) Identify BPX syscall vector location
+//      b) Set breakpoints at syscall entry points
+//      c) Detect BASR instructions calling into syscall vector
+//      d) Parse arguments from registers before/after syscall
+//
+// 6. LIMITATIONS:
+//    - PtraceSetOptions: No equivalent (returns ENOSYS)
+//    - PtraceGetEventMsg: No equivalent (returns ENOSYS)
+//    - PtraceSingleStep: Requires complex implementation (returns ENOSYS)
+//    - PtraceInterrupt: No equivalent (returns ENOSYS)
+//    - PtracePokeUser: No PT_WRITE_U (returns ENOSYS)
+//
+// For reference implementations of single-stepping and syscall tracing on z/OS,
+
+// ptrace is the basic wrapper for BPX4PTR on z/OS.
+// Note: z/OS ptrace (BPX4PTR) takes 5 parameters vs 4 on Linux/Darwin.
+// The 5th parameter (buffer) is used for operations like PT_READ_BLOCK/PT_WRITE_BLOCK.
+//
+// data is an integer-valued argument (signal number, register index, byte count,
+// or a target-process address). It is not a Go-managed pointer. We must not pass
+// it to Bpx4ptr as unsafe.Pointer(data) because the garbage collector would treat
+// that integer as a pointer and may crash trying to follow it.
+//
+// Instead we inline the parms array that Bpx4ptr would construct, placing &data
+// at parms[3]. BPX4PTR dereferences parms[3] to obtain the data value, so it
+// receives data unchanged while the GC only ever sees a valid stack pointer.
+func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
+	req32 := int32(request)
+	pid32 := int32(pid)
+	var rv, rc, rn int32
+	var buffer unsafe.Pointer
+	parms := [8]unsafe.Pointer{
+		unsafe.Pointer(&req32),
+		unsafe.Pointer(&pid32),
+		unsafe.Pointer(&addr),
+		unsafe.Pointer(&data), // &data, not unsafe.Pointer(data)
+		unsafe.Pointer(&buffer),
+		unsafe.Pointer(&rv),
+		unsafe.Pointer(&rc),
+		unsafe.Pointer(&rn),
+	}
+	bpxcall(parms[:], BPX4PTR)
+	if rv != 0 {
+		err = errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return
+}
+
+// ptracePtr is a variant that accepts unsafe.Pointer for the data parameter.
+// addr is a target-process address (a raw integer), not a Go-managed pointer.
+// We must not pass it to Bpx4ptr as unsafe.Pointer(addr); instead we inline the
+// parms array and place &addr at parms[2], exactly as ptrace() does for data.
+func ptracePtr(request int, pid int, addr uintptr, data unsafe.Pointer) (err error) {
+	req32 := int32(request)
+	pid32 := int32(pid)
+	var rv, rc, rn int32
+	var buffer unsafe.Pointer
+	parms := [8]unsafe.Pointer{
+		unsafe.Pointer(&req32),
+		unsafe.Pointer(&pid32),
+		unsafe.Pointer(&addr), // &addr, not unsafe.Pointer(addr)
+		unsafe.Pointer(&data),
+		unsafe.Pointer(&buffer),
+		unsafe.Pointer(&rv),
+		unsafe.Pointer(&rc),
+		unsafe.Pointer(&rn),
+	}
+	bpxcall(parms[:], BPX4PTR)
+	if rv != 0 {
+		err = errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return
+}
+
+// ptracePtrWithBuffer is used for operations that require the buffer parameter.
+// addr is a target-process address; same &addr treatment as ptracePtr.
+func ptracePtrWithBuffer(request int, pid int, addr uintptr, data unsafe.Pointer, buffer unsafe.Pointer) (err error) {
+	req32 := int32(request)
+	pid32 := int32(pid)
+	var rv, rc, rn int32
+	parms := [8]unsafe.Pointer{
+		unsafe.Pointer(&req32),
+		unsafe.Pointer(&pid32),
+		unsafe.Pointer(&addr), // &addr, not unsafe.Pointer(addr)
+		unsafe.Pointer(&data),
+		unsafe.Pointer(&buffer),
+		unsafe.Pointer(&rv),
+		unsafe.Pointer(&rc),
+		unsafe.Pointer(&rn),
+	}
+	bpxcall(parms[:], BPX4PTR)
+	if rv != 0 {
+		err = errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return
+}
+
+// High-level convenience functions matching the Linux/Darwin API
+
+func PtraceAttach(pid int) (err error) {
+	return ptrace(PT_ATTACH, pid, 0, 0)
+}
+
+func PtraceDetach(pid int) (err error) {
+	return ptrace(PT_DETACH, pid, 0, 0)
+}
+
+func PtraceCont(pid int, signal int) (err error) {
+	// PT_CONTINUE can be interrupted by signals (EINTR), retry if needed
+	for {
+		err = ptrace(PT_CONTINUE, pid, 0, uintptr(signal))
+		if err != EINTR {
+			break
+		}
+	}
+	return err
+}
+
+func PtraceKill(pid int) (err error) {
+	return ptrace(PT_KILL, pid, 0, 0)
+}
+
+// ptracePeek implements the peek operations using PT_READ_BLOCK.
+// On z/OS, PT_READ_BLOCK can read arbitrary-length data efficiently.
+// Unlike Linux which reads word-by-word, z/OS can read blocks directly.
+func ptracePeek(req int, pid int, addr uintptr, out []byte) (count int, err error) {
+	if len(out) == 0 {
+		return 0, nil
+	}
+
+	// z/OS PT_READ_BLOCK can read blocks directly without word-by-word alignment
+	// The buffer parameter points to the output buffer
+	buffer := unsafe.Pointer(&out[0])
+	err = ptracePtrWithBuffer(req, pid, addr, unsafe.Pointer(uintptr(len(out))), buffer)
+	if err != nil {
+		return 0, err
+	}
+	return len(out), nil
+}
+
+// PtracePeekText reads from the traced process's text segment.
+func PtracePeekText(pid int, addr uintptr, out []byte) (count int, err error) {
+	return ptracePeek(PT_READ_BLOCK, pid, addr, out)
+}
+
+// PtracePeekData reads from the traced process's data segment.
+func PtracePeekData(pid int, addr uintptr, out []byte) (count int, err error) {
+	return ptracePeek(PT_READ_BLOCK, pid, addr, out)
+}
+
+// PtracePeekUser reads from the traced process's user area.
+// On z/OS, PT_READ_U reads a 32-bit word from the user area at the specified offset.
+// To match Linux behavior, we implement word-by-word reading for arbitrary lengths.
+func PtracePeekUser(pid int, addr uintptr, out []byte) (count int, err error) {
+	if len(out) == 0 {
+		return 0, nil
+	}
+
+	// PT_READ_U reads 32-bit words from user area
+	// We need to read word-by-word to handle arbitrary lengths
+	n := 0
+	for n < len(out) {
+		var data uint32
+		err = ptracePtr(PT_READ_U, pid, addr+uintptr(n), unsafe.Pointer(&data))
+		if err != nil {
+			return n, err
+		}
+
+		// Copy up to 4 bytes to output
+		remaining := len(out) - n
+		if remaining >= 4 {
+			out[n] = byte(data >> 24)
+			out[n+1] = byte(data >> 16)
+			out[n+2] = byte(data >> 8)
+			out[n+3] = byte(data)
+			n += 4
+		} else {
+			// Handle partial word at the end
+			for i := 0; i < remaining; i++ {
+				out[n+i] = byte(data >> (24 - i*8))
+			}
+			n += remaining
+		}
+	}
+	return n, nil
+}
+
+// ptracePoke implements the poke operations using PT_WRITE_BLOCK.
+func ptracePoke(pokeReq int, peekReq int, pid int, addr uintptr, data []byte) (count int, err error) {
+	if len(data) == 0 {
+		return 0, nil
+	}
+
+	// z/OS PT_WRITE_BLOCK can write blocks directly
+	buffer := unsafe.Pointer(&data[0])
+	err = ptracePtrWithBuffer(pokeReq, pid, addr, unsafe.Pointer(uintptr(len(data))), buffer)
+	if err != nil {
+		return 0, err
+	}
+	return len(data), nil
+}
+
+// PtracePokeText writes to the traced process's text segment.
+func PtracePokeText(pid int, addr uintptr, data []byte) (count int, err error) {
+	return ptracePoke(PT_WRITE_BLOCK, PT_READ_BLOCK, pid, addr, data)
+}
+
+// PtracePokeData writes to the traced process's data segment.
+func PtracePokeData(pid int, addr uintptr, data []byte) (count int, err error) {
+	return ptracePoke(PT_WRITE_BLOCK, PT_READ_BLOCK, pid, addr, data)
+}
+
+// PtracePokeUser writes to the traced process's user area.
+// Note: z/OS does not have a direct PT_WRITE_U equivalent.
+// This function returns ENOSYS to indicate it's not supported.
+// DIFFERENCE FROM LINUX: Linux supports PTRACE_POKEUSR, z/OS does not.
+func PtracePokeUser(pid int, addr uintptr, data []byte) (count int, err error) {
+	// z/OS doesn't have PT_WRITE_U
+	return 0, ENOSYS
+}
+
+// PtraceGetRegs retrieves the general purpose registers from the traced process.
+// On z/OS, PT_READ_GPR can read individual registers as 64-bit values when called
+// with a register number, or read all registers when called with a buffer.
+// This function reads each register individually to ensure full 64-bit values.
+// DIFFERENCE FROM LINUX: Linux uses PTRACE_GETREGSET with iovec, z/OS uses PT_READ_GPR.
+func PtraceGetRegs(pid int, regsout *PtraceRegs) (err error) {
+	// Use PT_REGHSET to enable reading high GPRs for AMODE 64 programs
+	rv, rc, rn := Bpx4ptr(int32(PT_REGHSET), int32(pid), nil, nil, nil)
+	_ = rv
+	_ = rc
+	_ = rn
+
+	// Use PT_BLOCKREQ to read GPRs and PSW in one call
+	// dbx uses 3 requests: PT_READ_GPR, PT_READ_U, PT_READ_GPRH
+	// PT_READ_U is required for ptrace to populate PSW in GPR block
+	//
+	// IMPORTANT: z/OS ptrace always returns 64-bit ESA/390 format PSW in the Psw field.
+	// The 128-bit Pswg field is never populated, even with PSWG_Req bit set.
+	// We convert ESA/390 to z/Architecture format in software (matching DBX behavior).
+	const (
+		numRequests = 3
+		reqSize     = int(unsafe.Sizeof(PtraceBlkReqReq{}))
+		gprSize     = int(unsafe.Sizeof(PtraceBlkGpr{}))
+		uareaSize   = int(unsafe.Sizeof(PtraceBlkUar{})) + 6*int(unsafe.Sizeof(PtraceBlkUarOcw{}))
+		totalSize   = int(unsafe.Sizeof(PtraceBlkReq{})) + numRequests*reqSize + gprSize*2 + uareaSize
+	)
+
+	// Allocate buffer for block request
+	buf := make([]byte, totalSize)
+
+	// Setup block request header
+	blkReq := (*PtraceBlkReq)(unsafe.Pointer(&buf[0]))
+	blkReq.Numreq = numRequests
+
+	// Setup request array
+	reqOffset := int(unsafe.Sizeof(PtraceBlkReq{}))
+	reqs := (*[3]PtraceBlkReqReq)(unsafe.Pointer(&buf[reqOffset]))
+
+	// Setup GPR block (lower 32 bits)
+	gprOffset := reqOffset + numRequests*reqSize
+	gprBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprOffset]))
+
+	// Setup user area block (required for PSW)
+	uareaOffset := gprOffset + gprSize
+	uareaBlock := (*PtraceBlkUar)(unsafe.Pointer(&buf[uareaOffset]))
+	uareaBlock.Num = 6 // Number of control info entries
+
+	// Setup user area offset/control words
+	uareaOcw := (*[6]PtraceBlkUarOcw)(unsafe.Pointer(&buf[uareaOffset+int(unsafe.Sizeof(PtraceBlkUar{}))]))
+	uareaOcw[0].Ofs = 1025 // program interrupt code
+	uareaOcw[1].Ofs = 1026 // abend completion code
+	uareaOcw[2].Ofs = 1027 // abend reason code
+	uareaOcw[3].Ofs = 1028 // signal code
+	uareaOcw[4].Ofs = 1029 // instruction length code
+	uareaOcw[5].Ofs = 1030 // process flags
+
+	// Setup high GPR block (upper 32 bits)
+	gprHighOffset := uareaOffset + uareaSize
+	gprHighBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprHighOffset]))
+
+	// Configure requests (order matters: GPR, U, GPRH)
+	// reqdata contains OFFSET from buffer start, not absolute address
+	// dbx: brr[0].reqdata=(unsigned long)brg; where brg is the offset
+	reqs[0].Reqtype = PT_READ_GPR
+	reqs[0].Reqdata = uint32(gprOffset)
+	reqs[1].Reqtype = PT_READ_U
+	reqs[1].Reqdata = uint32(uareaOffset)
+	reqs[2].Reqtype = PT_READ_GPRH
+	reqs[2].Reqdata = uint32(gprHighOffset)
+
+	// Execute block request
+	rvBlk, rcBlk, rnBlk := Bpx4ptr(int32(PT_BLOCKREQ), int32(pid),
+		unsafe.Pointer(&buf[0]), unsafe.Pointer(uintptr(totalSize)), nil)
+	if rvBlk == -1 {
+		return errnoErr2(Errno(rcBlk), uintptr(rnBlk))
+	}
+
+	// Extract GPRs (combine low and high 32 bits)
+	for i := 0; i < 16; i++ {
+		low := uint64(gprBlock.Gpr[i])
+		high := uint64(gprHighBlock.Gpr[i]) << 32
+		regsout.Gprs[i] = high | low
+	}
+
+	// Extract PSW from GPR block structure
+	// z/OS ptrace ALWAYS returns 8-byte ESA/390 format PSW at offset 144.
+	// The 16-byte PSWG field at offset 152 is NEVER populated (always zero).
+	// We must convert ESA/390 format to z/Architecture format in software (like DBX does).
+	//
+	// ESA/390 PSW format (8 bytes):
+	//   Word 1 (bytes 0-3): Mask with bit 12 = 1 (ECMODE31BIT)
+	//   Word 2 (bytes 4-7): Address with bit 0 = AMODE bit (1=31-bit, 0=64-bit)
+	//
+	// z/Architecture PSW format (16 bytes):
+	//   Mask (bytes 0-7): Extended mask with bit 12 = 0, bits 31-32 = EA+BA (AMODE)
+	//   Addr (bytes 8-15): Full 64-bit instruction address
+
+	// Read ESA/390 PSW as two 32-bit words
+	pswWord1 := uint32(gprBlock.Psw[0])<<24 | uint32(gprBlock.Psw[1])<<16 |
+		uint32(gprBlock.Psw[2])<<8 | uint32(gprBlock.Psw[3])
+	pswWord2 := uint32(gprBlock.Psw[4])<<24 | uint32(gprBlock.Psw[5])<<16 |
+		uint32(gprBlock.Psw[6])<<8 | uint32(gprBlock.Psw[7])
+
+	// Convert ESA/390 to z/Architecture format (matching DBX psw_ESA390_to_zArchitecture)
+	const ECMODE31BIT = uint64(0x0000000000080000)
+	const AMODE31BIT = uint64(0x0000000080000000)
+	const ADDR_MASK_31 = uint64(0x000000007FFFFFFF)
+
+	// Extract AMODE bit from address word (bit 0 of word 2)
+	amode31 := uint64(pswWord2) & AMODE31BIT
+
+	// Mask off AMODE bit from address
+	addr := uint64(pswWord2) & ADDR_MASK_31
+
+	// Convert mask: clear ECMODE31BIT, shift left 32 bits, add AMODE bit
+	mask := uint64(pswWord1) & ^ECMODE31BIT
+	mask = (mask << 32) | amode31
+
+	regsout.Psw.Mask = mask
+	regsout.Psw.Addr = addr
+
+	// Note: Access registers (Acrs), floating point registers (Fp_regs),
+	// PER info (Per_info), and other fields would require additional
+	// PT_READ_* calls. For now, we focus on GPRs and PSW which are
+	// the most commonly used registers for debugging.
+
+	return nil
+}
+
+// ptraceWritePSW writes only the PSW address register.
+// This is a lower-level function used internally for single-stepping.
+// Based on ztrace's write_psw function.
+func ptraceWritePSW(pid int, pswAddr uint32) error {
+	const PTRACE_REG_PSWA = 41
+	rv, rc, rn := Bpx4ptr(int32(PT_WRITE_GPR), int32(pid),
+		unsafe.Pointer(uintptr(PTRACE_REG_PSWA)),
+		unsafe.Pointer(uintptr(pswAddr)),
+		nil)
+	if rv == -1 {
+		return errnoErr2(Errno(rc), uintptr(rn))
+	}
+	return nil
+}
+
+// PtraceSetRegs sets the general purpose registers in the traced process.
+// Uses PT_BLOCKREQ to write GPRs and PSW in a single call, matching dbx implementation.
+// DIFFERENCE FROM LINUX: Linux uses PTRACE_SETREGSET with iovec, z/OS uses PT_BLOCKREQ.
+// NOTE: The process must be in a stopped state for register writes to succeed.
+func PtraceSetRegs(pid int, regs *PtraceRegs) (err error) {
+	// Use PT_REGHSET to enable writing high GPRs for AMODE 64 programs
+	rv, rc, rn := Bpx4ptr(int32(PT_REGHSET), int32(pid), nil, nil, nil)
+	_ = rv
+	_ = rc
+	_ = rn
+
+	// Use PT_BLOCKREQ to write GPRs and PSW in one call
+	const (
+		numRequests = 2
+		reqSize     = int(unsafe.Sizeof(PtraceBlkReqReq{}))
+		gprSize     = int(unsafe.Sizeof(PtraceBlkGpr{}))
+		totalSize   = int(unsafe.Sizeof(PtraceBlkReq{})) + numRequests*reqSize + gprSize*2
+	)
+
+	// Allocate buffer for block request
+	buf := make([]byte, totalSize)
+
+	// Setup block request header
+	blkReq := (*PtraceBlkReq)(unsafe.Pointer(&buf[0]))
+	blkReq.Numreq = numRequests
+
+	// Setup request array
+	reqOffset := int(unsafe.Sizeof(PtraceBlkReq{}))
+	reqs := (*[2]PtraceBlkReqReq)(unsafe.Pointer(&buf[reqOffset]))
+
+	// Setup GPR block (lower 32 bits)
+	gprOffset := reqOffset + numRequests*reqSize
+	gprBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprOffset]))
+
+	// Setup high GPR block (upper 32 bits)
+	gprHighOffset := gprOffset + gprSize
+	gprHighBlock := (*PtraceBlkGpr)(unsafe.Pointer(&buf[gprHighOffset]))
+
+	// Mark all GPRs as modified (set all 16 bits)
+	gprBlock.Writebitflags = 0xFFFF
+	gprHighBlock.Writebitflags = 0xFFFF
+
+	// Split 64-bit GPRs into low and high 32 bits
+	for i := 0; i < 16; i++ {
+		gprBlock.Gpr[i] = uint32(regs.Gprs[i] & 0xFFFFFFFF)
+		gprHighBlock.Gpr[i] = uint32(regs.Gprs[i] >> 32)
+	}
+
+	// Pack PSW for 31-bit targets (current z/OS)
+	// Upper 32 bits = mask, lower 32 bits = address
+	gprBlock.Wpsw = 1 // Mark PSW as modified
+	// Write PSW in old format (8 bytes at offset 144)
+	// Word 1 (mask) at bytes 0-3, Word 2 (addr) at bytes 4-7
+	pswMask := uint32(regs.Psw.Mask)
+	pswAddr := uint32(regs.Psw.Addr)
+	gprBlock.Psw[0] = byte(pswMask >> 24)
+	gprBlock.Psw[1] = byte(pswMask >> 16)
+	gprBlock.Psw[2] = byte(pswMask >> 8)
+	gprBlock.Psw[3] = byte(pswMask)
+	gprBlock.Psw[4] = byte(pswAddr >> 24)
+	gprBlock.Psw[5] = byte(pswAddr >> 16)
+	gprBlock.Psw[6] = byte(pswAddr >> 8)
+	gprBlock.Psw[7] = byte(pswAddr)
+
+	// Clear extended PSWG (not used for 31-bit targets)
+	for i := 0; i < 16; i++ {
+		gprBlock.Pswg[i] = 0
+	}
+
+	// Configure requests
+	// reqdata contains OFFSET from buffer start, not absolute address
+	reqs[0].Reqtype = PT_WRITE_GPR
+	reqs[0].Reqdata = uint32(gprOffset)
+	reqs[1].Reqtype = PT_WRITE_GPRH
+	reqs[1].Reqdata = uint32(gprHighOffset)
+
+	// Execute block request
+	rvBlk, rcBlk, rnBlk := Bpx4ptr(int32(PT_BLOCKREQ), int32(pid),
+		unsafe.Pointer(&buf[0]), unsafe.Pointer(uintptr(totalSize)), nil)
+	if rvBlk == -1 {
+		return errnoErr2(Errno(rcBlk), uintptr(rnBlk))
+	}
+
+	return nil
+}
+
+// PtraceSetOptions sets ptrace options.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_SETOPTIONS equivalent.
+// Returns ENOSYS to indicate this is not supported on z/OS.
+func PtraceSetOptions(pid int, options int) (err error) {
+	return ENOSYS
+}
+
+// PtraceGetEventMsg retrieves a message about the ptrace event.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_GETEVENTMSG equivalent.
+// Returns ENOSYS to indicate this is not supported on z/OS.
+func PtraceGetEventMsg(pid int) (msg uint, err error) {
+	return 0, ENOSYS
+}
+
+// PtraceSyscall continues execution and stops at the next syscall entry/exit.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_SYSCALL equivalent.
+// This function falls back to PT_CONTINUE and will NOT stop at syscalls.
+//
+// To trace syscalls on z/OS, applications must:
+// 1. Set breakpoints at BPX syscall entry points (requires knowledge of syscall vector)
+// 2. Detect BASR instructions that call into the BPX syscall vector
+// 3. Use PT_LDINFO to identify loaded modules and their entry points
+func PtraceSyscall(pid int, signal int) (err error) {
+	// z/OS doesn't have a direct PTRACE_SYSCALL equivalent
+	// Use PT_CONTINUE as a fallback (won't stop at syscalls)
+	return ptrace(PT_CONTINUE, pid, 0, uintptr(signal))
+}
+
+// Note: PtraceSingleStep is implemented in ptrace_zos_singlestep.go
+// with full two-breakpoint emulation for branch instructions.
+
+// PtraceInterrupt interrupts the traced process.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_INTERRUPT equivalent.
+// Returns ENOSYS to indicate this is not supported on z/OS.
+func PtraceInterrupt(pid int) (err error) {
+	return ENOSYS
+}
+
+// PtraceSeize attaches to a process without stopping it.
+// DIFFERENCE FROM LINUX: z/OS doesn't have PTRACE_SEIZE equivalent.
+// Uses PT_ATTACH as a fallback, which will stop the process.
+func PtraceSeize(pid int) (err error) {
+	// z/OS doesn't have PTRACE_SEIZE, use PT_ATTACH
+	// Note: This WILL stop the process, unlike Linux PTRACE_SEIZE
+	return ptrace(PT_ATTACH, pid, 0, 0)
+}
diff --git a/vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go b/vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go
new file mode 100644
index 00000000..7d7e2c8d
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/ptrace_zos_singlestep.go
@@ -0,0 +1,425 @@
+// 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.
+
+//go:build zos
+
+package unix
+
+import (
+	"sync"
+)
+
+// Single-stepping emulation for z/OS
+//
+// z/OS does not have native single-step support like Linux's PTRACE_SINGLESTEP.
+// Instead, single-stepping must be emulated using temporary breakpoints.
+//
+// This file provides a complete implementation of single-step emulation using
+// temporary breakpoints at both the sequential next instruction and branch target.
+
+const (
+	// NO_BRANCH_DEST indicates the instruction is not a branch or cannot branch
+	NO_BRANCH_DEST = 0xFFFFFFFF
+
+	// SVC_144 is the breakpoint instruction (SVC 144 = 0x0A90)
+	SVC_144 = 0x0A90
+
+	// Maximum number of temporary breakpoints (one for next PC, one for branch dest)
+	MAX_TEMP_BREAKPOINTS = 2
+
+	// S/390 branch instruction opcodes
+	// RR format (Register-Register)
+	opBCR   = 0x07 // Branch on Condition Register
+	opBALR  = 0x05 // Branch and Link Register
+	opBASR  = 0x0D // Branch and Save Register
+	opBASSM = 0x0C // Branch and Save and Set Mode
+	opBSM   = 0x0B // Branch and Set Mode
+	opBCTR  = 0x06 // Branch on Count Register
+
+	// RX format (Register-Index-Storage)
+	opBC  = 0x47 // Branch on Condition
+	opBAL = 0x45 // Branch and Link
+	opBCT = 0x46 // Branch on Count
+	opBAS = 0x4D // Branch and Save
+
+	// RS format (Register-Storage)
+	opBXH  = 0x86 // Branch on Index High
+	opBXLE = 0x87 // Branch on Index Low or Equal
+
+	// Extended branch opcodes
+	opBA7 = 0xA7 // A7x series (BRC, BRAS, BRCT, BRCTG)
+	opBC0 = 0xC0 // C0x series (BRASL, BRCL)
+	opBEC = 0xEC // ECxx series (RIEc format: compare-and-branch)
+)
+
+// tempBreakpoint represents a temporary breakpoint for single-stepping
+type tempBreakpoint struct {
+	address      uint64
+	originalInsn [8]byte // Save up to 8 bytes (full instruction)
+	active       bool
+}
+
+// singleStepState manages temporary breakpoints for a process
+type singleStepState struct {
+	mu          sync.Mutex
+	breakpoints [MAX_TEMP_BREAKPOINTS]tempBreakpoint
+}
+
+var (
+	// Global map of process states (pid -> state)
+	processStates   = make(map[int]*singleStepState)
+	processStatesMu sync.Mutex
+)
+
+// getProcessState returns or creates the single-step state for a process
+func getProcessState(pid int) *singleStepState {
+	processStatesMu.Lock()
+	defer processStatesMu.Unlock()
+
+	state, exists := processStates[pid]
+	if !exists {
+		state = &singleStepState{}
+		processStates[pid] = state
+	}
+	return state
+}
+
+// cleanupProcessState removes the state for a process (call on detach)
+func cleanupProcessState(pid int) {
+	processStatesMu.Lock()
+	defer processStatesMu.Unlock()
+	delete(processStates, pid)
+}
+
+// GetInstructionLength returns the length of an S/390 instruction in bytes.
+func GetInstructionLength(firstByte byte) int {
+	switch (firstByte >> 6) & 0x03 {
+	case 0x00:
+		return 2
+	case 0x01, 0x02:
+		return 4
+	case 0x03:
+		return 6
+	default:
+		return 2
+	}
+}
+
+// GetNextInstructionAddr returns the address of the next sequential instruction.
+func GetNextInstructionAddr(pc uint64, instruction []byte) uint64 {
+	if len(instruction) < 1 {
+		return pc + 2
+	}
+	insnLen := GetInstructionLength(instruction[0])
+	return pc + uint64(insnLen)
+}
+
+// CalculateBranchDest calculates the destination address for branch instructions.
+func CalculateBranchDest(pid int, pc uint64, instruction []byte) uint64 {
+	if len(instruction) < 6 {
+		return NO_BRANCH_DEST
+	}
+
+	inst0_15 := uint16(instruction[0])<<8 | uint16(instruction[1])
+	inst16_31 := uint16(instruction[2])<<8 | uint16(instruction[3])
+	inst32_47 := uint16(instruction[4])<<8 | uint16(instruction[5])
+	opcode := instruction[0]
+
+	var dest uint64 = NO_BRANCH_DEST
+
+	// RR format branches
+	if opcode == opBCR || opcode == opBALR || opcode == opBASR ||
+		opcode == opBASSM || opcode == opBSM || opcode == opBCTR {
+
+		r2 := int(inst0_15 & 0x0F)
+
+		if opcode == opBCR {
+			mask := int((inst0_15 >> 4) & 0x0F)
+			if mask == 0 || r2 == 0 {
+				return NO_BRANCH_DEST
+			}
+		} else {
+			if r2 == 0 {
+				return NO_BRANCH_DEST
+			}
+		}
+
+		var regs PtraceRegs
+		if err := PtraceGetRegs(pid, &regs); err == nil {
+			if r2 >= 0 && r2 < 16 {
+				regVal := regs.Gprs[r2]
+				dest = regVal
+			}
+		}
+	} else if opcode == opBC || opcode == opBAL || opcode == opBCT || opcode == opBAS {
+		// RX format branches
+		if opcode == opBC {
+			mask := int((inst0_15 >> 4) & 0x0F)
+			if mask == 0 {
+				return NO_BRANCH_DEST
+			}
+		}
+
+		index := int(inst0_15 & 0x0F)
+		base := int((inst16_31 >> 12) & 0x0F)
+		displacement := uint32(inst16_31 & 0x0FFF)
+
+		var baseVal, indexVal uint64
+		var regs PtraceRegs
+		if err := PtraceGetRegs(pid, &regs); err == nil {
+			if base != 0 && base < 16 {
+				baseVal = regs.Gprs[base]
+			}
+			if index != 0 && index < 16 {
+				indexVal = regs.Gprs[index]
+			}
+		}
+
+		if base == 0 && index == 0 {
+			dest = pc + uint64(displacement)
+		} else {
+			dest = baseVal + indexVal + uint64(displacement)
+		}
+	} else if opcode == opBXH || opcode == opBXLE {
+		// RS format branches
+		base := int((inst16_31 >> 12) & 0x0F)
+		displacement := uint32(inst16_31 & 0x0FFF)
+
+		var baseVal uint64
+		var regs PtraceRegs
+		if err := PtraceGetRegs(pid, &regs); err == nil {
+			if base != 0 && base < 16 {
+				baseVal = regs.Gprs[base]
+			}
+		}
+
+		dest = baseVal + uint64(displacement)
+	} else if opcode == opBA7 {
+		// RI format branches
+		subOp := int(inst0_15 & 0x0F)
+
+		if subOp < 4 || subOp > 7 {
+			return NO_BRANCH_DEST
+		}
+
+		if subOp == 0x04 {
+			mask := int((inst0_15 >> 4) & 0x0F)
+			if mask == 0 {
+				return NO_BRANCH_DEST
+			}
+		}
+
+		relDispl := int16(inst16_31)
+		dest = uint64(int64(pc) + int64(relDispl)*2)
+	} else if opcode == opBC0 {
+		// RIL format branches
+		subOp := int(inst0_15 & 0x0F)
+
+		if subOp == 0x04 || subOp == 0x05 {
+			if subOp == 0x04 {
+				mask := int((inst0_15 >> 4) & 0x0F)
+				if mask == 0 {
+					return NO_BRANCH_DEST
+				}
+			}
+
+			inst16_47 := (uint32(inst16_31) << 16) | uint32(inst32_47)
+			relDispl4 := int32(inst16_47)
+			dest = uint64(int64(pc) + int64(relDispl4)*2)
+		}
+	} else if opcode == opBEC {
+		// RIEc format compare-and-branch
+		subOp := instruction[4]
+
+		isCompareBranch := (subOp >= 0x64 && subOp <= 0x67) ||
+			(subOp >= 0x76 && subOp <= 0x77) ||
+			(subOp >= 0x7C && subOp <= 0x7F)
+
+		if isCompareBranch {
+			ri4 := int16(inst16_31)
+			dest = uint64(int64(pc) + int64(ri4)*2)
+		}
+	}
+
+	if dest < 0x2000 {
+		return NO_BRANCH_DEST
+	}
+
+	return dest
+}
+
+// setTempBreakpoint sets a temporary breakpoint at the specified address
+func (s *singleStepState) setTempBreakpoint(pid int, addr uint64) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// Find free slot
+	slot := -1
+	for i := 0; i < MAX_TEMP_BREAKPOINTS; i++ {
+		if !s.breakpoints[i].active {
+			slot = i
+			break
+		}
+	}
+
+	if slot == -1 {
+		return ENOMEM // All slots in use
+	}
+
+	// Read original instruction (up to 8 bytes for safety)
+	_, err := PtracePeekText(pid, uintptr(addr), s.breakpoints[slot].originalInsn[:])
+	if err != nil {
+		return err
+	}
+
+	// Write SVC 144 (0x0A90) as breakpoint
+	svc144 := []byte{0x0A, 0x90}
+	_, err = PtracePokeText(pid, uintptr(addr), svc144)
+	if err != nil {
+		return err
+	}
+
+	s.breakpoints[slot].address = addr
+	s.breakpoints[slot].active = true
+
+	return nil
+}
+
+// removeTempBreakpoints removes all active temporary breakpoints
+func (s *singleStepState) removeTempBreakpoints(pid int) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	var lastErr error
+	for i := 0; i < MAX_TEMP_BREAKPOINTS; i++ {
+		if !s.breakpoints[i].active {
+			continue
+		}
+
+		// Restore original instruction (first 2 bytes are enough for SVC 144)
+		_, err := PtracePokeText(pid, uintptr(s.breakpoints[i].address), s.breakpoints[i].originalInsn[:2])
+		if err != nil {
+			lastErr = err
+		}
+
+		s.breakpoints[i].active = false
+	}
+
+	return lastErr
+}
+
+// isTempBreakpoint checks if an address is a temporary breakpoint
+func (s *singleStepState) isTempBreakpoint(addr uint64) bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	for i := 0; i < MAX_TEMP_BREAKPOINTS; i++ {
+		if s.breakpoints[i].active && s.breakpoints[i].address == addr {
+			return true
+		}
+	}
+	return false
+}
+
+// PtraceSingleStep executes a single instruction using temporary breakpoints.
+//
+// This function:
+// 1. Reads the current instruction at PSW
+// 2. Calculates the next instruction address (sequential)
+// 3. If branch instruction, calculates branch destination
+// 4. Sets temporary breakpoints at both addresses
+// 5. Continues execution until breakpoint hit
+// 6. Restores original instructions and adjusts PSW
+//
+// Returns nil on success, error on failure.
+func PtraceSingleStep(pid int) error {
+	state := getProcessState(pid)
+
+	// 1. Get current PSW
+	var regs PtraceRegs
+	if err := PtraceGetRegs(pid, &regs); err != nil {
+		return err
+	}
+	pc := regs.Psw.Addr
+
+	// 2. Read instruction at PC
+	insn := make([]byte, 8)
+	if _, err := PtracePeekText(pid, uintptr(pc), insn); err != nil {
+		return err
+	}
+
+	// 3. Calculate next instruction addresses
+	nextPC := GetNextInstructionAddr(pc, insn)
+	branchDest := CalculateBranchDest(pid, pc, insn)
+
+	// 4. Set temporary breakpoints
+	if err := state.setTempBreakpoint(pid, nextPC); err != nil {
+		return err
+	}
+
+	// If branch instruction, set breakpoint at branch destination too
+	if branchDest != NO_BRANCH_DEST && branchDest != nextPC {
+		if err := state.setTempBreakpoint(pid, branchDest); err != nil {
+			state.removeTempBreakpoints(pid) // Cleanup first breakpoint
+			return err
+		}
+	}
+
+	// 5. Continue execution
+	if err := PtraceCont(pid, 0); err != nil {
+		state.removeTempBreakpoints(pid)
+		return err
+	}
+
+	// 6. Wait for breakpoint hit (retry on EINTR)
+	var status WaitStatus
+	for {
+		_, err := Wait4(pid, &status, 0, nil)
+		if err == EINTR {
+			continue // Retry on interrupted system call
+		}
+		if err != nil {
+			state.removeTempBreakpoints(pid)
+			return err
+		}
+		break
+	}
+
+	// Check if process stopped (should be at breakpoint)
+	if !status.Stopped() {
+		state.removeTempBreakpoints(pid)
+		return ECHILD // Process exited or error
+	}
+
+	// 7. Get current PSW (should be at breakpoint + 2)
+	if err := PtraceGetRegs(pid, &regs); err != nil {
+		state.removeTempBreakpoints(pid)
+		return err
+	}
+
+	// 8. Remove temporary breakpoints
+	if err := state.removeTempBreakpoints(pid); err != nil {
+		return err
+	}
+
+	// 9. Back up PSW by 2 bytes (to point at original instruction, not SVC 144)
+	// Use direct PSW write like ztrace does, not full register set
+	hitAddr := regs.Psw.Addr
+	if state.isTempBreakpoint(hitAddr - 2) {
+		if err := ptraceWritePSW(pid, uint32(hitAddr-2)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// PtraceDetachWithCleanup detaches from a process and cleans up single-step state.
+// Use this instead of PtraceDetach when using PtraceSingleStep.
+func PtraceDetachWithCleanup(pid int) error {
+	state := getProcessState(pid)
+	state.removeTempBreakpoints(pid)
+	cleanupProcessState(pid)
+	return PtraceDetach(pid)
+}
diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go
index 38590ca8..cb9d0a18 100644
--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -369,6 +369,7 @@ func Flistxattr(fd int, dest []byte) (sz int, err error) {
  */
 
 //sys	fcntl(fd int, cmd int, arg int) (val int, err error)
+//sys	fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) = SYS_FCNTL
 
 //sys	kill(pid int, signum int, posix int) (err error)
 
diff --git a/vendor/golang.org/x/sys/unix/syscall_freebsd.go b/vendor/golang.org/x/sys/unix/syscall_freebsd.go
index 2b57e0f7..49518899 100644
--- a/vendor/golang.org/x/sys/unix/syscall_freebsd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_freebsd.go
@@ -369,6 +369,15 @@ func Dup3(oldfd, newfd, flags int) error {
 //sys	ExtattrSetLink(link string, attrnamespace int, attrname string, data uintptr, nbytes int) (ret int, err error)
 //sys	ExtattrDeleteLink(link string, attrnamespace int, attrname string) (err error)
 //sys	ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (ret int, err error)
+//sys	extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
 //sys	Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_POSIX_FADVISE
 //sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 //sys	Fchdir(fd int) (err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go
index 6926057e..a31e2c71 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux.go
@@ -1991,7 +1991,24 @@ func FsconfigReconfigure(fd int) (err error) {
 	return fsconfig(fd, FSCONFIG_CMD_RECONFIGURE, nil, nil, 0)
 }
 
-//sys	Getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64
+//sys	getdents(fd int, buf []byte) (n int, err error) = SYS_GETDENTS64
+
+// Getdents reads directory entries from fd into buf.
+func Getdents(fd int, buf []byte) (n int, err error) {
+	// getdents64 stores d_ino with a 64-bit write, which faults on
+	// strict-alignment targets unless buf is 8-aligned.
+	if len(buf) > 0 {
+		if off := int(-uintptr(unsafe.Pointer(&buf[0])) & 7); off > 0 && off < len(buf) {
+			n, err = getdents(fd, buf[off:])
+			if n > 0 {
+				copy(buf, buf[off:off+n])
+			}
+			return n, err
+		}
+	}
+	return getdents(fd, buf)
+}
+
 //sysnb	Getpgid(pid int) (pgid int, err error)
 
 func Getpgrp() (pid int) {
@@ -2033,6 +2050,7 @@ func Getrandom(buf []byte, flags int) (n int, err error) {
 //sysnb	Kill(pid int, sig syscall.Signal) (err error)
 //sys	Klogctl(typ int, buf []byte) (n int, err error) = SYS_SYSLOG
 //sys	Lgetxattr(path string, attr string, dest []byte) (sz int, err error)
+//sys	Listns(req *NsIdReq, nsIds []uint64, flags uint) (n int, err error)
 //sys	Listxattr(path string, dest []byte) (sz int, err error)
 //sys	Llistxattr(path string, dest []byte) (sz int, err error)
 //sys	Lremovexattr(path string, attr string) (err error)
@@ -2046,6 +2064,7 @@ func Getrandom(buf []byte, flags int) (n int, err error) {
 //sys	PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error)
 //sys	PivotRoot(newroot string, putold string) (err error) = SYS_PIVOT_ROOT
 //sys	Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (err error)
+//sys	PrctlArg5Ptr(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 unsafe.Pointer) (err error) = SYS_PRCTL
 //sys	pselect6(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *sigset_argpack) (n int, err error)
 //sys	read(fd int, p []byte) (n int, err error)
 //sys	Removexattr(path string, attr string) (err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go b/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
index 4964119a..cd50715c 100644
--- a/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/syscall_linux_sparc64.go
@@ -8,7 +8,7 @@ package unix
 
 //sys	Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64
 //sys	Fchown(fd int, uid int, gid int) (err error)
-//sys	Fstat(fd int, stat *Stat_t) (err error)
+//sys	Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
 //sys	Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
 //sys	Fstatfs(fd int, buf *Statfs_t) (err error)
 //sys	Ftruncate(fd int, length int64) (err error)
@@ -19,7 +19,7 @@ package unix
 //sysnb	Getuid() (uid int)
 //sys	Lchown(path string, uid int, gid int) (err error)
 //sys	Listen(s int, n int) (err error)
-//sys	Lstat(path string, stat *Stat_t) (err error)
+//sys	Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
 //sys	Pause() (err error)
 //sys	pread(fd int, p []byte, offset int64) (n int, err error) = SYS_PREAD64
 //sys	pwrite(fd int, p []byte, offset int64) (n int, err error) = SYS_PWRITE64
@@ -31,7 +31,7 @@ package unix
 //sys	setfsuid(uid int) (prev int, err error)
 //sys	Shutdown(fd int, how int) (err error)
 //sys	Splice(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)
-//sys	Stat(path string, stat *Stat_t) (err error)
+//sys	Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
 //sys	Statfs(path string, buf *Statfs_t) (err error)
 //sys	SyncFileRange(fd int, off int64, n int64, flags int) (err error)
 //sys	Truncate(path string, length int64) (err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_netbsd.go b/vendor/golang.org/x/sys/unix/syscall_netbsd.go
index 34a46769..c8badc54 100644
--- a/vendor/golang.org/x/sys/unix/syscall_netbsd.go
+++ b/vendor/golang.org/x/sys/unix/syscall_netbsd.go
@@ -293,6 +293,15 @@ func Getvfsstat(buf []Statvfs_t, flags int) (n int, err error) {
 //sys	ExtattrSetLink(link string, attrnamespace int, attrname string, data uintptr, nbytes int) (ret int, err error)
 //sys	ExtattrDeleteLink(link string, attrnamespace int, attrname string) (err error)
 //sys	ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (ret int, err error)
+//sys	extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error)
+//sys	extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error)
 //sys	Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
 //sys	Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_POSIX_FADVISE
 //sys	Fchdir(fd int) (err error)
diff --git a/vendor/golang.org/x/sys/unix/syscall_unix_gc.go b/vendor/golang.org/x/sys/unix/syscall_unix_gc.go
index 05c95bcc..60c0d16c 100644
--- a/vendor/golang.org/x/sys/unix/syscall_unix_gc.go
+++ b/vendor/golang.org/x/sys/unix/syscall_unix_gc.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build (darwin || dragonfly || freebsd || (linux && !ppc64 && !ppc64le) || netbsd || openbsd || solaris) && gc
+//go:build (darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris) && gc
 
 package unix
 
diff --git a/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go b/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go
deleted file mode 100644
index 23f39b7a..00000000
--- a/vendor/golang.org/x/sys/unix/syscall_unix_gc_ppc64x.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2018 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 linux && (ppc64le || ppc64) && gc
-
-package unix
-
-import "syscall"
-
-func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.Syscall(trap, a1, a2, a3)
-}
-func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.Syscall6(trap, a1, a2, a3, a4, a5, a6)
-}
-func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.RawSyscall(trap, a1, a2, a3)
-}
-func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return syscall.RawSyscall6(trap, a1, a2, a3, a4, a5, a6)
-}
diff --git a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
index 7bf5c04b..edabb689 100644
--- a/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go
@@ -27,14 +27,10 @@ import (
 	"unsafe"
 )
 
-//go:noescape
-func initZosLibVec()
-
 //go:noescape
 func GetZosLibVec() uintptr
 
 func init() {
-	initZosLibVec()
 	r0, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS_____GETENV_A<<4, uintptr(unsafe.Pointer(&([]byte("__ZOS_XSYSTRACE\x00"))[0])))
 	if r0 != 0 {
 		n, _, _ := CallLeFuncWithPtrReturn(GetZosLibVec()+SYS___ATOI_A<<4, r0)
diff --git a/vendor/golang.org/x/sys/unix/xattr_bsd.go b/vendor/golang.org/x/sys/unix/xattr_bsd.go
index e1687939..d3d12c27 100644
--- a/vendor/golang.org/x/sys/unix/xattr_bsd.go
+++ b/vendor/golang.org/x/sys/unix/xattr_bsd.go
@@ -56,7 +56,7 @@ func Getxattr(file string, attr string, dest []byte) (sz int, err error) {
 		return -1, err
 	}
 
-	return ExtattrGetFile(file, nsid, a, uintptr(d), destsize)
+	return extattrGetFile(file, nsid, a, d, destsize)
 }
 
 func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
@@ -68,7 +68,7 @@ func Fgetxattr(fd int, attr string, dest []byte) (sz int, err error) {
 		return -1, err
 	}
 
-	return ExtattrGetFd(fd, nsid, a, uintptr(d), destsize)
+	return extattrGetFd(fd, nsid, a, d, destsize)
 }
 
 func Lgetxattr(link string, attr string, dest []byte) (sz int, err error) {
@@ -80,7 +80,7 @@ func Lgetxattr(link string, attr string, dest []byte) (sz int, err error) {
 		return -1, err
 	}
 
-	return ExtattrGetLink(link, nsid, a, uintptr(d), destsize)
+	return extattrGetLink(link, nsid, a, d, destsize)
 }
 
 // flags are unused on FreeBSD
@@ -97,7 +97,7 @@ func Fsetxattr(fd int, attr string, data []byte, flags int) (err error) {
 		return
 	}
 
-	_, err = ExtattrSetFd(fd, nsid, a, uintptr(d), datasiz)
+	_, err = extattrSetFd(fd, nsid, a, d, datasiz)
 	return
 }
 
@@ -113,7 +113,7 @@ func Setxattr(file string, attr string, data []byte, flags int) (err error) {
 		return
 	}
 
-	_, err = ExtattrSetFile(file, nsid, a, uintptr(d), datasiz)
+	_, err = extattrSetFile(file, nsid, a, d, datasiz)
 	return
 }
 
@@ -129,7 +129,7 @@ func Lsetxattr(link string, attr string, data []byte, flags int) (err error) {
 		return
 	}
 
-	_, err = ExtattrSetLink(link, nsid, a, uintptr(d), datasiz)
+	_, err = extattrSetLink(link, nsid, a, d, datasiz)
 	return
 }
 
@@ -199,9 +199,9 @@ func ListxattrNS(file string, nsid int, dest []byte) (sz int, err error) {
 	d := initxattrdest(dest, 0)
 	destsiz := len(dest)
 
-	s, e := ExtattrListFile(file, nsid, uintptr(d), destsiz)
+	s, e := extattrListFile(file, nsid, d, destsiz)
 	if e != nil {
-		return 0, err
+		return 0, e
 	}
 
 	return s, nil
@@ -235,9 +235,9 @@ func FlistxattrNS(fd int, nsid int, dest []byte) (sz int, err error) {
 	d := initxattrdest(dest, 0)
 	destsiz := len(dest)
 
-	s, e := ExtattrListFd(fd, nsid, uintptr(d), destsiz)
+	s, e := extattrListFd(fd, nsid, d, destsiz)
 	if e != nil {
-		return 0, err
+		return 0, e
 	}
 
 	return s, nil
@@ -271,9 +271,9 @@ func LlistxattrNS(link string, nsid int, dest []byte) (sz int, err error) {
 	d := initxattrdest(dest, 0)
 	destsiz := len(dest)
 
-	s, e := ExtattrListLink(link, nsid, uintptr(d), destsiz)
+	s, e := extattrListLink(link, nsid, d, destsiz)
 	if e != nil {
-		return 0, err
+		return 0, e
 	}
 
 	return s, nil
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
index d73c4652..01a39533 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_amd64.go
@@ -1128,6 +1128,7 @@ const (
 	O_DSYNC                                 = 0x400000
 	O_EVTONLY                               = 0x8000
 	O_EXCL                                  = 0x800
+	O_EXEC                                  = 0x40000000
 	O_EXLOCK                                = 0x20
 	O_FSYNC                                 = 0x80
 	O_NDELAY                                = 0x4
@@ -1138,6 +1139,7 @@ const (
 	O_POPUP                                 = 0x80000000
 	O_RDONLY                                = 0x0
 	O_RDWR                                  = 0x2
+	O_SEARCH                                = 0x40100000
 	O_SHLOCK                                = 0x10
 	O_SYMLINK                               = 0x200000
 	O_SYNC                                  = 0x80
@@ -1147,6 +1149,10 @@ const (
 	PARMRK                                  = 0x8
 	PARODD                                  = 0x2000
 	PENDIN                                  = 0x20000000
+	PRIO_DARWIN_BG                          = 0x1000
+	PRIO_DARWIN_NONUI                       = 0x1001
+	PRIO_DARWIN_PROCESS                     = 0x4
+	PRIO_DARWIN_THREAD                      = 0x3
 	PRIO_PGRP                               = 0x1
 	PRIO_PROCESS                            = 0x0
 	PRIO_USER                               = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
index 4a55a400..d80b95f6 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_darwin_arm64.go
@@ -1128,6 +1128,7 @@ const (
 	O_DSYNC                                 = 0x400000
 	O_EVTONLY                               = 0x8000
 	O_EXCL                                  = 0x800
+	O_EXEC                                  = 0x40000000
 	O_EXLOCK                                = 0x20
 	O_FSYNC                                 = 0x80
 	O_NDELAY                                = 0x4
@@ -1138,6 +1139,7 @@ const (
 	O_POPUP                                 = 0x80000000
 	O_RDONLY                                = 0x0
 	O_RDWR                                  = 0x2
+	O_SEARCH                                = 0x40100000
 	O_SHLOCK                                = 0x10
 	O_SYMLINK                               = 0x200000
 	O_SYNC                                  = 0x80
@@ -1147,6 +1149,10 @@ const (
 	PARMRK                                  = 0x8
 	PARODD                                  = 0x2000
 	PENDIN                                  = 0x20000000
+	PRIO_DARWIN_BG                          = 0x1000
+	PRIO_DARWIN_NONUI                       = 0x1001
+	PRIO_DARWIN_PROCESS                     = 0x4
+	PRIO_DARWIN_THREAD                      = 0x3
 	PRIO_PGRP                               = 0x1
 	PRIO_PROCESS                            = 0x0
 	PRIO_USER                               = 0x2
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 45feb124..aa68cb8d 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -752,10 +752,12 @@ const (
 	CLONE_ARGS_SIZE_VER0                        = 0x40
 	CLONE_ARGS_SIZE_VER1                        = 0x50
 	CLONE_ARGS_SIZE_VER2                        = 0x58
+	CLONE_AUTOREAP                              = 0x400000000
 	CLONE_CHILD_CLEARTID                        = 0x200000
 	CLONE_CHILD_SETTID                          = 0x1000000
 	CLONE_CLEAR_SIGHAND                         = 0x100000000
 	CLONE_DETACHED                              = 0x400000
+	CLONE_EMPTY_MNTNS                           = 0x2000000000
 	CLONE_FILES                                 = 0x400
 	CLONE_FS                                    = 0x200
 	CLONE_INTO_CGROUP                           = 0x200000000
@@ -768,9 +770,11 @@ const (
 	CLONE_NEWTIME                               = 0x80
 	CLONE_NEWUSER                               = 0x10000000
 	CLONE_NEWUTS                                = 0x4000000
+	CLONE_NNP                                   = 0x800000000
 	CLONE_PARENT                                = 0x8000
 	CLONE_PARENT_SETTID                         = 0x100000
 	CLONE_PIDFD                                 = 0x1000
+	CLONE_PIDFD_AUTOKILL                        = 0x1000000000
 	CLONE_PTRACE                                = 0x2000
 	CLONE_SETTLS                                = 0x80000
 	CLONE_SIGHAND                               = 0x800
@@ -803,12 +807,15 @@ const (
 	DEVLINK_GENL_MCGRP_CONFIG_NAME              = "config"
 	DEVLINK_GENL_NAME                           = "devlink"
 	DEVLINK_GENL_VERSION                        = 0x1
+	DEVLINK_INDEX_BUS_NAME                      = "devlink_index"
 	DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO            = 0x4
 	DEVLINK_PORT_FN_CAP_IPSEC_PACKET            = 0x8
 	DEVLINK_PORT_FN_CAP_MIGRATABLE              = 0x2
 	DEVLINK_PORT_FN_CAP_ROCE                    = 0x1
 	DEVLINK_RATE_TCS_MAX                        = 0x8
 	DEVLINK_RATE_TC_INDEX_MAX                   = 0x7
+	DEVLINK_RESOURCE_SCOPE_DEV                  = 0x1
+	DEVLINK_RESOURCE_SCOPE_PORT                 = 0x2
 	DEVLINK_SB_THRESHOLD_TO_ALPHA_MAX           = 0x14
 	DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS  = 0x3
 	DEVMEM_MAGIC                                = 0x454d444d
@@ -1127,6 +1134,7 @@ const (
 	ETHTOOL_SWOL                                = 0x6
 	ETHTOOL_TEST                                = 0x1a
 	ETH_P_1588                                  = 0x88f7
+	ETH_P_8021AC                                = 0x8870
 	ETH_P_8021AD                                = 0x88a8
 	ETH_P_8021AH                                = 0x88e7
 	ETH_P_8021Q                                 = 0x8100
@@ -1170,6 +1178,7 @@ const (
 	ETH_P_ETHERCAT                              = 0x88a4
 	ETH_P_FCOE                                  = 0x8906
 	ETH_P_FIP                                   = 0x8914
+	ETH_P_GRE_OSI                               = 0xfe
 	ETH_P_HDLC                                  = 0x19
 	ETH_P_HSR                                   = 0x892f
 	ETH_P_IBOE                                  = 0x8915
@@ -1198,6 +1207,7 @@ const (
 	ETH_P_MXLGSW                                = 0x88c3
 	ETH_P_NCSI                                  = 0x88f8
 	ETH_P_NSH                                   = 0x894f
+	ETH_P_NXP_NETC                              = 0xfd3a
 	ETH_P_PAE                                   = 0x888e
 	ETH_P_PAUSE                                 = 0x8808
 	ETH_P_PHONET                                = 0xf5
@@ -1359,6 +1369,7 @@ const (
 	FAN_UNLIMITED_MARKS                         = 0x20
 	FAN_UNLIMITED_QUEUE                         = 0x10
 	FD_CLOEXEC                                  = 0x1
+	FD_NSFS_ROOT                                = -0x2713
 	FD_PIDFS_ROOT                               = -0x2712
 	FD_SETSIZE                                  = 0x400
 	FF0                                         = 0x0
@@ -1427,6 +1438,8 @@ const (
 	FS_POLICY_FLAGS_PAD_8                       = 0x1
 	FS_POLICY_FLAGS_PAD_MASK                    = 0x3
 	FS_POLICY_FLAGS_VALID                       = 0x7
+	FS_SHUTDOWN_FLAGS_LOGFLUSH                  = 0x1
+	FS_SHUTDOWN_FLAGS_NOLOGFLUSH                = 0x2
 	FS_VERITY_FL                                = 0x100000
 	FS_VERITY_HASH_ALG_SHA256                   = 0x1
 	FS_VERITY_HASH_ALG_SHA512                   = 0x2
@@ -1441,6 +1454,7 @@ const (
 	F_DUPFD_CLOEXEC                             = 0x406
 	F_DUPFD_QUERY                               = 0x403
 	F_EXLCK                                     = 0x4
+	F_GETDELEG                                  = 0x40f
 	F_GETFD                                     = 0x1
 	F_GETFL                                     = 0x3
 	F_GETLEASE                                  = 0x401
@@ -1462,6 +1476,7 @@ const (
 	F_SEAL_SEAL                                 = 0x1
 	F_SEAL_SHRINK                               = 0x2
 	F_SEAL_WRITE                                = 0x8
+	F_SETDELEG                                  = 0x410
 	F_SETFD                                     = 0x2
 	F_SETFL                                     = 0x4
 	F_SETLEASE                                  = 0x400
@@ -1632,6 +1647,7 @@ const (
 	IN_UNMOUNT                                  = 0x2000
 	IOCTL_MEI_CONNECT_CLIENT                    = 0xc0104801
 	IOCTL_MEI_CONNECT_CLIENT_VTAG               = 0xc0144804
+	IPPROTO_AGGFRAG                             = 0x90
 	IPPROTO_AH                                  = 0x33
 	IPPROTO_BEETPH                              = 0x5e
 	IPPROTO_COMP                                = 0x6c
@@ -1913,10 +1929,14 @@ const (
 	LANDLOCK_ACCESS_FS_REFER                    = 0x2000
 	LANDLOCK_ACCESS_FS_REMOVE_DIR               = 0x10
 	LANDLOCK_ACCESS_FS_REMOVE_FILE              = 0x20
+	LANDLOCK_ACCESS_FS_RESOLVE_UNIX             = 0x10000
 	LANDLOCK_ACCESS_FS_TRUNCATE                 = 0x4000
 	LANDLOCK_ACCESS_FS_WRITE_FILE               = 0x2
 	LANDLOCK_ACCESS_NET_BIND_TCP                = 0x1
+	LANDLOCK_ACCESS_NET_BIND_UDP                = 0x4
+	LANDLOCK_ACCESS_NET_CONNECT_SEND_UDP        = 0x8
 	LANDLOCK_ACCESS_NET_CONNECT_TCP             = 0x2
+	LANDLOCK_ADD_RULE_QUIET                     = 0x1
 	LANDLOCK_CREATE_RULESET_ERRATA              = 0x2
 	LANDLOCK_CREATE_RULESET_VERSION             = 0x1
 	LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON      = 0x2
@@ -3408,6 +3428,7 @@ const (
 	SCHED_FLAG_UTIL_CLAMP                       = 0x60
 	SCHED_FLAG_UTIL_CLAMP_MAX                   = 0x40
 	SCHED_FLAG_UTIL_CLAMP_MIN                   = 0x20
+	SCHED_GETATTR_FLAG_DL_DYNAMIC               = 0x1
 	SCHED_IDLE                                  = 0x5
 	SCHED_NORMAL                                = 0x0
 	SCHED_RESET_ON_FORK                         = 0x40000000
@@ -3790,6 +3811,14 @@ const (
 	TCPOPT_TIMESTAMP                            = 0x8
 	TCPOPT_TSTAMP_HDR                           = 0x101080a
 	TCPOPT_WINDOW                               = 0x3
+	TCP_ACCECN_ACE_FAIL_RECV                    = 0x2
+	TCP_ACCECN_ACE_FAIL_SEND                    = 0x1
+	TCP_ACCECN_OPT_COUNTER_SEEN                 = 0x2
+	TCP_ACCECN_OPT_EMPTY_SEEN                   = 0x1
+	TCP_ACCECN_OPT_FAIL_RECV                    = 0x8
+	TCP_ACCECN_OPT_FAIL_SEEN                    = 0x3
+	TCP_ACCECN_OPT_FAIL_SEND                    = 0x4
+	TCP_ACCECN_OPT_NOT_SEEN                     = 0x0
 	TCP_AO_KEYF_EXCLUDE_OPT                     = 0x2
 	TCP_AO_KEYF_IFINDEX                         = 0x1
 	TCP_AO_MAXKEYLEN                            = 0x50
@@ -3804,6 +3833,7 @@ const (
 	TCP_COOKIE_TRANSACTIONS                     = 0xf
 	TCP_CORK                                    = 0x3
 	TCP_DEFER_ACCEPT                            = 0x9
+	TCP_DELACK_MAX_US                           = 0x2e
 	TCP_FASTOPEN                                = 0x17
 	TCP_FASTOPEN_CONNECT                        = 0x1e
 	TCP_FASTOPEN_KEY                            = 0x21
@@ -3836,6 +3866,8 @@ const (
 	TCP_REPAIR_OPTIONS                          = 0x16
 	TCP_REPAIR_QUEUE                            = 0x14
 	TCP_REPAIR_WINDOW                           = 0x1d
+	TCP_RTO_MAX_MS                              = 0x2c
+	TCP_RTO_MIN_US                              = 0x2d
 	TCP_SAVED_SYN                               = 0x1c
 	TCP_SAVE_SYN                                = 0x1b
 	TCP_SYNCNT                                  = 0x7
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 6f74d4a0..5aaf4bc7 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -600,6 +600,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -840,6 +841,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 36c1f0b6..b8e6287a 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -600,6 +600,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -840,6 +841,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 c5512dbe..464f8218 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -605,6 +605,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -845,6 +846,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 4dabfae0..735265b6 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -602,6 +602,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -842,6 +843,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 ea97930f..1970ce82 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
@@ -592,6 +592,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -832,6 +833,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 0826a929..56de9aeb 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -601,6 +601,7 @@ const (
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@ var errorList = [...]struct {
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
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 139deedd..26ca1cac 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -601,6 +601,7 @@ const (
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@ var errorList = [...]struct {
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
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 b8018af3..b19df234 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -601,6 +601,7 @@ const (
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@ var errorList = [...]struct {
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
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 deb5c2e6..9ba3c950 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -601,6 +601,7 @@ const (
 	EDQUOT          = syscall.Errno(0x46d)
 	EFSBADCRC       = syscall.Errno(0x4d)
 	EFSCORRUPTED    = syscall.Errno(0x87)
+	EFTYPE          = syscall.Errno(0xa9)
 	EHOSTDOWN       = syscall.Errno(0x93)
 	EHOSTUNREACH    = syscall.Errno(0x94)
 	EHWPOISON       = syscall.Errno(0xa8)
@@ -845,6 +846,7 @@ var errorList = [...]struct {
 	{166, "ENOTRECOVERABLE", "state not recoverable"},
 	{167, "ERFKILL", "operation not possible due to RF-kill"},
 	{168, "EHWPOISON", "memory page has hardware error"},
+	{169, "EFTYPE", "unknown error 169"},
 	{1133, "EDQUOT", "disk quota exceeded"},
 }
 
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 0603bf3a..62da59f9 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
@@ -657,6 +657,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -898,6 +899,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 5fa8a5d3..d18d4dae 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -661,6 +661,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -902,6 +903,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 2733e999..ba7767db 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -661,6 +661,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -902,6 +903,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 1470172f..76cb2211 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -602,6 +602,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -842,6 +843,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 1871579c..ffd12a97 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -661,6 +661,7 @@ const (
 	EDQUOT          = syscall.Errno(0x7a)
 	EFSBADCRC       = syscall.Errno(0x4a)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x86)
 	EHOSTDOWN       = syscall.Errno(0x70)
 	EHOSTUNREACH    = syscall.Errno(0x71)
 	EHWPOISON       = syscall.Errno(0x85)
@@ -901,6 +902,7 @@ var errorList = [...]struct {
 	{131, "ENOTRECOVERABLE", "state not recoverable"},
 	{132, "ERFKILL", "operation not possible due to RF-kill"},
 	{133, "EHWPOISON", "memory page has hardware error"},
+	{134, "EFTYPE", "unknown error 134"},
 }
 
 // Signal table
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 10881cf6..f372aed3 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -704,6 +704,7 @@ const (
 	EDQUOT          = syscall.Errno(0x45)
 	EFSBADCRC       = syscall.Errno(0x4c)
 	EFSCORRUPTED    = syscall.Errno(0x75)
+	EFTYPE          = syscall.Errno(0x88)
 	EHOSTDOWN       = syscall.Errno(0x40)
 	EHOSTUNREACH    = syscall.Errno(0x41)
 	EHWPOISON       = syscall.Errno(0x87)
@@ -950,6 +951,7 @@ var errorList = [...]struct {
 	{133, "ENOTRECOVERABLE", "state not recoverable"},
 	{134, "ERFKILL", "operation not possible due to RF-kill"},
 	{135, "EHWPOISON", "memory page has hardware error"},
+	{136, "EFTYPE", "unknown error 136"},
 }
 
 // Signal table
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
index 813c05b6..7db9bf5f 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go
@@ -702,6 +702,17 @@ var libc_fcntl_trampoline_addr uintptr
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+	r0, _, e1 := syscall_syscall(libc_fcntl_trampoline_addr, uintptr(fd), uintptr(cmd), uintptr(arg))
+	val = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func kill(pid int, signum int, posix int) (err error) {
 	_, _, e1 := syscall_syscall(libc_kill_trampoline_addr, uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
index e6f58f3c..2a658059 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_darwin_arm64.go
@@ -702,6 +702,17 @@ var libc_fcntl_trampoline_addr uintptr
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func fcntlPtr(fd int, cmd int, arg unsafe.Pointer) (val int, err error) {
+	r0, _, e1 := syscall_syscall(libc_fcntl_trampoline_addr, uintptr(fd), uintptr(cmd), uintptr(arg))
+	val = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func kill(pid int, signum int, posix int) (err error) {
 	_, _, e1 := syscall_syscall(libc_kill_trampoline_addr, uintptr(pid), uintptr(signum), uintptr(posix))
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go
index c0096391..10b57ffb 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_386.go
@@ -825,6 +825,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(length), uintptr(length>>32), uintptr(advice))
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go
index 7664df74..6a6fc3cc 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_amd64.go
@@ -825,6 +825,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go
index ae099182..4a15b4ab 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm.go
@@ -825,6 +825,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall9(SYS_POSIX_FADVISE, uintptr(fd), 0, uintptr(offset), uintptr(offset>>32), uintptr(length), uintptr(length>>32), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go
index 11fd5d45..f15331fb 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_arm64.go
@@ -825,6 +825,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go
index c3d2d653..faa56264 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_freebsd_riscv64.go
@@ -825,6 +825,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Fadvise(fd int, offset int64, length int64, advice int) (err error) {
 	_, _, e1 := Syscall6(SYS_POSIX_FADVISE, uintptr(fd), uintptr(offset), uintptr(length), uintptr(advice), 0, 0)
 	if e1 != 0 {
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
index 5788c2a5..4c63b976 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go
@@ -943,7 +943,7 @@ func fsconfig(fd int, cmd uint, key *byte, value *byte, aux int) (err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
-func Getdents(fd int, buf []byte) (n int, err error) {
+func getdents(fd int, buf []byte) (n int, err error) {
 	var _p0 unsafe.Pointer
 	if len(buf) > 0 {
 		_p0 = unsafe.Pointer(&buf[0])
@@ -1167,6 +1167,23 @@ func Lgetxattr(path string, attr string, dest []byte) (sz int, err error) {
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func Listns(req *NsIdReq, nsIds []uint64, flags uint) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(nsIds) > 0 {
+		_p0 = unsafe.Pointer(&nsIds[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_LISTNS, uintptr(unsafe.Pointer(req)), uintptr(_p0), uintptr(len(nsIds)), uintptr(flags), 0, 0)
+	n = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Listxattr(path string, dest []byte) (sz int, err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
@@ -1390,6 +1407,16 @@ func Prctl(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 uintptr) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func PrctlArg5Ptr(option int, arg2 uintptr, arg3 uintptr, arg4 uintptr, arg5 unsafe.Pointer) (err error) {
+	_, _, e1 := Syscall6(SYS_PRCTL, uintptr(option), uintptr(arg2), uintptr(arg3), uintptr(arg4), uintptr(arg5), 0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func pselect6(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timespec, sigmask *sigset_argpack) (n int, err error) {
 	r0, _, e1 := Syscall6(SYS_PSELECT6, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), uintptr(unsafe.Pointer(sigmask)))
 	n = int(r0)
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go
index 52763762..b7aca545 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_linux_sparc64.go
@@ -66,7 +66,7 @@ func Fchown(fd int, uid int, gid int) (err error) {
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
 func Fstat(fd int, stat *Stat_t) (err error) {
-	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -183,7 +183,7 @@ func Lstat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
@@ -338,7 +338,7 @@ func Stat(path string, stat *Stat_t) (err error) {
 	if err != nil {
 		return
 	}
-	_, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
+	_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 	if e1 != 0 {
 		err = errnoErr(e1)
 	}
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
index e91ebc14..1e136d12 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_386.go
@@ -802,6 +802,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
index be28babb..440db6ec 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_amd64.go
@@ -802,6 +802,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
index fb587e82..db963000 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm.go
@@ -802,6 +802,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff --git a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
index d576438b..c4bea6c8 100644
--- a/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsyscall_netbsd_arm64.go
@@ -802,6 +802,165 @@ func ExtattrListLink(link string, attrnamespace int, data uintptr, nbytes int) (
 
 // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
+func extattrGetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFd(fd int, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FD, uintptr(fd), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p0)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFd(fd int, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FD, uintptr(fd), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetFile(file string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListFile(file string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(file)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_FILE, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrGetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_GET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrSetLink(link string, attrnamespace int, attrname string, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(attrname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_SET_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(unsafe.Pointer(_p1)), uintptr(data), uintptr(nbytes), 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func extattrListLink(link string, attrnamespace int, data unsafe.Pointer, nbytes int) (ret int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(link)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_EXTATTR_LIST_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(attrnamespace), uintptr(data), uintptr(nbytes), 0, 0)
+	ret = int(r0)
+	if e1 != 0 {
+		err = errnoErr(e1)
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
 func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
 	var _p0 *byte
 	_p0, err = BytePtrFromString(path)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go
index 5e8c263c..f09f8447 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_zos_s390x.go
@@ -2848,5 +2848,18 @@ const (
 	SYS_____CHATTRAT64_A                = 0xE39 // 3641
 	SYS_MADVISE                         = 0xE3A // 3642
 	SYS___AUTHENTICATE                  = 0xE3B // 3643
+	SYS_GETPWENT_R                      = 0xE3C // 3644
+	SYS___GETPWENT_R_A                  = 0xE3D // 3645
+	SYS_STRNLEN                         = 0xE3E // 3646
+	SYS_STPCPY                          = 0xE3F // 3647
+	SYS_STPNCPY                         = 0xE40 // 3648
+	SYS_STRSIGNAL                       = 0xE41 // 3649
+	SYS_WCPCPY                          = 0xE42 // 3650
+	SYS_WCPNCPY                         = 0xE43 // 3651
+	SYS_WCSNLEN                         = 0xE44 // 3652
+	SYS___STRSIGNAL_A                   = 0xE45 // 3653
+	SYS_FDOPENDIR                       = 0xE46 // 3654
+	SYS_FDCLOSEDIR                      = 0xE47 // 3655
+	SYS_SYSCALL                         = 0xE48 // 3656
 
 )
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go
index 538a18f2..2b3c00b9 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -933,6 +933,29 @@ type OpenHow struct {
 
 const SizeofOpenHow = 0x18
 
+type NsIdReq struct {
+	Size       uint32
+	Spare      uint32
+	Ns_id      uint64
+	Ns_type    uint32
+	Spare2     uint32
+	User_ns_id uint64
+}
+
+const (
+	NS_ID_REQ_SIZE_VER0 = 0x20
+	LISTNS_CURRENT_USER = 0xffffffffffffffff
+
+	TIME_NS   = 0x80
+	MNT_NS    = 0x20000
+	CGROUP_NS = 0x2000000
+	UTS_NS    = 0x4000000
+	IPC_NS    = 0x8000000
+	USER_NS   = 0x10000000
+	PID_NS    = 0x20000000
+	NET_NS    = 0x40000000
+)
+
 const (
 	RESOLVE_BENEATH       = 0x8
 	RESOLVE_IN_ROOT       = 0x10
@@ -3579,7 +3602,7 @@ const (
 	DEVLINK_ATTR_LINECARD_SUPPORTED_TYPES              = 0xae
 	DEVLINK_ATTR_NESTED_DEVLINK                        = 0xaf
 	DEVLINK_ATTR_SELFTESTS                             = 0xb0
-	DEVLINK_ATTR_MAX                                   = 0xb7
+	DEVLINK_ATTR_MAX                                   = 0xb9
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_NONE              = 0x0
 	DEVLINK_DPIPE_FIELD_MAPPING_TYPE_IFINDEX           = 0x1
 	DEVLINK_DPIPE_MATCH_TYPE_FIELD_EXACT               = 0x0
@@ -4101,7 +4124,7 @@ const (
 	ETHTOOL_A_COALESCE_RATE_SAMPLE_INTERVAL   = 0x17
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_TX        = 0x18
 	ETHTOOL_A_COALESCE_USE_CQE_MODE_RX        = 0x19
-	ETHTOOL_A_COALESCE_MAX                    = 0x1e
+	ETHTOOL_A_COALESCE_MAX                    = 0x20
 	ETHTOOL_A_PAUSE_UNSPEC                    = 0x0
 	ETHTOOL_A_PAUSE_HEADER                    = 0x1
 	ETHTOOL_A_PAUSE_AUTONEG                   = 0x2
@@ -4113,7 +4136,7 @@ const (
 	ETHTOOL_A_PAUSE_STAT_PAD                  = 0x1
 	ETHTOOL_A_PAUSE_STAT_TX_FRAMES            = 0x2
 	ETHTOOL_A_PAUSE_STAT_RX_FRAMES            = 0x3
-	ETHTOOL_A_PAUSE_STAT_MAX                  = 0x3
+	ETHTOOL_A_PAUSE_STAT_MAX                  = 0x4
 	ETHTOOL_A_EEE_UNSPEC                      = 0x0
 	ETHTOOL_A_EEE_HEADER                      = 0x1
 	ETHTOOL_A_EEE_MODES_OURS                  = 0x2
@@ -4537,9 +4560,12 @@ const (
 )
 
 type LandlockRulesetAttr struct {
-	Access_fs  uint64
-	Access_net uint64
-	Scoped     uint64
+	Handled_access_fs  uint64
+	Handled_access_net uint64
+	Scoped             uint64
+	Quiet_access_fs    uint64
+	Quiet_access_net   uint64
+	Quiet_scoped       uint64
 }
 
 type LandlockPathBeneathAttr struct {
@@ -4569,28 +4595,31 @@ const (
 	PIDFD_COREDUMP_USER        = 0x4
 	PIDFD_COREDUMP_ROOT        = 0x8
 	PIDFD_INFO_SIZE_VER0       = 0x40
-	PIDFD_GET_INFO             = 0xc048ff0b
+	PIDFD_GET_INFO             = 0xc058ff0b
 )
 
-const SizeofPidfdInfo = 0x48
+const SizeofPidfdInfo = 0x58
 
 type PidfdInfo struct {
-	Mask          uint64
-	Cgroupid      uint64
-	Pid           uint32
-	Tgid          uint32
-	Ppid          uint32
-	Ruid          uint32
-	Rgid          uint32
-	Euid          uint32
-	Egid          uint32
-	Suid          uint32
-	Sgid          uint32
-	Fsuid         uint32
-	Fsgid         uint32
-	Exit_code     int32
-	Coredump_mask uint32
-	_             uint32
+	Mask            uint64
+	Cgroupid        uint64
+	Pid             uint32
+	Tgid            uint32
+	Ppid            uint32
+	Ruid            uint32
+	Rgid            uint32
+	Euid            uint32
+	Egid            uint32
+	Suid            uint32
+	Sgid            uint32
+	Fsuid           uint32
+	Fsgid           uint32
+	Exit_code       int32
+	Coredump_mask   uint32
+	Coredump_signal uint32
+	Coredump_code   uint32
+	Coredump_pad    uint32
+	Supported_mask  uint64
 }
 
 const (
@@ -4932,7 +4961,7 @@ const (
 	NL80211_ATTR_MAC_HINT                                   = 0xc8
 	NL80211_ATTR_MAC_MASK                                   = 0xd7
 	NL80211_ATTR_MAX_AP_ASSOC_STA                           = 0xca
-	NL80211_ATTR_MAX                                        = 0x15c
+	NL80211_ATTR_MAX                                        = 0x16e
 	NL80211_ATTR_MAX_CRIT_PROT_DURATION                     = 0xb4
 	NL80211_ATTR_MAX_CSA_COUNTERS                           = 0xce
 	NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS                     = 0x143
@@ -5147,12 +5176,12 @@ const (
 	NL80211_ATTR_WOWLAN_TRIGGERS                            = 0x75
 	NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED                  = 0x76
 	NL80211_ATTR_WPA_VERSIONS                               = 0x4b
-	NL80211_AUTHTYPE_AUTOMATIC                              = 0x9
+	NL80211_AUTHTYPE_AUTOMATIC                              = 0xa
 	NL80211_AUTHTYPE_FILS_PK                                = 0x7
 	NL80211_AUTHTYPE_FILS_SK                                = 0x5
 	NL80211_AUTHTYPE_FILS_SK_PFS                            = 0x6
 	NL80211_AUTHTYPE_FT                                     = 0x2
-	NL80211_AUTHTYPE_MAX                                    = 0x8
+	NL80211_AUTHTYPE_MAX                                    = 0x9
 	NL80211_AUTHTYPE_NETWORK_EAP                            = 0x3
 	NL80211_AUTHTYPE_OPEN_SYSTEM                            = 0x0
 	NL80211_AUTHTYPE_SAE                                    = 0x4
@@ -5320,7 +5349,7 @@ const (
 	NL80211_CMD_LEAVE_MESH                                  = 0x45
 	NL80211_CMD_LEAVE_OCB                                   = 0x6d
 	NL80211_CMD_LINKS_REMOVED                               = 0x9a
-	NL80211_CMD_MAX                                         = 0x9f
+	NL80211_CMD_MAX                                         = 0xa7
 	NL80211_CMD_MICHAEL_MIC_FAILURE                         = 0x29
 	NL80211_CMD_MODIFY_LINK_STA                             = 0x97
 	NL80211_CMD_NAN_MATCH                                   = 0x78
@@ -5566,7 +5595,7 @@ const (
 	NL80211_FREQUENCY_ATTR_GO_CONCURRENT                    = 0xf
 	NL80211_FREQUENCY_ATTR_INDOOR_ONLY                      = 0xe
 	NL80211_FREQUENCY_ATTR_IR_CONCURRENT                    = 0xf
-	NL80211_FREQUENCY_ATTR_MAX                              = 0x27
+	NL80211_FREQUENCY_ATTR_MAX                              = 0x29
 	NL80211_FREQUENCY_ATTR_MAX_TX_POWER                     = 0x6
 	NL80211_FREQUENCY_ATTR_NO_10MHZ                         = 0x11
 	NL80211_FREQUENCY_ATTR_NO_160MHZ                        = 0xc
@@ -5639,7 +5668,7 @@ const (
 	NL80211_IFTYPE_AKM_ATTR_SUITES                          = 0x2
 	NL80211_IFTYPE_AP                                       = 0x3
 	NL80211_IFTYPE_AP_VLAN                                  = 0x4
-	NL80211_IFTYPE_MAX                                      = 0xc
+	NL80211_IFTYPE_MAX                                      = 0xe
 	NL80211_IFTYPE_MESH_POINT                               = 0x7
 	NL80211_IFTYPE_MONITOR                                  = 0x6
 	NL80211_IFTYPE_NAN                                      = 0xc
@@ -5664,7 +5693,7 @@ const (
 	NL80211_KEY_DEFAULT_TYPES                               = 0x8
 	NL80211_KEY_DEFAULT_TYPE_UNICAST                        = 0x1
 	NL80211_KEY_IDX                                         = 0x2
-	NL80211_KEY_MAX                                         = 0xa
+	NL80211_KEY_MAX                                         = 0xb
 	NL80211_KEY_MODE                                        = 0x9
 	NL80211_KEY_NO_TX                                       = 0x1
 	NL80211_KEY_RX_TX                                       = 0x0
@@ -5822,7 +5851,7 @@ const (
 	NL80211_PMKSA_CANDIDATE_BSSID                           = 0x2
 	NL80211_PMKSA_CANDIDATE_INDEX                           = 0x1
 	NL80211_PMKSA_CANDIDATE_PREAUTH                         = 0x3
-	NL80211_PMSR_ATTR_MAX                                   = 0x5
+	NL80211_PMSR_ATTR_MAX                                   = 0x7
 	NL80211_PMSR_ATTR_MAX_PEERS                             = 0x1
 	NL80211_PMSR_ATTR_PEERS                                 = 0x5
 	NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR                    = 0x3
@@ -5831,7 +5860,7 @@ const (
 	NL80211_PMSR_FTM_CAPA_ATTR_ASAP                         = 0x1
 	NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS                   = 0x6
 	NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT          = 0x7
-	NL80211_PMSR_FTM_CAPA_ATTR_MAX                          = 0x12
+	NL80211_PMSR_FTM_CAPA_ATTR_MAX                          = 0x1f
 	NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST           = 0x8
 	NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP                     = 0x2
 	NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED            = 0xa
@@ -5853,7 +5882,7 @@ const (
 	NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD                  = 0x4
 	NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST                = 0x6
 	NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK                  = 0xc
-	NL80211_PMSR_FTM_REQ_ATTR_MAX                           = 0xe
+	NL80211_PMSR_FTM_REQ_ATTR_MAX                           = 0x17
 	NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED             = 0xb
 	NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP                = 0x3
 	NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES              = 0x7
@@ -5871,7 +5900,7 @@ const (
 	NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON                  = 0x1
 	NL80211_PMSR_FTM_RESP_ATTR_FTMS_PER_BURST               = 0x8
 	NL80211_PMSR_FTM_RESP_ATTR_LCI                          = 0x13
-	NL80211_PMSR_FTM_RESP_ATTR_MAX                          = 0x16
+	NL80211_PMSR_FTM_RESP_ATTR_MAX                          = 0x21
 	NL80211_PMSR_FTM_RESP_ATTR_NUM_BURSTS_EXP               = 0x6
 	NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_ATTEMPTS            = 0x3
 	NL80211_PMSR_FTM_RESP_ATTR_NUM_FTMR_SUCCESSES           = 0x4
@@ -5885,7 +5914,7 @@ const (
 	NL80211_PMSR_FTM_RESP_ATTR_TX_RATE                      = 0xb
 	NL80211_PMSR_PEER_ATTR_ADDR                             = 0x1
 	NL80211_PMSR_PEER_ATTR_CHAN                             = 0x2
-	NL80211_PMSR_PEER_ATTR_MAX                              = 0x4
+	NL80211_PMSR_PEER_ATTR_MAX                              = 0x5
 	NL80211_PMSR_PEER_ATTR_REQ                              = 0x3
 	NL80211_PMSR_PEER_ATTR_RESP                             = 0x4
 	NL80211_PMSR_REQ_ATTR_DATA                              = 0x1
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
index 38658a34..c7ec66dc 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
@@ -163,6 +163,11 @@ type Msghdr struct {
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -178,6 +183,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
index 267ffe05..abe072e8 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
@@ -166,6 +166,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -181,6 +187,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
index ec459d5f..4ba7cea0 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
@@ -169,6 +169,11 @@ type Msghdr struct {
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -184,6 +189,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
index fa45ab7d..3f55ca4a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
@@ -167,6 +167,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go
index 3da72ccd..445b2a2e 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go
@@ -167,6 +167,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
index 78f8c6d5..6a52e254 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
@@ -168,6 +168,11 @@ type Msghdr struct {
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -183,6 +188,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
index bbd4c6c2..fafd89de 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
@@ -167,6 +167,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
index 644d31d6..5fb6f4cf 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
@@ -167,6 +167,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
index a976f626..a50187bc 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
@@ -168,6 +168,11 @@ type Msghdr struct {
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -183,6 +188,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
index 46324695..777b0228 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
@@ -169,6 +169,11 @@ type Msghdr struct {
 	Flags      int32
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+}
+
 type Cmsghdr struct {
 	Len   uint32
 	Level int32
@@ -184,6 +189,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x58
 	SizeofIovec           = 0x8
 	SizeofMsghdr          = 0x1c
+	SizeofMmsghdr         = 0x20
 	SizeofCmsghdr         = 0xc
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
index cbc30397..48a6a5ac 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
@@ -168,6 +168,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -183,6 +189,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
index b47f7b49..1972c012 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
@@ -168,6 +168,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -183,6 +189,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index cb16add5..87572ee0 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -167,6 +167,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -182,6 +188,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
index a57ab8fa..f6a33e68 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
@@ -166,6 +166,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -181,6 +187,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
index bf99635d..8b726145 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
@@ -84,22 +84,20 @@ type Rusage struct {
 
 type Stat_t struct {
 	Dev     uint64
-	_       uint16
 	Ino     uint64
+	Nlink   uint64
 	Mode    uint32
-	Nlink   uint32
 	Uid     uint32
 	Gid     uint32
+	_       uint32
 	Rdev    uint64
-	_       uint16
 	Size    int64
 	Blksize int64
 	Blocks  int64
 	Atim    Timespec
 	Mtim    Timespec
 	Ctim    Timespec
-	_       uint64
-	_       uint64
+	_       [3]int64
 }
 
 type Dirent struct {
@@ -170,6 +168,12 @@ type Msghdr struct {
 	_          [4]byte
 }
 
+type Mmsghdr struct {
+	Hdr Msghdr
+	Len uint32
+	_   [4]byte
+}
+
 type Cmsghdr struct {
 	Len   uint64
 	Level int32
@@ -185,6 +189,7 @@ const (
 	SizeofSockaddrNFCLLCP = 0x60
 	SizeofIovec           = 0x10
 	SizeofMsghdr          = 0x38
+	SizeofMmsghdr         = 0x40
 	SizeofCmsghdr         = 0x10
 )
 
diff --git a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
index 2e5d5a44..80d4c953 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_zos_s390x.go
@@ -209,6 +209,84 @@ type TCPInfo struct {
 	Total_retrans  uint32
 }
 
+// Ptrace structures for z/OS
+
+type PtraceRegs struct {
+	Psw                      PtracePsw
+	Gprs                     [16]uint64
+	Acrs                     [16]uint32
+	Orig_gpr2                uint64
+	Fp_regs                  PtraceFpregs
+	Per_info                 PtracePer
+	Ieee_instruction_pointer uint64
+}
+
+type PtracePsw struct {
+	Mask uint64
+	Addr uint64
+}
+
+type PtraceFpregs struct {
+	Fpc  uint32
+	Fprs [16]float64
+}
+
+type PtracePer struct {
+	Control_regs  [3]uint64
+	_             [8]byte
+	Starting_addr uint64
+	Ending_addr   uint64
+	Perc_atmid    uint16
+	Address       uint64
+	Access_id     uint8
+	_             [7]byte
+}
+
+// PT_BLOCKREQ structures for block ptrace requests
+// Layout matches BPXYPTRC HLASM macro (PtBR_GPR + PtBR_GPR_EXT):
+//
+//	Offset 0-1:    Writebitflags (PtBR_GPR_CntlGPR, 2 bytes)
+//	Offset 2-3:    Wpsw (PtBR_GPR_CntlMisc, 2 bytes with WPSW bit flag)
+//	Offset 4-15:   Reserved (12 bytes)
+//	Offset 16-79:  Gpr (64 bytes, 16 GPRs)
+//	Offset 80-143: Ctl (64 bytes, 16 CRs)
+//	Offset 144-151: Psw old format (8 bytes, PtBR_GPR_PSW)
+//	Offset 152-167: Pswg extended (16 bytes, PtBR_GPR_PSWG for 64-bit)
+//	Total: 168 bytes (base 152 + extended 16)
+type PtraceBlkGpr struct {
+	Writebitflags uint16     // 2 bytes at offset 0 (PtBR_GPR_CntlGPR)
+	Wpsw          uint16     // 2 bytes at offset 2 (PtBR_GPR_CntlMisc with WPSW flag)
+	_             [12]byte   // 12 bytes reserved (offset 4-15)
+	Gpr           [16]uint32 // 64 bytes at offset 16 (GPRs)
+	Ctl           [16]uint32 // 64 bytes at offset 80 (CRs)
+	Psw           [8]byte    // 8 bytes at offset 144 (old PSW format)
+	Pswg          [16]byte   // 16 bytes at offset 152 (extended PSWG)
+	// Total: 2+2+12+64+64+8+16 = 168 bytes
+}
+
+type PtraceBlkReqReq struct {
+	Reqtype int32
+	Reqstat int32
+	Reqdata uint32
+	_       [4]byte
+}
+
+type PtraceBlkReq struct {
+	Numreq int32
+	_      [12]byte
+}
+
+// PT_READ_U structures for reading user area (control info)
+type PtraceBlkUarOcw struct {
+	Ofs uint32 // Control information offset
+	Ctl uint32 // Control information
+}
+
+type PtraceBlkUar struct {
+	Num uint32 // Number of entries
+	_   [4]byte
+}
+
 type _Gid_t uint32
 
 type rusage_zos struct {
diff --git a/vendor/golang.org/x/sys/windows/types_windows_arm.go b/vendor/golang.org/x/sys/windows/types_windows_arm.go
deleted file mode 100644
index 321872c3..00000000
--- a/vendor/golang.org/x/sys/windows/types_windows_arm.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2018 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 windows
-
-type WSAData struct {
-	Version      uint16
-	HighVersion  uint16
-	Description  [WSADESCRIPTION_LEN + 1]byte
-	SystemStatus [WSASYS_STATUS_LEN + 1]byte
-	MaxSockets   uint16
-	MaxUdpDg     uint16
-	VendorInfo   *byte
-}
-
-type Servent struct {
-	Name    *byte
-	Aliases **byte
-	Port    uint16
-	Proto   *byte
-}
-
-type JOBOBJECT_BASIC_LIMIT_INFORMATION struct {
-	PerProcessUserTimeLimit int64
-	PerJobUserTimeLimit     int64
-	LimitFlags              uint32
-	MinimumWorkingSetSize   uintptr
-	MaximumWorkingSetSize   uintptr
-	ActiveProcessLimit      uint32
-	Affinity                uintptr
-	PriorityClass           uint32
-	SchedulingClass         uint32
-	_                       uint32 // pad to 8 byte boundary
-}
diff --git a/vendor/golang.org/x/text/secure/bidirule/bidirule.go b/vendor/golang.org/x/text/secure/bidirule/bidirule.go
index 53863273..399cb896 100644
--- a/vendor/golang.org/x/text/secure/bidirule/bidirule.go
+++ b/vendor/golang.org/x/text/secure/bidirule/bidirule.go
@@ -10,6 +10,7 @@ package bidirule
 
 import (
 	"errors"
+	"sync"
 	"unicode/utf8"
 
 	"golang.org/x/text/transform"
@@ -246,8 +247,9 @@ func (t *Transformer) Span(src []byte, atEOF bool) (n int, err error) {
 // Precomputing the ASCII values decreases running time for the ASCII fast path
 // by about 30%.
 var asciiTable [128]bidi.Properties
+var asciiTableOnce sync.Once
 
-func init() {
+func initASCIITable() {
 	for i := range asciiTable {
 		p, _ := bidi.LookupRune(rune(i))
 		asciiTable[i] = p
@@ -255,6 +257,8 @@ func init() {
 }
 
 func (t *Transformer) advance(s []byte) (n int, ok bool) {
+	asciiTableOnce.Do(initASCIITable)
+
 	var e bidi.Properties
 	var sz int
 	for n < len(s) {
@@ -297,6 +301,8 @@ func (t *Transformer) advance(s []byte) (n int, ok bool) {
 }
 
 func (t *Transformer) advanceString(s string) (n int, ok bool) {
+	asciiTableOnce.Do(initASCIITable)
+
 	var e bidi.Properties
 	var sz int
 	for n < len(s) {
diff --git a/vendor/golang.org/x/text/unicode/bidi/core.go b/vendor/golang.org/x/text/unicode/bidi/core.go
index e28ac8c8..fe5a46ff 100644
--- a/vendor/golang.org/x/text/unicode/bidi/core.go
+++ b/vendor/golang.org/x/text/unicode/bidi/core.go
@@ -208,27 +208,23 @@ func (p *paragraph) determineMatchingIsolates() {
 		p.matchingIsolateInitiator[i] = -1
 	}
 
+	var open []int
 	for i := range p.matchingPDI {
 		p.matchingPDI[i] = -1
 
-		if t := p.resultTypes[i]; t.in(LRI, RLI, FSI) {
-			depthCounter := 1
-			for j := i + 1; j < p.Len(); j++ {
-				if u := p.resultTypes[j]; u.in(LRI, RLI, FSI) {
-					depthCounter++
-				} else if u == PDI {
-					if depthCounter--; depthCounter == 0 {
-						p.matchingPDI[i] = j
-						p.matchingIsolateInitiator[j] = i
-						break
-					}
-				}
-			}
-			if p.matchingPDI[i] == -1 {
-				p.matchingPDI[i] = p.Len()
-			}
+		switch t := p.resultTypes[i]; {
+		case t.in(LRI, RLI, FSI):
+			open = append(open, i)
+		case t == PDI && len(open) > 0:
+			j := open[len(open)-1]
+			open = open[:len(open)-1]
+			p.matchingPDI[j] = i
+			p.matchingIsolateInitiator[i] = j
 		}
 	}
+	for _, i := range open {
+		p.matchingPDI[i] = p.Len()
+	}
 }
 
 // determineParagraphEmbeddingLevel reports the resolved paragraph direction of
@@ -496,16 +492,13 @@ func (s *isolatingRunSequence) resolveWeakTypes() {
 
 	// Rule W2.
 	// EN does not change at the start of the run, because sos != AL.
+	lastStrong := unknownClass
 	for i, t := range s.types {
-		if t == EN {
-			for j := i - 1; j >= 0; j-- {
-				if t := s.types[j]; t.in(L, R, AL) {
-					if t == AL {
-						s.types[i] = AN
-					}
-					break
-				}
-			}
+		switch {
+		case t.in(L, R, AL):
+			lastStrong = t
+		case t == EN && lastStrong == AL:
+			s.types[i] = AN
 		}
 	}
 
@@ -543,29 +536,30 @@ func (s *isolatingRunSequence) resolveWeakTypes() {
 	}
 
 	// Rule W5.
-	for i, t := range s.types {
-		if t == ET {
-			// locate end of sequence
-			runStart := i
-			runEnd := s.findRunLimit(runStart, ET)
-
-			// check values at ends of sequence
-			t := s.sos
-			if runStart > 0 {
-				t = s.types[runStart-1]
-			}
-			if t != EN {
-				t = s.eos
-				if runEnd < len(s.types) {
-					t = s.types[runEnd]
-				}
-			}
-			if t == EN {
-				setTypes(s.types[runStart:runEnd], EN)
+	for i := 0; i < len(s.types); i++ {
+		if s.types[i] != ET {
+			continue
+		}
+		// locate end of sequence
+		runStart := i
+		runEnd := s.findRunLimit(runStart, ET)
+
+		// check values at ends of sequence
+		t := s.sos
+		if runStart > 0 {
+			t = s.types[runStart-1]
+		}
+		if t != EN {
+			t = s.eos
+			if runEnd < len(s.types) {
+				t = s.types[runEnd]
 			}
-			// continue at end of sequence
-			i = runEnd
 		}
+		if t == EN {
+			setTypes(s.types[runStart:runEnd], EN)
+		}
+		// continue at end of sequence
+		i = runEnd
 	}
 
 	// Rule W6.
@@ -576,20 +570,13 @@ func (s *isolatingRunSequence) resolveWeakTypes() {
 	}
 
 	// Rule W7.
+	prevStrongType := s.sos
 	for i, t := range s.types {
-		if t == EN {
-			// set default if we reach start of run
-			prevStrongType := s.sos
-			for j := i - 1; j >= 0; j-- {
-				t = s.types[j]
-				if t == L || t == R { // AL's have been changed to R
-					prevStrongType = t
-					break
-				}
-			}
-			if prevStrongType == L {
-				s.types[i] = L
-			}
+		switch {
+		case t == L || t == R: // AL's have been changed to R
+			prevStrongType = t
+		case t == EN && prevStrongType == L:
+			s.types[i] = L
 		}
 	}
 }
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
index 7b90bc92..5b0e3b47 100644
--- a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
@@ -2,63 +2,44 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package gcexportdata provides functions for reading and writing
-// export data, which is a serialized description of the API of a Go
-// package including the names, kinds, types, and locations of all
-// exported declarations.
-//
-// The standard Go compiler (cmd/compile) writes an export data file
-// for each package it compiles, which it later reads when compiling
-// packages that import the earlier one. The compiler must thus
-// contain logic to both write and read export data.
-// (See the "Export" section in the cmd/compile/README file.)
-//
-// The [Read] function in this package can read files produced by the
-// compiler, producing [go/types] data structures. As a matter of
-// policy, Read supports export data files produced by only the last
-// two Go releases plus tip; see https://go.dev/issue/68898. The
-// export data files produced by the compiler contain additional
-// details related to generics, inlining, and other optimizations that
-// cannot be decoded by the [Read] function.
-//
-// In files written by the compiler, the export data is not at the
-// start of the file. Before calling Read, use [NewReader] to locate
-// the desired portion of the file.
-//
-// The [Write] function in this package encodes the exported API of a
-// Go package ([types.Package]) as a file. Such files can be later
-// decoded by Read, but cannot be consumed by the compiler.
-//
-// # Future changes
-//
-// Although Read supports the formats written by both Write and the
-// compiler, the two are quite different, and there is an open
-// proposal (https://go.dev/issue/69491) to separate these APIs.
-//
-// Under that proposal, this package would ultimately provide only the
-// Read operation for compiler export data, which must be defined in
-// this module (golang.org/x/tools), not in the standard library, to
-// avoid version skew for developer tools that need to read compiler
-// export data both before and after a Go release, such as from Go
-// 1.23 to Go 1.24. Because this package lives in the tools module,
-// clients can update their version of the module some time before the
-// Go 1.24 release and rebuild and redeploy their tools, which will
-// then be able to consume both Go 1.23 and Go 1.24 export data files,
-// so they will work before and after the Go update. (See discussion
-// at https://go.dev/issue/15651.)
-//
-// The operations to import and export [go/types] data structures
-// would be defined in the go/types package as Import and Export.
-// [Write] would (eventually) delegate to Export,
-// and [Read], when it detects a file produced by Export,
-// would delegate to Import.
+// Package gcexportdata provides functions for writing and reading
+// export data, a serialized representation of a [types.Package].
+// It describes the API of a Go package, including the names,
+// kinds, types, and locations of all exported declarations.
+//
+// Files may be written and read using the [Write] and [Read]
+// functions.
+// Alternatively, files may be produced by the "go list -export" command.
+// This command runs the type checker on each specified Go package and
+// writes export data for each package into a file named by the Export
+// field of go list's -json output.
+// The [Read] function may then be used to read those files.
+//
+// The export data format evolves with each Go release. As a matter of
+// policy, [Read] supports reading files produced by only the last two
+// Go releases plus tip; see https://go.dev/issue/68898.
+//
+// The name of this package reflects its origins at a time when
+// cmd/compile was named gc, and [Read] parsed export data
+// from .a archives produced by the Go compiler.
+// However, starting with go1.28, the format of the files
+// produced by "go list -export" will diverge from the format
+// used by the standard Go compiler.
+// Consequently, this package will eventually stop being
+// capable of reading those files.
+// In the meantime, when using [Read] on a .a file written by the
+// compiler, be aware that export data is not at the start of the file.
+// Before calling Read, one must use [NewReader] to locate the export
+// data section of the file.
+// For more information on the compiler's export data, see the
+// "Export" section in the GOROOT/src/cmd/compile/README file.
 //
 // # Deprecations
 //
-// The [NewImporter] and [Find] functions are deprecated and should
-// not be used in new code. The [WriteBundle] and [ReadBundle]
-// functions are experimental, and there is an open proposal to
-// deprecate them (https://go.dev/issue/69573).
+// The [NewImporter], [Find], and [NewReader] functions are deprecated
+// and should not be used in new code.
+// The [WriteBundle] and [ReadBundle] functions are experimental, and
+// there is an open proposal to deprecate them (https://go.dev/issue/69573).
 package gcexportdata
 
 import (
@@ -101,11 +82,30 @@ func Find(importPath, srcDir string) (filename, path string) {
 	return data.Export, data.ImportPath
 }
 
-// NewReader returns a reader for the export data section of an object
-// (.o) or archive (.a) file read from r.  The new reader may provide
-// additional trailing data beyond the end of the export data.
+// NewReader returns a reader for export data read from r. Export data
+// may be read from:
+//
+//   - The export data section of an object (.o) or archive file (.a).
+//     In this case, the new reader may provide additional trailing data
+//     beyond the end of the export data.
+//   - The output of the cmd/export tool (e.g. via "go list -export").
+//     In this case, the new reader contains no trailing data.
+//
+// Deprecated: This package will stop supporting the reading of export
+// data from compiler-produced archive files in Go 1.29. To read
+// cmd/export files, use [Read] directly instead.
 func NewReader(r io.Reader) (io.Reader, error) {
 	buf := bufio.NewReader(r)
+	peek, err := buf.Peek(1)
+	if err != nil {
+		return nil, err
+	}
+	if peek[0] == 'i' {
+		// We were given an output of cmd/export. The entire file is
+		// export data.
+		return buf, nil
+	}
+
 	size, err := gcimporter.FindExportData(buf)
 	if err != nil {
 		return nil, err
@@ -176,16 +176,7 @@ func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package,
 		case 'i':
 			// indexed, produced by cmd/compile till go1.19,
 			// and also by [Write].
-			//
-			// If proposal #69491 is accepted, go/types
-			// serialization will be implemented by
-			// types.Export, to which Write would eventually
-			// delegate (explicitly dropping any pretence at
-			// inter-version Write-Read compatibility).
-			// This [Read] function would delegate to types.Import
-			// when it detects that the file was produced by Export.
-			_, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
-			return pkg, err
+			return gcimporter.IImportData(fset, imports, data[1:], path)
 
 		case 'u':
 			// unified, produced by cmd/compile since go1.20
diff --git a/vendor/golang.org/x/tools/go/packages/golist.go b/vendor/golang.org/x/tools/go/packages/golist.go
index 8e60cbbe..8f66c355 100644
--- a/vendor/golang.org/x/tools/go/packages/golist.go
+++ b/vendor/golang.org/x/tools/go/packages/golist.go
@@ -317,10 +317,17 @@ func (state *golistState) adhocPackage(pattern, query string) (*DriverResponse,
 	if err != nil {
 		return nil, err
 	}
-	// If we get nothing back from `go list`,
-	// try to make this file into its own ad-hoc package.
-	// TODO(rstambler): Should this check against the original response?
-	if len(response.Packages) == 0 {
+	// Only .go files can form ad-hoc packages (command-line-arguments);
+	// non-Go files cannot be compiled as Go packages (golang.org/issue/54815).
+	if filepath.Ext(query) != ".go" {
+		return response, nil
+	}
+
+	switch len(response.Packages) {
+	case 0:
+		// If we get nothing back from `go list`,
+		// try to make this file into its own ad-hoc package.
+		// TODO(rstambler): Should this check against the original response?
 		response.Packages = append(response.Packages, &Package{
 			ID:              "command-line-arguments",
 			PkgPath:         query,
@@ -329,22 +336,23 @@ func (state *golistState) adhocPackage(pattern, query string) (*DriverResponse,
 			Imports:         make(map[string]*Package),
 		})
 		response.Roots = append(response.Roots, "command-line-arguments")
-	}
-	// Handle special cases.
-	if len(response.Packages) == 1 {
+
+	case 1:
+		// Handle special cases.
 		// golang/go#33482: If this is a file= query for ad-hoc packages where
 		// the file only exists on an overlay, and exists outside of a module,
 		// add the file to the package and remove the errors.
-		if response.Packages[0].ID == "command-line-arguments" ||
-			filepath.ToSlash(response.Packages[0].PkgPath) == filepath.ToSlash(query) {
-			if len(response.Packages[0].GoFiles) == 0 {
+		pkg := response.Packages[0]
+		if pkg.ID == "command-line-arguments" ||
+			filepath.ToSlash(pkg.PkgPath) == filepath.ToSlash(query) {
+			if len(pkg.GoFiles) == 0 {
 				filename := filepath.Join(pattern, filepath.Base(query)) // avoid recomputing abspath
 				// TODO(matloob): check if the file is outside of a root dir?
 				for path := range state.cfg.Overlay {
 					if path == filename {
-						response.Packages[0].Errors = nil
-						response.Packages[0].GoFiles = []string{path}
-						response.Packages[0].CompiledGoFiles = []string{path}
+						pkg.Errors = nil
+						pkg.GoFiles = []string{path}
+						pkg.CompiledGoFiles = []string{path}
 					}
 				}
 			}
@@ -683,9 +691,14 @@ func (state *golistState) createDriverResponse(words ...string) (*DriverResponse
 
 		if p.Error != nil {
 			msg := strings.TrimSpace(p.Error.Err) // Trim to work around golang.org/issue/32363.
-			// Address golang.org/issue/35964 by appending import stack to error message.
-			if msg == "import cycle not allowed" && len(p.Error.ImportStack) != 0 {
-				msg += fmt.Sprintf(": import stack: %v", p.Error.ImportStack)
+			// Address golang.org/issue/35964 and golang.org/issue/38826 by appending import stack to error message.
+			// Address golang/go#38826 by removing " (test)"
+			if (msg == "import cycle not allowed" || msg == "import cycle not allowed in test") && len(p.Error.ImportStack) != 0 {
+				stack := make([]string, len(p.Error.ImportStack))
+				for i, s := range p.Error.ImportStack {
+					stack[i] = strings.TrimSuffix(s, " (test)")
+				}
+				msg += fmt.Sprintf(": import stack: %v", stack)
 			}
 			pkg.Errors = append(pkg.Errors, Error{
 				Pos:  p.Error.Pos,
@@ -752,29 +765,27 @@ func (state *golistState) getPkgPath(dir string) (string, bool, error) {
 		return "", false, err
 	}
 
+	// A directory can be contained in multiple roots, for example when a
+	// replaced module is nested inside the main module. Choose the most
+	// specific root, breaking ties lexically for deterministic behavior.
+	var bestRoot, bestPath, bestRel string
 	for rdir, rpath := range roots {
-		// Make sure that the directory is in the module,
-		// to avoid creating a path relative to another module.
-		if !strings.HasPrefix(dir, rdir) {
-			continue
-		}
 		// TODO(matloob): This doesn't properly handle symlinks.
 		r, err := filepath.Rel(rdir, dir)
-		if err != nil {
+		if err != nil || !filepath.IsLocal(r) {
 			continue
 		}
-		if rpath != "" {
-			// We choose only one root even though the directory even it can belong in multiple modules
-			// or GOPATH entries. This is okay because we only need to work with absolute dirs when a
-			// file is missing from disk, for instance when gopls calls go/packages in an overlay.
-			// Once the file is saved, gopls, or the next invocation of the tool will get the correct
-			// result straight from golist.
-			// TODO(matloob): Implement module tiebreaking?
-			return path.Join(rpath, filepath.ToSlash(r)), true, nil
+		if bestRoot == "" || len(rdir) > len(bestRoot) || len(rdir) == len(bestRoot) && rdir < bestRoot {
+			bestRoot, bestPath, bestRel = rdir, rpath, r
 		}
-		return filepath.ToSlash(r), true, nil
 	}
-	return "", false, nil
+	if bestRoot == "" {
+		return "", false, nil
+	}
+	if bestPath != "" {
+		return path.Join(bestPath, filepath.ToSlash(bestRel)), true, nil
+	}
+	return filepath.ToSlash(bestRel), true, nil
 }
 
 // absJoin absolutizes and flattens the lists of files.
@@ -996,9 +1007,12 @@ func (state *golistState) invokeGo(verb string, args ...string) (*bytes.Buffer,
 			return bytes.NewBufferString(output), nil
 		}
 
-		// Workaround for #29280: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
+		// Workaround for #29280 and #31344: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
 		// Note that the error message we look for in this case is different that the one looked for above.
-		if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no such file or directory") {
+		// "no such file or directory" is emitted on Unix,
+		if len(stderr.String()) > 0 && (strings.Contains(stderr.String(), "no such file or directory") || // Unix
+			strings.Contains(stderr.String(), "The system cannot find the file specified") || // Windows ERROR_FILE_NOT_FOUND
+			strings.Contains(stderr.String(), "The system cannot find the path specified")) { // Windows ERROR_PATH_NOT_FOUND
 			output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
 				strings.Trim(stderr.String(), "\n"))
 			return bytes.NewBufferString(output), nil
diff --git a/vendor/golang.org/x/tools/go/packages/golist_overlay.go b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
index d9d5a45c..8bd0f7fa 100644
--- a/vendor/golang.org/x/tools/go/packages/golist_overlay.go
+++ b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
@@ -31,8 +31,8 @@ func (state *golistState) determineRootDirs() (map[string]string, error) {
 }
 
 func (state *golistState) determineRootDirsModules() (map[string]string, error) {
-	// List all of the modules--the first will be the directory for the main
-	// module. Any replaced modules will also need to be treated as roots.
+	// List all of the modules. Main modules and replaced modules need to be
+	// treated as roots.
 	// Editing files in the module cache isn't a great idea, so we don't
 	// plan to ever support that.
 	out, err := state.invokeGo("list", "-m", "-json", "all")
@@ -46,8 +46,6 @@ func (state *golistState) determineRootDirsModules() (map[string]string, error)
 		}
 	}
 	roots := map[string]string{}
-	modules := map[string]string{}
-	var i int
 	for dec := json.NewDecoder(out); dec.More(); {
 		mod := new(gocommand.ModuleJSON)
 		if err := dec.Decode(mod); err != nil {
@@ -59,13 +57,10 @@ func (state *golistState) determineRootDirsModules() (map[string]string, error)
 			if err != nil {
 				return nil, err
 			}
-			modules[absDir] = mod.Path
-			// The first result is the main module.
-			if i == 0 || mod.Replace != nil && mod.Replace.Path != "" {
+			if mod.Main || mod.Replace != nil && mod.Replace.Path != "" {
 				roots[absDir] = mod.Path
 			}
 		}
-		i++
 	}
 	return roots, nil
 }
diff --git a/vendor/golang.org/x/tools/go/packages/packages.go b/vendor/golang.org/x/tools/go/packages/packages.go
index 1e5549ab..5dadc1b0 100644
--- a/vendor/golang.org/x/tools/go/packages/packages.go
+++ b/vendor/golang.org/x/tools/go/packages/packages.go
@@ -1508,7 +1508,7 @@ func (ld *loader) loadFromExportData(lpkg *loaderPackage) error {
 	}
 	defer f.Close()
 
-	// Read gc export data.
+	// Read gc or cmd/export export data.
 	//
 	// We don't currently support gccgo export data because all
 	// underlying workspaces use the gc toolchain. (Even build
diff --git a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
index 9c7401c9..91add849 100644
--- a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
+++ b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
@@ -31,8 +31,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
-
-	"golang.org/x/tools/internal/typesinternal"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // TODO(adonovan): think about generic aliases.
@@ -692,8 +691,13 @@ func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
 		return "", false
 	}
 
-	_, named := typesinternal.ReceiverNamed(meth.Signature().Recv())
-	if named == nil {
+	// Avoid dependency on typesinternal.RecvBase here.
+	t := meth.Signature().Recv().Type()
+	if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+		t = ptr.Elem()
+	}
+	named, ok := types.Unalias(t).(*types.Named)
+	if !ok {
 		return "", false
 	}
 
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases.go b/vendor/golang.org/x/tools/internal/aliases/aliases.go
deleted file mode 100644
index a4ae04bc..00000000
--- a/vendor/golang.org/x/tools/internal/aliases/aliases.go
+++ /dev/null
@@ -1,18 +0,0 @@
-// 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 aliases
-
-import (
-	"go/token"
-	"go/types"
-)
-
-// New creates a new TypeName in Package pkg that
-// is an alias for the type rhs.
-func New(pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
-	tname := types.NewTypeName(pos, pkg, name, nil)
-	types.NewAlias(tname, rhs).SetTypeParams(tparams)
-	return tname
-}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
index 555ef626..3fca56c0 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
@@ -12,6 +12,7 @@ import (
 	"go/token"
 	"go/types"
 	"sync"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 func errorf(format string, args ...any) {
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go b/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
index 5662a311..885369d4 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
@@ -19,6 +19,7 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // FindExportData positions the reader r at the beginning of the
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
index 3dbd21d1..8c56f5d9 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
@@ -28,6 +28,7 @@ import (
 	"go/types"
 	"io"
 	"os"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 const (
@@ -95,6 +96,19 @@ func Import(fset *token.FileSet, packages map[string]*types.Package, path, srcDi
 	defer rc.Close()
 
 	buf := bufio.NewReader(rc)
+	peek, err := buf.Peek(1)
+	if err != nil {
+		return
+	}
+	if peek[0] == 'i' {
+		var data []byte // avoid redeclaring err
+		data, err = io.ReadAll(buf)
+		if err != nil {
+			return
+		}
+		pkg, err = IImportData(fset, packages, data[1:], path)
+		return
+	}
 	data, err := ReadUnified(buf)
 	if err != nil {
 		err = fmt.Errorf("import %q: %v", path, err)
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
index 686f171d..6bee3c41 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
@@ -242,6 +242,7 @@ import (
 	"strings"
 
 	"golang.org/x/tools/go/types/objectpath"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // IExportShallow encodes "shallow" export data for the specified package.
@@ -712,7 +713,7 @@ func (p *iexporter) doDecl(obj types.Object) {
 		w.typ(obj.Type(), obj.Pkg())
 
 	case *types.Func:
-		sig, _ := obj.Type().(*types.Signature)
+		sig := obj.Type().(*types.Signature)
 		if sig.Recv() != nil {
 			// We shouldn't see methods in the package scope,
 			// but the type checker may repair "func () F() {}"
@@ -745,7 +746,7 @@ func (p *iexporter) doDecl(obj types.Object) {
 	case *types.Const:
 		w.tag(constTag)
 		w.pos(obj.Pos())
-		w.value(obj.Type(), obj.Val())
+		w.value(obj.Type(), obj.Val(), obj.Pkg())
 
 	case *types.TypeName:
 		t := obj.Type()
@@ -822,7 +823,7 @@ func (p *iexporter) doDecl(obj types.Object) {
 			m := named.Method(i)
 			w.pos(m.Pos())
 			w.string(m.Name())
-			sig, _ := m.Type().(*types.Signature)
+			sig := m.Type().(*types.Signature)
 			if w.p.version >= iexportVersionGenericMethods && w.bool(sig.TypeParams().Len() > 0) {
 				w.tparamList(obj.Name()+"."+m.Name(), sig.TypeParams(), obj.Pkg())
 			}
@@ -970,9 +971,11 @@ func (w *exportWriter) qualifiedType(obj *types.TypeName) {
 // typ emits the specified type.
 //
 // Objects within the type (struct fields and interface methods) are
-// qualified by pkg. It may be nil if the type cannot contain objects,
-// such as the type of a constant.
+// qualified by pkg.
 func (w *exportWriter) typ(t types.Type, pkg *types.Package) {
+	if pkg == nil {
+		pkg = w.p.localpkg
+	}
 	w.data.uint64(w.p.typOff(t, pkg))
 }
 
@@ -1148,7 +1151,7 @@ func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
 			}
 			w.pos(m.Pos())
 			w.string(m.Name())
-			sig, _ := m.Type().(*types.Signature)
+			sig := m.Type().(*types.Signature)
 			w.signature(sig)
 		}
 
@@ -1295,8 +1298,12 @@ func (w *exportWriter) param(obj types.Object) {
 	w.typ(obj.Type(), obj.Pkg())
 }
 
-func (w *exportWriter) value(typ types.Type, v constant.Value) {
-	w.typ(typ, nil)
+// only called for constants
+func (w *exportWriter) value(typ types.Type, v constant.Value, pkg *types.Package) {
+	if pkg == nil {
+		pkg = w.p.localpkg
+	}
+	w.typ(typ, pkg)
 	if w.p.version >= iexportVersionGo1_18 {
 		w.int64(int64(v.Kind()))
 	}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
index 7b1723e0..e9149882 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
@@ -21,8 +21,7 @@ import (
 	"strings"
 
 	"golang.org/x/tools/go/types/objectpath"
-	"golang.org/x/tools/internal/aliases"
-	"golang.org/x/tools/internal/typesinternal"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 type intReader struct {
@@ -30,14 +29,6 @@ type intReader struct {
 	path string
 }
 
-func (r *intReader) int64() int64 {
-	i, err := binary.ReadVarint(r.Reader)
-	if err != nil {
-		errorf("import %q: read varint error: %v", r.path, err)
-	}
-	return i
-}
-
 func (r *intReader) uint64() uint64 {
 	i, err := binary.ReadUvarint(r.Reader)
 	if err != nil {
@@ -101,12 +92,12 @@ const (
 // and returns 0 and a reference to the package.
 // If the export data version is not recognized or the format is otherwise
 // compromised, an error is returned.
-func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (int, *types.Package, error) {
+func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (*types.Package, error) {
 	pkgs, err := iimportCommon(fset, GetPackagesFromMap(imports), data, false, path, false, nil)
 	if err != nil {
-		return 0, nil, err
+		return nil, err
 	}
-	return 0, pkgs[0], nil
+	return pkgs[0], nil
 }
 
 // IImportBundle imports a set of packages from the serialized package bundle.
@@ -574,8 +565,8 @@ func (r *importReader) obj(pkg *types.Package, name string) {
 		if tag == genericAliasTag {
 			tparams = r.tparamList()
 		}
-		typ := r.typ()
-		obj := aliases.New(pos, pkg, name, typ, tparams)
+		obj := types.NewTypeName(pos, pkg, name, nil)
+		types.NewAlias(obj, r.typ()).SetTypeParams(tparams)
 		markBlack(obj) // workaround for golang/go#69912
 		r.declare(obj)
 
@@ -624,8 +615,13 @@ func (r *importReader) obj(pkg *types.Package, name string) {
 				// If the receiver has any targs, set those as the
 				// rparams of the method (since those are the
 				// typeparams being used in the method sig/body).
-				_, recvNamed := typesinternal.ReceiverNamed(recv)
-				targs := recvNamed.TypeArgs()
+				//
+				// Avoid dependency on typesinternal.RecvBase here.
+				t := recv.Type()
+				if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+					t = ptr.Elem()
+				}
+				targs := types.Unalias(t).(*types.Named).TypeArgs()
 				var rparams []*types.TypeParam
 				if targs.Len() > 0 {
 					rparams = make([]*types.TypeParam, targs.Len())
@@ -675,7 +671,7 @@ func (r *importReader) obj(pkg *types.Package, name string) {
 		typ := r.typ()
 
 		v := types.NewVar(pos, pkg, name, typ)
-		typesinternal.SetVarKind(v, typesinternal.PackageVar)
+		v.SetKind(types.PackageVar)
 		r.declare(v)
 
 	default:
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
index 907c8557..a8bfa875 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
@@ -7,6 +7,7 @@ package gcimporter
 import (
 	"go/types"
 	"sync"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // predecl is a cache for the predeclared types in types.Universe.
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/support.go b/vendor/golang.org/x/tools/internal/gcimporter/support.go
index 4af810dc..28b17694 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/support.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/support.go
@@ -9,6 +9,7 @@ import (
 	"io"
 	"strconv"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // Copy of $GOROOT/src/cmd/internal/archive.ReadHeader.
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/ureader.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
index 5d3b7c86..09e833ce 100644
--- a/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
+++ b/vendor/golang.org/x/tools/internal/gcimporter/ureader.go
@@ -13,9 +13,8 @@ import (
 	"sort"
 	"strings"
 
-	"golang.org/x/tools/internal/aliases"
 	"golang.org/x/tools/internal/pkgbits"
-	"golang.org/x/tools/internal/typesinternal"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // A pkgReader holds the shared state for reading a unified IR package
@@ -551,7 +550,9 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 				tparams = r.typeParamNames(false)
 			}
 			typ := r.typ()
-			declare(aliases.New(pos, objPkg, objName, typ, tparams))
+			tname := types.NewTypeName(pos, objPkg, objName, nil)
+			types.NewAlias(tname, typ).SetTypeParams(tparams)
+			declare(tname)
 
 		case pkgbits.ObjConst:
 			pos := r.pos()
@@ -588,7 +589,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)
+						recv.SetKind(types.RecvVar)
 						methods[i] = types.NewFunc(fn.Pos(), fn.Pkg(), fn.Name(), types.NewSignatureType(recv, nil, nil, sig.Params(), sig.Results(), sig.Variadic()))
 					}
 
@@ -629,11 +630,26 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 				})
 			}
 
-			for i, n := 0, r.Len(); i < n; i++ {
-				named.AddMethod(r.method())
-			}
-
 			if r.Version().Has(pkgbits.GenericMethods) {
+				// V4 (go1.27.0) emitted all non-generic methods
+				// before all generic ones, discarding source
+				// order: a bug (go.dev/issue/81188).
+				// V5 (go1.27.x) fixes it by emitting an explicit
+				// index along with each method.
+				type indexedMethod struct {
+					index int // (or -1 in V4)
+					fn    *types.Func
+				}
+
+				var methods []indexedMethod
+
+				// ordinary methods
+				for range r.Len() {
+					idx, m := r.method()
+					methods = append(methods, indexedMethod{idx, m})
+				}
+
+				// generic methods
 				for range r.Len() {
 					// Careful: objIdx is used to read in package-scoped declarations, which
 					// methods are not. Instead, decode it here. This makes it easier to
@@ -648,11 +664,31 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 					pkg, name := r.selector()
 					rtparams := r.typeParamNames(true)
 					recv := r.param()
+					methodIdx := -1
+					if r.Version().Has(pkgbits.PreserveMethodOrder) {
+						methodIdx = r.Len()
+					}
 					tparams := r.typeParamNames(false)
 					sig := r.signature(recv, rtparams, tparams)
 
 					pr.retireReader(r)
-					named.AddMethod(types.NewFunc(pos, pkg, name, sig))
+					methods = append(methods, indexedMethod{methodIdx, types.NewFunc(pos, pkg, name, sig)})
+				}
+
+				if r.Version().Has(pkgbits.PreserveMethodOrder) {
+					sort.Slice(methods, func(i, j int) bool {
+						return methods[i].index < methods[j].index
+					})
+				}
+
+				for _, m := range methods {
+					named.AddMethod(m.fn)
+				}
+
+			} else {
+				for range r.Len() {
+					_, m := r.method()
+					named.AddMethod(m)
 				}
 			}
 
@@ -660,7 +696,7 @@ func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
 			pos := r.pos()
 			typ := r.typ()
 			v := types.NewVar(pos, objPkg, objName, typ)
-			typesinternal.SetVarKind(v, typesinternal.PackageVar)
+			v.SetKind(types.PackageVar)
 			declare(v)
 		}
 	}
@@ -766,8 +802,12 @@ func (r *reader) typeParamNames(isGenMeth bool) []*types.TypeParam {
 	return tparams
 }
 
-func (r *reader) method() *types.Func {
+func (r *reader) method() (int, *types.Func) {
 	r.Sync(pkgbits.SyncMethod)
+	idx := -1
+	if r.Version().Has(pkgbits.PreserveMethodOrder) {
+		idx = r.Len()
+	}
 	pos := r.pos()
 	pkg, name := r.selector()
 
@@ -775,7 +815,7 @@ func (r *reader) method() *types.Func {
 	sig := r.signature(r.param(), rparams, nil)
 
 	_ = r.pos() // TODO(mdempsky): Remove; this is a hacker for linker.go.
-	return types.NewFunc(pos, pkg, name, sig)
+	return idx, types.NewFunc(pos, pkg, name, sig)
 }
 
 func (r *reader) qualifiedIdent() (*types.Package, string) { return r.ident(pkgbits.SyncSym) }
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/codes.go b/vendor/golang.org/x/tools/internal/pkgbits/codes.go
index f0cabde9..21f44d96 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/codes.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/codes.go
@@ -4,6 +4,8 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
+
 // A Code is an enum value that can be encoded into bitstreams.
 //
 // Code types are preferable for enum types, because they allow
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
index c0aba26c..f05e2696 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
@@ -15,6 +15,7 @@ import (
 	"os"
 	"runtime"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // A PkgDecoder provides methods for decoding a package's Unified IR
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/doc.go b/vendor/golang.org/x/tools/internal/pkgbits/doc.go
index c8a2796b..f5a9badf 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/doc.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/doc.go
@@ -30,3 +30,5 @@
 //
 // This is a copy of internal/pkgbits in the Go implementation.
 package pkgbits
+
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
index c17a1239..ac9c8e8b 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
@@ -13,6 +13,7 @@ import (
 	"math/big"
 	"runtime"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // A PkgEncoder provides methods for encoding a package's Unified IR
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/reloc.go b/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
index fcdfb97c..99494aa3 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
@@ -4,6 +4,8 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
+
 // A RelocKind indicates a particular section within a unified IR export.
 type RelocKind int32
 
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/support.go b/vendor/golang.org/x/tools/internal/pkgbits/support.go
index 50534a29..b0011600 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/support.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/support.go
@@ -4,6 +4,7 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 import "fmt"
 
 func assert(b bool) {
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/sync.go b/vendor/golang.org/x/tools/internal/pkgbits/sync.go
index 1520b73a..4cf7f1ee 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/sync.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/sync.go
@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"runtime"
 	"strings"
+	// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
 )
 
 // fmtFrames formats a backtrace for reporting reader/writer desyncs.
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/version.go b/vendor/golang.org/x/tools/internal/pkgbits/version.go
index 0db96527..932a9267 100644
--- a/vendor/golang.org/x/tools/internal/pkgbits/version.go
+++ b/vendor/golang.org/x/tools/internal/pkgbits/version.go
@@ -4,6 +4,8 @@
 
 package pkgbits
 
+// This package is dependency-restricted; see x/tools/go/gcexportdata.TestDeps.
+
 // Version indicates a version of a unified IR bitstream.
 // Each Version indicates the addition, removal, or change of
 // new data in the bitstream.
@@ -37,6 +39,10 @@ const (
 	// V4: encodes generic methods as standalone function objects
 	V4
 
+	// V5: encodes the index of methods to preserve relative order
+	// of nongeneric and generic methods (go.dev/issue/81188).
+	V5
+
 	numVersions = iota
 )
 
@@ -76,6 +82,10 @@ const (
 	// Generic methods may appear as standalone function objects.
 	GenericMethods
 
+	// Method index is encoded to preserve relative order of
+	// nongeneric and generic methods.
+	PreserveMethodOrder
+
 	numFields = iota
 )
 
@@ -85,6 +95,7 @@ var introduced = [numFields]Version{
 	AliasTypeParamNames: V2,
 	CompactCompLiterals: V3,
 	GenericMethods:      V4,
+	PreserveMethodOrder: V5,
 }
 
 // removed is the version a field was removed in or 0 for fields
diff --git a/vendor/golang.org/x/tools/internal/stdlib/deps.go b/vendor/golang.org/x/tools/internal/stdlib/deps.go
index b049e5f9..abd3c875 100644
--- a/vendor/golang.org/x/tools/internal/stdlib/deps.go
+++ b/vendor/golang.org/x/tools/internal/stdlib/deps.go
@@ -44,7 +44,7 @@ var deps = [...]pkginfo{
 	{"crypto/internal/boring/bcache", "\xcf\x02\x14"},
 	{"crypto/internal/boring/sig", ""},
 	{"crypto/internal/constanttime", ""},
-	{"crypto/internal/cryptotest", "\x03\r\v\n%\x11\x1a\r\x12\x12!\x04\x06\n\x19\x01\x11\x11\x1d\x01\a\x03\x02\b\x02\x01\x05\f"},
+	{"crypto/internal/cryptotest", "\x03\r\v\n%\x11\x1a\r\x12\x12!\x04\x06\n\x19\x01\x11\x11\x1d\x01\a\x03\x02\b\x02\x01\x04\x01\f"},
 	{"crypto/internal/cryptotest/wycheproof", "\x0e\x12T\x01\f\x01r@\x05\x03\x15\x10"},
 	{"crypto/internal/cryptotest/x509limbo", "u\n\x03\xba\x01\x03\x1e"},
 	{"crypto/internal/entropy", "M"},
@@ -122,7 +122,7 @@ var deps = [...]pkginfo{
 	{"embed/internal/embedtest", ""},
 	{"encoding", ""},
 	{"encoding/ascii85", "\x86\x02E"},
-	{"encoding/asn1", "\x03|\x03h(\x01)\r\x02\x01\x11\x03\x01"},
+	{"encoding/asn1", "\x03|\x03h(\x01)\x05\b\x02\x01\x11\x03\x01"},
 	{"encoding/base32", "\x86\x02C\x02"},
 	{"encoding/base64", "\xaa\x01\\C\x02"},
 	{"encoding/binary", "\x7f\x87\x01\f*\r\x05"},
@@ -319,7 +319,7 @@ var deps = [...]pkginfo{
 	{"net/rpc/jsonrpc", "u\n\x03\x84\x01\x16\x13\x1f"},
 	{"net/smtp", "\x196\r\x14\x0f\x03\x84\x01\x16\x16\x1a"},
 	{"net/textproto", "\x02\x01|\x03\x84\x01\f\n/\x01\x02\x15"},
-	{"net/url", "\x7f\x03Ff\v\x10\x02\x01\x17"},
+	{"net/url", "\x03|\x03Ff\v\x10\x02\x01\x17"},
 	{"os", "\x7f*\x01\x19\x04\x11\x14\x01\x03\x01\x05\x10\x01:\b\x05\x01\x01\r\x06"},
 	{"os/exec", "\x03\nrI(\x01\x15\x01-\x06\a\n\x01\x03\x01\r"},
 	{"os/exec/internal/fdtest", "\xd0\x02"},
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go b/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
index e0d63c46..9af27f80 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/isnamed.go
@@ -60,12 +60,10 @@ func IsFunctionNamed(obj types.Object, pkgPath string, names ...string) bool {
 // which is important for the performance of syntax matching.
 func IsMethodNamed(obj types.Object, pkgPath string, typeName string, names ...string) bool {
 	if fn, ok := obj.(*types.Func); ok {
-		if recv := fn.Signature().Recv(); recv != nil {
-			_, T := ReceiverNamed(recv)
-			return T != nil &&
-				IsTypeNamed(T, pkgPath, typeName) &&
-				slices.Contains(names, fn.Name())
-		}
+		_, T := RecvBase(fn)
+		return T != nil &&
+			IsTypeNamed(T, pkgPath, typeName) &&
+			slices.Contains(names, fn.Name())
 	}
 	return false
 }
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/recv.go b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
index 8352ea76..564e93b1 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/recv.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
@@ -8,19 +8,32 @@ import (
 	"go/types"
 )
 
-// ReceiverNamed returns the named type (if any) associated with the
-// type of recv, which may be of the form N or *N, or aliases thereof.
-// It also reports whether a Pointer was present.
+// RecvBase returns the receiver base type (if any) of the method fn,
+// and reports whether the receiver is a pointer to it.
 //
-// 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 {
-		isPtr = true
-		t = ptr.Elem()
+// The spec says of a method declaration: the receiver's "type must be
+// a defined type T or a pointer to a defined type T, possibly followed
+// by a list of type parameter names [P1, P2, …] enclosed in square
+// brackets. T is called the receiver base type."
+//
+// The named result is nil if fn is not a method, or if its receiver
+// is an anonymous interface or struct type, as in interface{ f() }.
+//
+// TODO(adonovan): go.dev/issue/81715 proposes this as a method of *types.Func.
+func RecvBase(fn *types.Func) (isPtr bool, named *types.Named) {
+	// The boolean result appears first to
+	// avoid misinterpretation as an 'ok'
+	// bool, and because that's the natural
+	// reading order in "*Named".
+
+	if recv := fn.Signature().Recv(); recv != nil {
+		t := recv.Type()
+		if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+			isPtr = true
+			t = ptr.Elem()
+		}
+		named, _ = types.Unalias(t).(*types.Named)
 	}
-	named, _ = types.Unalias(t).(*types.Named)
 	return
 }
 
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/types.go b/vendor/golang.org/x/tools/internal/typesinternal/types.go
index 9fd48b08..b916df22 100644
--- a/vendor/golang.org/x/tools/internal/typesinternal/types.go
+++ b/vendor/golang.org/x/tools/internal/typesinternal/types.go
@@ -9,7 +9,7 @@
 //   - functions for converting types to strings or syntax (e.g. [TypeExpr], FileQualifier]);
 //   - helpers for working with the [go/types] API (e.g. [NewTypesInfo]);
 //   - access to internal go/types APIs that are not yet
-//     exported (e.g. [SetUsesCgo], [ErrorCodeStartEnd], [VarKind]); and
+//     exported (e.g. [SetUsesCgo], [ErrorCodeStartEnd]); and
 //   - common algorithms related to types (e.g. [TooNewStdSymbols]).
 //
 // See also:
@@ -215,17 +215,17 @@ func ObjectKind(obj types.Object) string {
 		}
 	case *types.Var:
 		switch obj.Kind() {
-		case PackageVar:
+		case types.PackageVar:
 			return "package-level variable"
-		case LocalVar:
+		case types.LocalVar:
 			return "local variable"
-		case RecvVar:
+		case types.RecvVar:
 			return "receiver"
-		case ParamVar:
+		case types.ParamVar:
 			return "parameter"
-		case ResultVar:
+		case types.ResultVar:
 			return "result variable"
-		case FieldVar:
+		case types.FieldVar:
 			return "struct field"
 		}
 	case *types.Func:
@@ -271,6 +271,8 @@ func ImplicitFieldSelections(seln types.Selection) iter.Seq2[*types.Var, bool] {
 	}
 }
 
+// TupleOf returns a tuple type with the specified list of (unnamed)
+// var types. Neither the zero nor one cases are special.
 func TupleOf(elems ...types.Type) *types.Tuple {
 	params := make([]*types.Var, len(elems))
 	for i, elem := range elems {
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go b/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
deleted file mode 100644
index 26499cdd..00000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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.
-
-//go:build go1.25
-
-package typesinternal
-
-import "go/types"
-
-type VarKind = types.VarKind
-
-const (
-	PackageVar = types.PackageVar
-	LocalVar   = types.LocalVar
-	RecvVar    = types.RecvVar
-	ParamVar   = types.ParamVar
-	ResultVar  = types.ResultVar
-	FieldVar   = types.FieldVar
-)
-
-func GetVarKind(v *types.Var) VarKind       { return v.Kind() }
-func SetVarKind(v *types.Var, kind VarKind) { v.SetKind(kind) }
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go b/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go
deleted file mode 100644
index 17b1804b..00000000
--- a/vendor/golang.org/x/tools/internal/typesinternal/varkind_go124.go
+++ /dev/null
@@ -1,39 +0,0 @@
-// 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.
-
-//go:build !go1.25
-
-package typesinternal
-
-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/modules.txt b/vendor/modules.txt
index 1cf41f1c..921bf7f5 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -228,7 +228,7 @@ go.yaml.in/yaml/v2
 # go.yaml.in/yaml/v3 v3.0.4
 ## explicit; go 1.16
 go.yaml.in/yaml/v3
-# golang.org/x/crypto v0.57.0
+# golang.org/x/crypto v0.58.0
 ## explicit; go 1.26.0
 golang.org/x/crypto/blowfish
 golang.org/x/crypto/chacha20
@@ -258,12 +258,12 @@ golang.org/x/net/internal/httpsfv
 # golang.org/x/sync v0.24.0
 ## explicit; go 1.26.0
 golang.org/x/sync/errgroup
-# golang.org/x/sys v0.48.0
+# golang.org/x/sys v0.49.0
 ## explicit; go 1.26.0
 golang.org/x/sys/cpu
 golang.org/x/sys/unix
 golang.org/x/sys/windows
-# golang.org/x/text v0.42.0
+# golang.org/x/text v0.43.0
 ## explicit; go 1.26.0
 golang.org/x/text/encoding
 golang.org/x/text/encoding/charmap
@@ -285,15 +285,14 @@ golang.org/x/text/secure/bidirule
 golang.org/x/text/transform
 golang.org/x/text/unicode/bidi
 golang.org/x/text/unicode/norm
-# golang.org/x/tools v0.49.0
-## explicit; go 1.25.0
+# golang.org/x/tools v0.51.0
+## explicit; go 1.26.0
 golang.org/x/tools/cover
 golang.org/x/tools/go/ast/edge
 golang.org/x/tools/go/ast/inspector
 golang.org/x/tools/go/gcexportdata
 golang.org/x/tools/go/packages
 golang.org/x/tools/go/types/objectpath
-golang.org/x/tools/internal/aliases
 golang.org/x/tools/internal/event
 golang.org/x/tools/internal/event/core
 golang.org/x/tools/internal/event/keys

From 589e84b739bb59d2046ac11a25a3dfc0748f73ad Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 11:09:54 +0000
Subject: [PATCH 4/6] chore(deps): Bump github.com/urfave/cli/v3 from 3.10.1 to
 3.14.0

Bumps [github.com/urfave/cli/v3](https://github.com/urfave/cli) from 3.10.1 to 3.14.0.
- [Release notes](https://github.com/urfave/cli/releases)
- [Changelog](https://github.com/urfave/cli/blob/main/docs/CHANGELOG.md)
- [Commits](https://github.com/urfave/cli/compare/v3.10.1...v3.14.0)

---
updated-dependencies:
- dependency-name: github.com/urfave/cli/v3
  dependency-version: 3.14.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Carlos Eduardo Arango Gutierrez <eduardoa@nvidia.com>
---
 go.mod                                        |   8 +-
 go.sum                                        |  12 +-
 .../testify/assert/assertion_format.go        |  28 +-
 .../testify/assert/assertion_forward.go       |  52 ++-
 .../testify/assert/assertion_order.go         |  14 +-
 .../stretchr/testify/assert/assertions.go     | 147 ++++----
 .../github.com/stretchr/testify/assert/doc.go |   4 +-
 .../testify/assert/yaml/yaml_custom.go        |   2 +-
 .../testify/assert/yaml/yaml_default.go       |   6 +-
 .../stretchr/testify/assert/yaml/yaml_fail.go |   2 +-
 .../testify/internal/difflib}/LICENSE         |   2 +-
 .../testify/internal}/difflib/difflib.go      | 206 +----------
 .../testify/internal/spew}/LICENSE            |   0
 .../stretchr/testify/internal/spew/README.md  |  12 +
 .../testify/internal}/spew/bypass.go          |   1 +
 .../testify/internal}/spew/bypasssafe.go      |   1 +
 .../testify/internal}/spew/common.go          |   0
 .../testify/internal}/spew/config.go          |  30 +-
 .../testify/internal}/spew/doc.go             | 146 ++++----
 .../testify/internal}/spew/dump.go            |  18 +-
 .../testify/internal}/spew/format.go          |   0
 .../testify/internal}/spew/spew.go            |   0
 .../stretchr/testify/require/doc.go           |   6 +-
 .../stretchr/testify/require/require.go       | 102 +++---
 .../stretchr/testify/require/require.go.tmpl  |   2 +-
 .../testify/require/require_forward.go        | 100 +++---
 .../testify/require/require_forward.go.tmpl   |   2 +-
 .../stretchr/testify/require/requirements.go  |   8 +-
 vendor/github.com/urfave/cli/v3/README.md     |  21 ++
 vendor/github.com/urfave/cli/v3/args.go       |  23 +-
 vendor/github.com/urfave/cli/v3/command.go    | 105 +++++-
 .../github.com/urfave/cli/v3/command_parse.go |  53 ++-
 .../github.com/urfave/cli/v3/command_run.go   |  92 ++++-
 .../github.com/urfave/cli/v3/command_setup.go |  30 +-
 vendor/github.com/urfave/cli/v3/completion.go |   2 +-
 vendor/github.com/urfave/cli/v3/docs.go       |   3 +-
 vendor/github.com/urfave/cli/v3/errors.go     |  22 ++
 vendor/github.com/urfave/cli/v3/fish.go       |  20 +-
 vendor/github.com/urfave/cli/v3/flag.go       |  19 +
 .../urfave/cli/v3/flag_bool_with_inverse.go   |  47 ++-
 vendor/github.com/urfave/cli/v3/flag_impl.go  |  90 ++++-
 .../github.com/urfave/cli/v3/flag_map_impl.go |  15 +-
 vendor/github.com/urfave/cli/v3/flag_mutex.go |  79 +++-
 vendor/github.com/urfave/cli/v3/flag_text.go  |  86 +++++
 .../urfave/cli/v3/flag_timestamp.go           |  18 +-
 vendor/github.com/urfave/cli/v3/funcs.go      |   7 +
 .../urfave/cli/v3/godoc-current.txt           |  90 +++++
 vendor/github.com/urfave/cli/v3/help.go       | 140 ++------
 .../urfave/cli/v3/help_notemplate.go          | 338 ++++++++++++++++++
 .../github.com/urfave/cli/v3/help_template.go | 204 +++++++++++
 .../urfave/cli/v3/mkdocs-requirements.txt     |   6 +-
 .../github.com/urfave/cli/v3/suggestions.go   |  11 +-
 vendor/github.com/urfave/cli/v3/template.go   |  88 -----
 .../github.com/urfave/cli/v3/value_source.go  |   1 +
 vendor/go.yaml.in/yaml/v3/parserc.go          | 178 +++++----
 vendor/go.yaml.in/yaml/v3/yamlh.go            |  44 ++-
 vendor/modules.txt                            |  14 +-
 57 files changed, 1823 insertions(+), 934 deletions(-)
 rename vendor/github.com/{pmezard/go-difflib => stretchr/testify/internal/difflib}/LICENSE (95%)
 rename vendor/github.com/{pmezard/go-difflib => stretchr/testify/internal}/difflib/difflib.go (77%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal/spew}/LICENSE (100%)
 create mode 100644 vendor/github.com/stretchr/testify/internal/spew/README.md
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/bypass.go (98%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/bypasssafe.go (96%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/common.go (100%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/config.go (95%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/doc.go (65%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/dump.go (96%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/format.go (100%)
 rename vendor/github.com/{davecgh/go-spew => stretchr/testify/internal}/spew/spew.go (100%)
 create mode 100644 vendor/github.com/urfave/cli/v3/flag_text.go
 create mode 100644 vendor/github.com/urfave/cli/v3/help_notemplate.go
 create mode 100644 vendor/github.com/urfave/cli/v3/help_template.go

diff --git a/go.mod b/go.mod
index b1089210..32e0a290 100644
--- a/go.mod
+++ b/go.mod
@@ -12,8 +12,8 @@ require (
 	github.com/onsi/ginkgo/v2 v2.32.0
 	github.com/onsi/gomega v1.42.1
 	github.com/pkg/sftp v1.13.11
-	github.com/stretchr/testify v1.11.1
-	github.com/urfave/cli/v3 v3.10.1
+	github.com/stretchr/testify v1.12.1
+	github.com/urfave/cli/v3 v3.14.0
 	golang.org/x/crypto v0.58.0
 	golang.org/x/sync v0.24.0
 	gopkg.in/yaml.v3 v3.0.1
@@ -35,7 +35,6 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/ssooidc v1.43.4 // indirect
 	github.com/aws/aws-sdk-go-v2/service/sts v1.51.4 // indirect
 	github.com/aws/smithy-go v1.28.5 // indirect
-	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/fxamacker/cbor/v2 v2.9.1 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
@@ -45,10 +44,9 @@ require (
 	github.com/kr/fs v0.1.0 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect
-	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
 	go.yaml.in/yaml/v2 v2.4.4 // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	go.yaml.in/yaml/v3 v3.0.5 // indirect
 	golang.org/x/mod v0.41.0 // indirect
 	golang.org/x/net v0.60.0 // indirect
 	golang.org/x/sys v0.49.0 // indirect
diff --git a/go.sum b/go.sum
index 2943b054..42e57970 100644
--- a/go.sum
+++ b/go.sum
@@ -94,8 +94,8 @@ github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
 github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.12.1 h1:EuwCh5fleGS7H32xRwO3wRGT7DxrDhLAT6FF8MpWDWE=
+github.com/stretchr/testify v1.12.1/go.mod h1:MDEgiDPPsNp5cuIrHPPCyornHKgEVbtFUmoNlxoYthg=
 github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
 github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
 github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
@@ -104,14 +104,14 @@ github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
 github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
 github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
 github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
-github.com/urfave/cli/v3 v3.10.1 h1:7Kx9H50hrHbRbyxgO1KP6/BcbiGRz0uYh5YyQ30JEEY=
-github.com/urfave/cli/v3 v3.10.1/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
+github.com/urfave/cli/v3 v3.14.0 h1:a8414NQlHJs0c/iBsulKLzlES0n/lEAskbL2LKpU4/s=
+github.com/urfave/cli/v3 v3.14.0/go.mod h1:vXn6HxPNccJSzQr2QvwVncOKrgYGIHU0HY5h8B2nQj4=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
 github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
 go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
 go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
-go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw=
+go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg=
 golang.org/x/crypto v0.58.0 h1:COkYLr4k7nDI4r6QtMML2AfzeIswWHAJthLS6K/M/54=
 golang.org/x/crypto v0.58.0/go.mod h1:Xh+kl5A+M0gMiWDytH2Hhr5Z7WbNCpv/eB/EFgfSk+w=
 golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c=
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_format.go b/vendor/github.com/stretchr/testify/assert/assertion_format.go
index c592f6ad..a19a8927 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_format.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_format.go
@@ -84,7 +84,7 @@ func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, ar
 	return Equal(t, expected, actual, append([]interface{}{msg}, args...)...)
 }
 
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// EqualErrorf asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -124,7 +124,7 @@ func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg stri
 	return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
 }
 
-// Errorf asserts that a function returned an error (i.e. not `nil`).
+// Errorf asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	assert.Errorf(t, err, "error message %s", "formatted")
@@ -144,8 +144,8 @@ func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...int
 	return ErrorAs(t, err, target, append([]interface{}{msg}, args...)...)
 }
 
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContainsf asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	assert.ErrorContainsf(t, err,  expectedErrorSubString, "error message %s", "formatted")
@@ -190,10 +190,10 @@ func Eventuallyf(t TestingT, condition func() bool, waitFor time.Duration, tick
 //		time.Sleep(8*time.Second)
 //		externalValue = true
 //	}()
-//	assert.EventuallyWithTf(t, func(c *assert.CollectT, "error message %s", "formatted") {
+//	assert.EventuallyWithTf(t, func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 10*time.Second, 1*time.Second, "error message %s", "formatted")
 func EventuallyWithTf(t TestingT, condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -552,7 +552,7 @@ func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) bool
 	return NoDirExists(t, path, append([]interface{}{msg}, args...)...)
 }
 
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
+// NoErrorf asserts that a function returned a nil error (ie. no error).
 //
 //	  actualObj, err := SomeFunction()
 //	  if assert.NoErrorf(t, err, "error message %s", "formatted") {
@@ -849,7 +849,19 @@ func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time,
 	return WithinRange(t, actual, start, end, append([]interface{}{msg}, args...)...)
 }
 
-// YAMLEqf asserts that two YAML strings are equivalent.
+// YAMLEqf asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	assert.YAMLEqf(t, expected, actual, "error message %s", "formatted")
 func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
index 58db9284..cd2a8606 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
@@ -146,7 +146,7 @@ func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs
 	return Equal(a.t, expected, actual, msgAndArgs...)
 }
 
-// EqualError asserts that a function returned an error (i.e. not `nil`)
+// EqualError asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -158,7 +158,7 @@ func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...
 	return EqualError(a.t, theError, errString, msgAndArgs...)
 }
 
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// EqualErrorf asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -240,7 +240,7 @@ func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string
 	return Equalf(a.t, expected, actual, msg, args...)
 }
 
-// Error asserts that a function returned an error (i.e. not `nil`).
+// Error asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	a.Error(err)
@@ -269,8 +269,8 @@ func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ..
 	return ErrorAsf(a.t, err, target, msg, args...)
 }
 
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContains asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	a.ErrorContains(err,  expectedErrorSubString)
@@ -281,8 +281,8 @@ func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs .
 	return ErrorContains(a.t, theError, contains, msgAndArgs...)
 }
 
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContainsf asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	a.ErrorContainsf(err,  expectedErrorSubString, "error message %s", "formatted")
@@ -311,7 +311,7 @@ func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...inter
 	return ErrorIsf(a.t, err, target, msg, args...)
 }
 
-// Errorf asserts that a function returned an error (i.e. not `nil`).
+// Errorf asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	a.Errorf(err, "error message %s", "formatted")
@@ -372,10 +372,10 @@ func (a *Assertions) EventuallyWithT(condition func(collect *CollectT), waitFor
 //		time.Sleep(8*time.Second)
 //		externalValue = true
 //	}()
-//	a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
+//	a.EventuallyWithTf(func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 10*time.Second, 1*time.Second, "error message %s", "formatted")
 func (a *Assertions) EventuallyWithTf(condition func(collect *CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1096,7 +1096,7 @@ func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{})
 	return NoDirExistsf(a.t, path, msg, args...)
 }
 
-// NoError asserts that a function returned no error (i.e. `nil`).
+// NoError asserts that a function returned a nil error (ie. no error).
 //
 //	  actualObj, err := SomeFunction()
 //	  if a.NoError(err) {
@@ -1109,7 +1109,7 @@ func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
 	return NoError(a.t, err, msgAndArgs...)
 }
 
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
+// NoErrorf asserts that a function returned a nil error (ie. no error).
 //
 //	  actualObj, err := SomeFunction()
 //	  if a.NoErrorf(err, "error message %s", "formatted") {
@@ -1690,7 +1690,19 @@ func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Ti
 	return WithinRangef(a.t, actual, start, end, msg, args...)
 }
 
-// YAMLEq asserts that two YAML strings are equivalent.
+// YAMLEq asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	a.YAMLEq(expected, actual)
 func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1698,7 +1710,19 @@ func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interf
 	return YAMLEq(a.t, expected, actual, msgAndArgs...)
 }
 
-// YAMLEqf asserts that two YAML strings are equivalent.
+// YAMLEqf asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	a.YAMLEqf(expected, actual, "error message %s", "formatted")
 func (a *Assertions) YAMLEqf(expected string, actual string, msg string, args ...interface{}) bool {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
diff --git a/vendor/github.com/stretchr/testify/assert/assertion_order.go b/vendor/github.com/stretchr/testify/assert/assertion_order.go
index 2fdf80fd..a44b40ed 100644
--- a/vendor/github.com/stretchr/testify/assert/assertion_order.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_order.go
@@ -9,7 +9,7 @@ import (
 func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareResult, failMessage string, msgAndArgs ...interface{}) bool {
 	objKind := reflect.TypeOf(object).Kind()
 	if objKind != reflect.Slice && objKind != reflect.Array {
-		return false
+		return Fail(t, fmt.Sprintf("object %T is not an ordered collection", object), msgAndArgs...)
 	}
 
 	objValue := reflect.ValueOf(object)
@@ -50,6 +50,9 @@ func isOrdered(t TestingT, object interface{}, allowedComparesResults []compareR
 //	assert.IsIncreasing(t, []float{1, 2})
 //	assert.IsIncreasing(t, []string{"a", "b"})
 func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
 	return isOrdered(t, object, []compareResult{compareLess}, "\"%v\" is not less than \"%v\"", msgAndArgs...)
 }
 
@@ -59,6 +62,9 @@ func IsIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) boo
 //	assert.IsNonIncreasing(t, []float{2, 1})
 //	assert.IsNonIncreasing(t, []string{"b", "a"})
 func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
 	return isOrdered(t, object, []compareResult{compareEqual, compareGreater}, "\"%v\" is not greater than or equal to \"%v\"", msgAndArgs...)
 }
 
@@ -68,6 +74,9 @@ func IsNonIncreasing(t TestingT, object interface{}, msgAndArgs ...interface{})
 //	assert.IsDecreasing(t, []float{2, 1})
 //	assert.IsDecreasing(t, []string{"b", "a"})
 func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
 	return isOrdered(t, object, []compareResult{compareGreater}, "\"%v\" is not greater than \"%v\"", msgAndArgs...)
 }
 
@@ -77,5 +86,8 @@ func IsDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) boo
 //	assert.IsNonDecreasing(t, []float{1, 2})
 //	assert.IsNonDecreasing(t, []string{"a", "b"})
 func IsNonDecreasing(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
+	if h, ok := t.(tHelper); ok {
+		h.Helper()
+	}
 	return isOrdered(t, object, []compareResult{compareLess, compareEqual}, "\"%v\" is not less than or equal to \"%v\"", msgAndArgs...)
 }
diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go
index de8de0cb..166f6372 100644
--- a/vendor/github.com/stretchr/testify/assert/assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/assertions.go
@@ -17,11 +17,10 @@ import (
 	"unicode"
 	"unicode/utf8"
 
-	"github.com/davecgh/go-spew/spew"
-	"github.com/pmezard/go-difflib/difflib"
-
-	// Wrapper around gopkg.in/yaml.v3
+	// Wrapper around go.yaml.in/yaml/v3
 	"github.com/stretchr/testify/assert/yaml"
+	"github.com/stretchr/testify/internal/difflib"
+	"github.com/stretchr/testify/internal/spew"
 )
 
 //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=assert -template=assertion_format.go.tmpl"
@@ -33,19 +32,19 @@ type TestingT interface {
 
 // ComparisonAssertionFunc is a common function prototype when comparing two values.  Can be useful
 // for table driven tests.
-type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool
+type ComparisonAssertionFunc = func(TestingT, interface{}, interface{}, ...interface{}) bool
 
 // ValueAssertionFunc is a common function prototype when validating a single value.  Can be useful
 // for table driven tests.
-type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool
+type ValueAssertionFunc = func(TestingT, interface{}, ...interface{}) bool
 
 // BoolAssertionFunc is a common function prototype when validating a bool value.  Can be useful
 // for table driven tests.
-type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool
+type BoolAssertionFunc = func(TestingT, bool, ...interface{}) bool
 
 // ErrorAssertionFunc is a common function prototype when validating an error value.  Can be useful
 // for table driven tests.
-type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool
+type ErrorAssertionFunc = func(TestingT, error, ...interface{}) bool
 
 // PanicAssertionFunc is a common function prototype when validating a panic value.  Can be useful
 // for table driven tests.
@@ -325,13 +324,15 @@ func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
 func indentMessageLines(message string, longestLabelLen int) string {
 	outBuf := new(bytes.Buffer)
 
-	for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ {
-		// no need to align first line because it starts at the correct location (after the label)
-		if i != 0 {
-			// append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab
-			outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t")
+	scanner := bufio.NewScanner(strings.NewReader(message))
+	for firstLine := true; scanner.Scan(); firstLine = false {
+		if !firstLine {
+			fmt.Fprint(outBuf, "\n\t"+strings.Repeat(" ", longestLabelLen+1)+"\t")
 		}
-		outBuf.WriteString(scanner.Text())
+		fmt.Fprint(outBuf, scanner.Text())
+	}
+	if err := scanner.Err(); err != nil {
+		return fmt.Sprintf("cannot display message: %s", err)
 	}
 
 	return outBuf.String()
@@ -544,9 +545,8 @@ func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) b
 	if !same {
 		// both are pointers but not the same type & pointing to the same address
 		return Fail(t, fmt.Sprintf("Not same: \n"+
-			"expected: %p %#[1]v\n"+
-			"actual  : %p %#[2]v",
-			expected, actual), msgAndArgs...)
+			"expected: %[2]s (%[1]T)(%[1]p)\n"+
+			"actual  : %[4]s (%[3]T)(%[3]p)", expected, truncatingFormat("%#v", expected), actual, truncatingFormat("%#v", actual)), msgAndArgs...)
 	}
 
 	return true
@@ -571,8 +571,8 @@ func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}
 
 	if same {
 		return Fail(t, fmt.Sprintf(
-			"Expected and actual point to the same object: %p %#[1]v",
-			expected), msgAndArgs...)
+			"Expected and actual point to the same object: %p %s",
+			expected, truncatingFormat("%#v", expected)), msgAndArgs...)
 	}
 	return true
 }
@@ -604,25 +604,26 @@ func samePointers(first, second interface{}) (same bool, ok bool) {
 // to a type conversion in the Go grammar.
 func formatUnequalValues(expected, actual interface{}) (e string, a string) {
 	if reflect.TypeOf(expected) != reflect.TypeOf(actual) {
-		return fmt.Sprintf("%T(%s)", expected, truncatingFormat(expected)),
-			fmt.Sprintf("%T(%s)", actual, truncatingFormat(actual))
+		return fmt.Sprintf("%T(%s)", expected, truncatingFormat("%#v", expected)),
+			fmt.Sprintf("%T(%s)", actual, truncatingFormat("%#v", actual))
 	}
 	switch expected.(type) {
 	case time.Duration:
 		return fmt.Sprintf("%v", expected), fmt.Sprintf("%v", actual)
 	}
-	return truncatingFormat(expected), truncatingFormat(actual)
+	return truncatingFormat("%#v", expected), truncatingFormat("%#v", actual)
 }
 
 // truncatingFormat formats the data and truncates it if it's too long.
 //
 // This helps keep formatted error messages lines from exceeding the
 // bufio.MaxScanTokenSize max line length that the go testing framework imposes.
-func truncatingFormat(data interface{}) string {
-	value := fmt.Sprintf("%#v", data)
-	max := bufio.MaxScanTokenSize - 100 // Give us some space the type info too if needed.
-	if len(value) > max {
-		value = value[0:max] + "<... truncated>"
+func truncatingFormat(format string, data interface{}) string {
+	value := fmt.Sprintf(format, data)
+	// Give us space for two truncated objects and the surrounding sentence.
+	maxMessageSize := bufio.MaxScanTokenSize/2 - 100
+	if len(value) > maxMessageSize {
+		value = value[0:maxMessageSize] + "<... truncated>"
 	}
 	return value
 }
@@ -743,7 +744,7 @@ func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
 	}
-	return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...)
+	return Fail(t, fmt.Sprintf("Expected nil, but got: %s", truncatingFormat("%#v", object)), msgAndArgs...)
 }
 
 // isEmpty gets whether the specified object is considered empty or not.
@@ -793,7 +794,7 @@ func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool {
 		if h, ok := t.(tHelper); ok {
 			h.Helper()
 		}
-		Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...)
+		Fail(t, fmt.Sprintf("Should be empty, but was %s", truncatingFormat("%v", object)), msgAndArgs...)
 	}
 
 	return pass
@@ -836,11 +837,11 @@ func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{})
 	}
 	l, ok := getLen(object)
 	if !ok {
-		return Fail(t, fmt.Sprintf("\"%v\" could not be applied builtin len()", object), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%q could not be applied builtin len()", truncatingFormat("%v", object)), msgAndArgs...)
 	}
 
 	if l != length {
-		return Fail(t, fmt.Sprintf("\"%v\" should have %d item(s), but has %d", object, length, l), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%q should have %d item(s), but has %d", truncatingFormat("%v", object), length, l), msgAndArgs...)
 	}
 	return true
 }
@@ -889,7 +890,7 @@ func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{
 	}
 
 	if ObjectsAreEqual(expected, actual) {
-		return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Should not be: %s\n", truncatingFormat("%#v", actual)), msgAndArgs...)
 	}
 
 	return true
@@ -904,7 +905,7 @@ func NotEqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...inte
 	}
 
 	if ObjectsAreEqualValues(expected, actual) {
-		return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Should not be: %s\n", truncatingFormat("%#v", actual)), msgAndArgs...)
 	}
 
 	return true
@@ -964,10 +965,10 @@ func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bo
 
 	ok, found := containsElement(s, contains)
 	if !ok {
-		return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%s could not be applied builtin len()", truncatingFormat("%#v", s)), msgAndArgs...)
 	}
 	if !found {
-		return Fail(t, fmt.Sprintf("%#v does not contain %#v", s, contains), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%s does not contain %#v", truncatingFormat("%#v", s), contains), msgAndArgs...)
 	}
 
 	return true
@@ -986,10 +987,10 @@ func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{})
 
 	ok, found := containsElement(s, contains)
 	if !ok {
-		return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", s), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%s could not be applied builtin len()", truncatingFormat("%#v", s)), msgAndArgs...)
 	}
 	if found {
-		return Fail(t, fmt.Sprintf("%#v should not contain %#v", s, contains), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%s should not contain %#v", truncatingFormat("%#v", s), contains), msgAndArgs...)
 	}
 
 	return true
@@ -1031,10 +1032,10 @@ func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok
 			av := actualMap.MapIndex(k)
 
 			if !av.IsValid() {
-				return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
+				return Fail(t, fmt.Sprintf("%s does not contain %s", truncatingFormat("%#v", list), truncatingFormat("%#v", subset)), msgAndArgs...)
 			}
 			if !ObjectsAreEqual(ev.Interface(), av.Interface()) {
-				return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, subset), msgAndArgs...)
+				return Fail(t, fmt.Sprintf("%s does not contain %s", truncatingFormat("%#v", list), truncatingFormat("%#v", subset)), msgAndArgs...)
 			}
 		}
 
@@ -1056,7 +1057,7 @@ func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok
 			return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", list), msgAndArgs...)
 		}
 		if !found {
-			return Fail(t, fmt.Sprintf("%#v does not contain %#v", list, element), msgAndArgs...)
+			return Fail(t, fmt.Sprintf("%s does not contain %#v", truncatingFormat("%#v", list), element), msgAndArgs...)
 		}
 	}
 
@@ -1082,12 +1083,12 @@ func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{})
 
 	listKind := reflect.TypeOf(list).Kind()
 	if listKind != reflect.Array && listKind != reflect.Slice && listKind != reflect.Map {
-		return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%#v has an unsupported type %s", list, listKind), msgAndArgs...)
 	}
 
 	subsetKind := reflect.TypeOf(subset).Kind()
 	if subsetKind != reflect.Array && subsetKind != reflect.Slice && subsetKind != reflect.Map {
-		return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%#v has an unsupported type %s", subset, subsetKind), msgAndArgs...)
 	}
 
 	if subsetKind == reflect.Map && listKind == reflect.Map {
@@ -1106,7 +1107,7 @@ func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{})
 			}
 		}
 
-		return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("%s is a subset of %s", truncatingFormat("%#v", subset), truncatingFormat("%#v", list)), msgAndArgs...)
 	}
 
 	subsetList := reflect.ValueOf(subset)
@@ -1121,14 +1122,14 @@ func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{})
 		element := subsetList.Index(i).Interface()
 		ok, found := containsElement(list, element)
 		if !ok {
-			return Fail(t, fmt.Sprintf("%q could not be applied builtin len()", list), msgAndArgs...)
+			return Fail(t, fmt.Sprintf("%#v could not be applied builtin len()", list), msgAndArgs...)
 		}
 		if !found {
 			return true
 		}
 	}
 
-	return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...)
+	return Fail(t, fmt.Sprintf("%s is a subset of %s", truncatingFormat("%#v", subset), truncatingFormat("%#v", list)), msgAndArgs...)
 }
 
 // ElementsMatch asserts that the specified listA(array, slice...) is equal to specified
@@ -1343,9 +1344,15 @@ func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs .
 	if !funcDidPanic {
 		return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...)
 	}
-	panicErr, ok := panicValue.(error)
-	if !ok || panicErr.Error() != errString {
-		return Fail(t, fmt.Sprintf("func %#v should panic with error message:\t%#v\n\tPanic value:\t%#v\n\tPanic stack:\t%s", f, errString, panicValue, panickedStack), msgAndArgs...)
+	panicErr, isError := panicValue.(error)
+	if !isError || panicErr.Error() != errString {
+		msg := fmt.Sprintf("func %#v should panic with error message:\t%#v\n", f, errString)
+		if isError {
+			msg += fmt.Sprintf("\tError message:\t%#v\n", panicErr.Error())
+		}
+		msg += fmt.Sprintf("\tPanic value:\t%#v\n", panicValue)
+		msg += fmt.Sprintf("\tPanic stack:\t%s\n", panickedStack)
+		return Fail(t, msg, msgAndArgs...)
 	}
 
 	return true
@@ -1624,7 +1631,7 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m
 	Errors
 */
 
-// NoError asserts that a function returned no error (i.e. `nil`).
+// NoError asserts that a function returned a nil error (ie. no error).
 //
 //	  actualObj, err := SomeFunction()
 //	  if assert.NoError(t, err) {
@@ -1635,13 +1642,13 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool {
 		if h, ok := t.(tHelper); ok {
 			h.Helper()
 		}
-		return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Received unexpected error:\n%s", truncatingFormat("%+v", err)), msgAndArgs...)
 	}
 
 	return true
 }
 
-// Error asserts that a function returned an error (i.e. not `nil`).
+// Error asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	assert.Error(t, err)
@@ -1656,7 +1663,7 @@ func Error(t TestingT, err error, msgAndArgs ...interface{}) bool {
 	return true
 }
 
-// EqualError asserts that a function returned an error (i.e. not `nil`)
+// EqualError asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -1674,13 +1681,13 @@ func EqualError(t TestingT, theError error, errString string, msgAndArgs ...inte
 	if expected != actual {
 		return Fail(t, fmt.Sprintf("Error message not equal:\n"+
 			"expected: %q\n"+
-			"actual  : %q", expected, actual), msgAndArgs...)
+			"actual  : %s", expected, truncatingFormat("%q", actual)), msgAndArgs...)
 	}
 	return true
 }
 
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContains asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	assert.ErrorContains(t, err,  expectedErrorSubString)
@@ -1694,7 +1701,7 @@ func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...in
 
 	actual := theError.Error()
 	if !strings.Contains(actual, contains) {
-		return Fail(t, fmt.Sprintf("Error %#v does not contain %#v", actual, contains), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Error %s does not contain %#v", truncatingFormat("%#v", actual), contains), msgAndArgs...)
 	}
 
 	return true
@@ -1760,7 +1767,7 @@ func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool {
 		h.Helper()
 	}
 	if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) {
-		return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...)
+		return Fail(t, fmt.Sprintf("Should be zero, but was %s", truncatingFormat("%v", i)), msgAndArgs...)
 	}
 	return true
 }
@@ -1874,7 +1881,19 @@ func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{
 	return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...)
 }
 
-// YAMLEq asserts that two YAML strings are equivalent.
+// YAMLEq asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	assert.YAMLEq(t, expected, actual)
 func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -2188,8 +2207,8 @@ func ErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
 	chain := buildErrorChainString(err, false)
 
 	return Fail(t, fmt.Sprintf("Target error should be in err chain:\n"+
-		"expected: %q\n"+
-		"in chain: %s", expectedText, chain,
+		"expected: %s\n"+
+		"in chain: %s", truncatingFormat("%q", expectedText), truncatingFormat("%s", chain),
 	), msgAndArgs...)
 }
 
@@ -2211,8 +2230,8 @@ func NotErrorIs(t TestingT, err, target error, msgAndArgs ...interface{}) bool {
 	chain := buildErrorChainString(err, false)
 
 	return Fail(t, fmt.Sprintf("Target error should not be in err chain:\n"+
-		"found: %q\n"+
-		"in chain: %s", expectedText, chain,
+		"found: %s\n"+
+		"in chain: %s", truncatingFormat("%q", expectedText), truncatingFormat("%s", chain),
 	), msgAndArgs...)
 }
 
@@ -2236,7 +2255,7 @@ func ErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interface{
 
 	return Fail(t, fmt.Sprintf("Should be in error chain:\n"+
 		"expected: %s\n"+
-		"in chain: %s", expectedType, chain,
+		"in chain: %s", expectedType, truncatingFormat("%s", chain),
 	), msgAndArgs...)
 }
 
@@ -2254,7 +2273,7 @@ func NotErrorAs(t TestingT, err error, target interface{}, msgAndArgs ...interfa
 
 	return Fail(t, fmt.Sprintf("Target error should not be in err chain:\n"+
 		"found: %s\n"+
-		"in chain: %s", reflect.TypeOf(target).Elem().String(), chain,
+		"in chain: %s", reflect.TypeOf(target).Elem().String(), truncatingFormat("%s", chain),
 	), msgAndArgs...)
 }
 
diff --git a/vendor/github.com/stretchr/testify/assert/doc.go b/vendor/github.com/stretchr/testify/assert/doc.go
index a0b953aa..c111589c 100644
--- a/vendor/github.com/stretchr/testify/assert/doc.go
+++ b/vendor/github.com/stretchr/testify/assert/doc.go
@@ -40,8 +40,8 @@
 //
 // # Assertions
 //
-// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
-// All assertion functions take, as the first argument, the `*testing.T` object provided by the
+// Assertions allow you to easily write test code, and are global funcs in the assert package.
+// All assertion functions take, as the first argument, the [*testing.T] object provided by the
 // testing framework. This allows the assertion funcs to write the failings and other details to
 // the correct place.
 //
diff --git a/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go b/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go
index 5a74c4f4..956227ca 100644
--- a/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go
+++ b/vendor/github.com/stretchr/testify/assert/yaml/yaml_custom.go
@@ -7,7 +7,7 @@
 //	go test -tags testify_yaml_custom
 //
 // This implementation can be used at build time to replace the default implementation
-// to avoid linking with [gopkg.in/yaml.v3].
+// to avoid linking with [go.yaml.in/yaml/v3].
 //
 // In your test package:
 //
diff --git a/vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go b/vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go
index 0bae80e3..dd89ac03 100644
--- a/vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go
+++ b/vendor/github.com/stretchr/testify/assert/yaml/yaml_default.go
@@ -6,7 +6,7 @@
 // indirection with an alternative implementation of this package that uses
 // another implementation of YAML deserialization. This allows to not either not
 // use YAML deserialization at all, or to use another implementation than
-// [gopkg.in/yaml.v3] (for example for license compatibility reasons, see [PR #1120]).
+// [go.yaml.in/yaml/v3] (for example for license compatibility reasons, see [PR #1120]).
 //
 // Alternative implementations are selected using build tags:
 //
@@ -28,9 +28,9 @@
 // [PR #1120]: https://github.com/stretchr/testify/pull/1120
 package yaml
 
-import goyaml "gopkg.in/yaml.v3"
+import goyaml "go.yaml.in/yaml/v3"
 
-// Unmarshal is just a wrapper of [gopkg.in/yaml.v3.Unmarshal].
+// Unmarshal is just a wrapper of [go.yaml.in/yaml/v3.Unmarshal].
 func Unmarshal(in []byte, out interface{}) error {
 	return goyaml.Unmarshal(in, out)
 }
diff --git a/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go b/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go
index 8041803f..a51d2792 100644
--- a/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go
+++ b/vendor/github.com/stretchr/testify/assert/yaml/yaml_fail.go
@@ -3,7 +3,7 @@
 // Package yaml is an implementation of YAML functions that always fail.
 //
 // This implementation can be used at build time to replace the default implementation
-// to avoid linking with [gopkg.in/yaml.v3]:
+// to avoid linking with [go.yaml.in/yaml/v3]:
 //
 //	go test -tags testify_yaml_fail
 package yaml
diff --git a/vendor/github.com/pmezard/go-difflib/LICENSE b/vendor/github.com/stretchr/testify/internal/difflib/LICENSE
similarity index 95%
rename from vendor/github.com/pmezard/go-difflib/LICENSE
rename to vendor/github.com/stretchr/testify/internal/difflib/LICENSE
index c67dad61..485be13c 100644
--- a/vendor/github.com/pmezard/go-difflib/LICENSE
+++ b/vendor/github.com/stretchr/testify/internal/difflib/LICENSE
@@ -24,4 +24,4 @@ TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/vendor/github.com/pmezard/go-difflib/difflib/difflib.go b/vendor/github.com/stretchr/testify/internal/difflib/difflib.go
similarity index 77%
rename from vendor/github.com/pmezard/go-difflib/difflib/difflib.go
rename to vendor/github.com/stretchr/testify/internal/difflib/difflib.go
index 003e99fa..9984599b 100644
--- a/vendor/github.com/pmezard/go-difflib/difflib/difflib.go
+++ b/vendor/github.com/stretchr/testify/internal/difflib/difflib.go
@@ -8,11 +8,14 @@
 //
 // - unified_diff
 //
-// - context_diff
-//
 // Getting unified diffs was the main goal of the port. Keep in mind this code
 // is mostly suitable to output text differences in a human friendly way, there
 // are no guarantees generated diffs are consumable by patch(1).
+//
+// This package was adopted from [github.com/pmezard/go-difflib] which
+// is no longer maintained.
+//
+// [github.com/pmezard/go-difflib]: https://github.com/pmezard/go-difflib
 package difflib
 
 import (
@@ -37,13 +40,6 @@ func max(a, b int) int {
 	return b
 }
 
-func calculateRatio(matches, length int) float64 {
-	if length > 0 {
-		return 2.0 * float64(matches) / float64(length)
-	}
-	return 1.0
-}
-
 type Match struct {
 	A    int
 	B    int
@@ -103,14 +99,6 @@ func NewMatcher(a, b []string) *SequenceMatcher {
 	return &m
 }
 
-func NewMatcherWithJunk(a, b []string, autoJunk bool,
-	isJunk func(string) bool) *SequenceMatcher {
-
-	m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk}
-	m.SetSeqs(a, b)
-	return &m
-}
-
 // Set two sequences to be compared.
 func (m *SequenceMatcher) SetSeqs(a, b []string) {
 	m.SetSeq1(a)
@@ -199,12 +187,15 @@ func (m *SequenceMatcher) isBJunk(s string) bool {
 // If IsJunk is not defined:
 //
 // Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where
-//     alo <= i <= i+k <= ahi
-//     blo <= j <= j+k <= bhi
+//
+//	alo <= i <= i+k <= ahi
+//	blo <= j <= j+k <= bhi
+//
 // and for all (i',j',k') meeting those conditions,
-//     k >= k'
-//     i <= i'
-//     and if i == i', j <= j'
+//
+//	k >= k'
+//	i <= i'
+//	and if i == i', j <= j'
 //
 // In other words, of all maximal matching blocks, return one that
 // starts earliest in a, and of all those maximal matching blocks that
@@ -451,66 +442,6 @@ func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode {
 	return groups
 }
 
-// Return a measure of the sequences' similarity (float in [0,1]).
-//
-// Where T is the total number of elements in both sequences, and
-// M is the number of matches, this is 2.0*M / T.
-// Note that this is 1 if the sequences are identical, and 0 if
-// they have nothing in common.
-//
-// .Ratio() is expensive to compute if you haven't already computed
-// .GetMatchingBlocks() or .GetOpCodes(), in which case you may
-// want to try .QuickRatio() or .RealQuickRation() first to get an
-// upper bound.
-func (m *SequenceMatcher) Ratio() float64 {
-	matches := 0
-	for _, m := range m.GetMatchingBlocks() {
-		matches += m.Size
-	}
-	return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() relatively quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute.
-func (m *SequenceMatcher) QuickRatio() float64 {
-	// viewing a and b as multisets, set matches to the cardinality
-	// of their intersection; this counts the number of matches
-	// without regard to order, so is clearly an upper bound
-	if m.fullBCount == nil {
-		m.fullBCount = map[string]int{}
-		for _, s := range m.b {
-			m.fullBCount[s] = m.fullBCount[s] + 1
-		}
-	}
-
-	// avail[x] is the number of times x appears in 'b' less the
-	// number of times we've seen it in 'a' so far ... kinda
-	avail := map[string]int{}
-	matches := 0
-	for _, s := range m.a {
-		n, ok := avail[s]
-		if !ok {
-			n = m.fullBCount[s]
-		}
-		avail[s] = n - 1
-		if n > 0 {
-			matches += 1
-		}
-	}
-	return calculateRatio(matches, len(m.a)+len(m.b))
-}
-
-// Return an upper bound on ratio() very quickly.
-//
-// This isn't defined beyond that it is an upper bound on .Ratio(), and
-// is faster to compute than either .Ratio() or .QuickRatio().
-func (m *SequenceMatcher) RealQuickRatio() float64 {
-	la, lb := len(m.a), len(m.b)
-	return calculateRatio(min(la, lb), la+lb)
-}
-
 // Convert range to the "ed" format
 func formatRangeUnified(start, stop int) string {
 	// Per the diff spec at http://www.unix.org/single_unix_specification/
@@ -652,117 +583,6 @@ func formatRangeContext(start, stop int) string {
 	return fmt.Sprintf("%d,%d", beginning, beginning+length-1)
 }
 
-type ContextDiff UnifiedDiff
-
-// Compare two sequences of lines; generate the delta as a context diff.
-//
-// Context diffs are a compact way of showing line changes and a few
-// lines of context. The number of context lines is set by diff.Context
-// which defaults to three.
-//
-// By default, the diff control lines (those with *** or ---) are
-// created with a trailing newline.
-//
-// For inputs that do not have trailing newlines, set the diff.Eol
-// argument to "" so that the output will be uniformly newline free.
-//
-// The context diff format normally has a header for filenames and
-// modification times.  Any or all of these may be specified using
-// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate.
-// The modification times are normally expressed in the ISO 8601 format.
-// If not specified, the strings default to blanks.
-func WriteContextDiff(writer io.Writer, diff ContextDiff) error {
-	buf := bufio.NewWriter(writer)
-	defer buf.Flush()
-	var diffErr error
-	wf := func(format string, args ...interface{}) {
-		_, err := buf.WriteString(fmt.Sprintf(format, args...))
-		if diffErr == nil && err != nil {
-			diffErr = err
-		}
-	}
-	ws := func(s string) {
-		_, err := buf.WriteString(s)
-		if diffErr == nil && err != nil {
-			diffErr = err
-		}
-	}
-
-	if len(diff.Eol) == 0 {
-		diff.Eol = "\n"
-	}
-
-	prefix := map[byte]string{
-		'i': "+ ",
-		'd': "- ",
-		'r': "! ",
-		'e': "  ",
-	}
-
-	started := false
-	m := NewMatcher(diff.A, diff.B)
-	for _, g := range m.GetGroupedOpCodes(diff.Context) {
-		if !started {
-			started = true
-			fromDate := ""
-			if len(diff.FromDate) > 0 {
-				fromDate = "\t" + diff.FromDate
-			}
-			toDate := ""
-			if len(diff.ToDate) > 0 {
-				toDate = "\t" + diff.ToDate
-			}
-			if diff.FromFile != "" || diff.ToFile != "" {
-				wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol)
-				wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol)
-			}
-		}
-
-		first, last := g[0], g[len(g)-1]
-		ws("***************" + diff.Eol)
-
-		range1 := formatRangeContext(first.I1, last.I2)
-		wf("*** %s ****%s", range1, diff.Eol)
-		for _, c := range g {
-			if c.Tag == 'r' || c.Tag == 'd' {
-				for _, cc := range g {
-					if cc.Tag == 'i' {
-						continue
-					}
-					for _, line := range diff.A[cc.I1:cc.I2] {
-						ws(prefix[cc.Tag] + line)
-					}
-				}
-				break
-			}
-		}
-
-		range2 := formatRangeContext(first.J1, last.J2)
-		wf("--- %s ----%s", range2, diff.Eol)
-		for _, c := range g {
-			if c.Tag == 'r' || c.Tag == 'i' {
-				for _, cc := range g {
-					if cc.Tag == 'd' {
-						continue
-					}
-					for _, line := range diff.B[cc.J1:cc.J2] {
-						ws(prefix[cc.Tag] + line)
-					}
-				}
-				break
-			}
-		}
-	}
-	return diffErr
-}
-
-// Like WriteContextDiff but returns the diff a string.
-func GetContextDiffString(diff ContextDiff) (string, error) {
-	w := &bytes.Buffer{}
-	err := WriteContextDiff(w, diff)
-	return string(w.Bytes()), err
-}
-
 // Split a string on "\n" while preserving them. The output can be used
 // as input for UnifiedDiff and ContextDiff structures.
 func SplitLines(s string) []string {
diff --git a/vendor/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/stretchr/testify/internal/spew/LICENSE
similarity index 100%
rename from vendor/github.com/davecgh/go-spew/LICENSE
rename to vendor/github.com/stretchr/testify/internal/spew/LICENSE
diff --git a/vendor/github.com/stretchr/testify/internal/spew/README.md b/vendor/github.com/stretchr/testify/internal/spew/README.md
new file mode 100644
index 00000000..51a909e2
--- /dev/null
+++ b/vendor/github.com/stretchr/testify/internal/spew/README.md
@@ -0,0 +1,12 @@
+go-spew
+=======
+
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+
+Go-spew implements a deep pretty printer for Go data structures to aid in
+debugging.  A comprehensive suite of tests with 100% test coverage is provided
+to ensure proper functionality.
+
+## License
+
+Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License.
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/stretchr/testify/internal/spew/bypass.go
similarity index 98%
rename from vendor/github.com/davecgh/go-spew/spew/bypass.go
rename to vendor/github.com/stretchr/testify/internal/spew/bypass.go
index 79299478..70ddeaad 100644
--- a/vendor/github.com/davecgh/go-spew/spew/bypass.go
+++ b/vendor/github.com/stretchr/testify/internal/spew/bypass.go
@@ -18,6 +18,7 @@
 // tag is deprecated and thus should not be used.
 // Go versions prior to 1.4 are disabled because they use a different layout
 // for interfaces which make the implementation of unsafeReflectValue more complex.
+//go:build !js && !appengine && !safe && !disableunsafe && go1.4
 // +build !js,!appengine,!safe,!disableunsafe,go1.4
 
 package spew
diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/stretchr/testify/internal/spew/bypasssafe.go
similarity index 96%
rename from vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
rename to vendor/github.com/stretchr/testify/internal/spew/bypasssafe.go
index 205c28d6..5e2d890d 100644
--- a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
+++ b/vendor/github.com/stretchr/testify/internal/spew/bypasssafe.go
@@ -16,6 +16,7 @@
 // when the code is running on Google App Engine, compiled by GopherJS, or
 // "-tags safe" is added to the go build command line.  The "disableunsafe"
 // tag is deprecated and thus should not be used.
+//go:build js || appengine || safe || disableunsafe || !go1.4
 // +build js appengine safe disableunsafe !go1.4
 
 package spew
diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/stretchr/testify/internal/spew/common.go
similarity index 100%
rename from vendor/github.com/davecgh/go-spew/spew/common.go
rename to vendor/github.com/stretchr/testify/internal/spew/common.go
diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/stretchr/testify/internal/spew/config.go
similarity index 95%
rename from vendor/github.com/davecgh/go-spew/spew/config.go
rename to vendor/github.com/stretchr/testify/internal/spew/config.go
index 2e3d22f3..161895fc 100644
--- a/vendor/github.com/davecgh/go-spew/spew/config.go
+++ b/vendor/github.com/stretchr/testify/internal/spew/config.go
@@ -254,15 +254,15 @@ pointer addresses used to indirect to the final value.  It provides the
 following features over the built-in printing facilities provided by the fmt
 package:
 
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
+  - Pointers are dereferenced and followed
+  - Circular data structures are detected and handled properly
+  - Custom Stringer/error interfaces are optionally invoked, including
+    on unexported types
+  - Custom types which only implement the Stringer/error interfaces via
+    a pointer receiver are optionally invoked when passing non-pointer
+    variables
+  - Byte arrays and slices are dumped like the hexdump -C command which
+    includes offsets, byte values in hex, and ASCII output
 
 The configuration options are controlled by modifying the public members
 of c.  See ConfigState for options documentation.
@@ -295,12 +295,12 @@ func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{})
 
 // NewDefaultConfig returns a ConfigState with the following default settings.
 //
-// 	Indent: " "
-// 	MaxDepth: 0
-// 	DisableMethods: false
-// 	DisablePointerMethods: false
-// 	ContinueOnMethod: false
-// 	SortKeys: false
+//	Indent: " "
+//	MaxDepth: 0
+//	DisableMethods: false
+//	DisablePointerMethods: false
+//	ContinueOnMethod: false
+//	SortKeys: false
 func NewDefaultConfig() *ConfigState {
 	return &ConfigState{Indent: " "}
 }
diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/stretchr/testify/internal/spew/doc.go
similarity index 65%
rename from vendor/github.com/davecgh/go-spew/spew/doc.go
rename to vendor/github.com/stretchr/testify/internal/spew/doc.go
index aacaac6f..722e9aa7 100644
--- a/vendor/github.com/davecgh/go-spew/spew/doc.go
+++ b/vendor/github.com/stretchr/testify/internal/spew/doc.go
@@ -21,35 +21,36 @@ debugging.
 A quick overview of the additional features spew provides over the built-in
 printing facilities for Go data types are as follows:
 
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output (only when using
-	  Dump style)
+  - Pointers are dereferenced and followed
+  - Circular data structures are detected and handled properly
+  - Custom Stringer/error interfaces are optionally invoked, including
+    on unexported types
+  - Custom types which only implement the Stringer/error interfaces via
+    a pointer receiver are optionally invoked when passing non-pointer
+    variables
+  - Byte arrays and slices are dumped like the hexdump -C command which
+    includes offsets, byte values in hex, and ASCII output (only when using
+    Dump style)
 
 There are two different approaches spew allows for dumping Go data structures:
 
-	* Dump style which prints with newlines, customizable indentation,
-	  and additional debug information such as types and all pointer addresses
-	  used to indirect to the final value
-	* A custom Formatter interface that integrates cleanly with the standard fmt
-	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
-	  similar to the default %v while providing the additional functionality
-	  outlined above and passing unsupported format verbs such as %x and %q
-	  along to fmt
+  - Dump style which prints with newlines, customizable indentation,
+    and additional debug information such as types and all pointer addresses
+    used to indirect to the final value
+  - A custom Formatter interface that integrates cleanly with the standard fmt
+    package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+    similar to the default %v while providing the additional functionality
+    outlined above and passing unsupported format verbs such as %x and %q
+    along to fmt
 
-Quick Start
+# Quick Start
 
 This section demonstrates how to quickly get started with spew.  See the
 sections below for further details on formatting and configuration options.
 
 To dump a variable with full newlines, indentation, type, and pointer
 information use Dump, Fdump, or Sdump:
+
 	spew.Dump(myVar1, myVar2, ...)
 	spew.Fdump(someWriter, myVar1, myVar2, ...)
 	str := spew.Sdump(myVar1, myVar2, ...)
@@ -58,12 +59,13 @@ Alternatively, if you would prefer to use format strings with a compacted inline
 printing style, use the convenience wrappers Printf, Fprintf, etc with
 %v (most compact), %+v (adds pointer addresses), %#v (adds types), or
 %#+v (adds types and pointer addresses):
+
 	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
 	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
 	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
 	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
 
-Configuration Options
+# Configuration Options
 
 Configuration of spew is handled by fields in the ConfigState type.  For
 convenience, all of the top-level functions use a global state available
@@ -74,51 +76,52 @@ equivalent to the top-level functions.  This allows concurrent configuration
 options.  See the ConfigState documentation for more details.
 
 The following configuration options are available:
-	* Indent
-		String to use for each indentation level for Dump functions.
-		It is a single space by default.  A popular alternative is "\t".
-
-	* MaxDepth
-		Maximum number of levels to descend into nested data structures.
-		There is no limit by default.
-
-	* DisableMethods
-		Disables invocation of error and Stringer interface methods.
-		Method invocation is enabled by default.
-
-	* DisablePointerMethods
-		Disables invocation of error and Stringer interface methods on types
-		which only accept pointer receivers from non-pointer variables.
-		Pointer method invocation is enabled by default.
-
-	* DisablePointerAddresses
-		DisablePointerAddresses specifies whether to disable the printing of
-		pointer addresses. This is useful when diffing data structures in tests.
-
-	* DisableCapacities
-		DisableCapacities specifies whether to disable the printing of
-		capacities for arrays, slices, maps and channels. This is useful when
-		diffing data structures in tests.
-
-	* ContinueOnMethod
-		Enables recursion into types after invoking error and Stringer interface
-		methods. Recursion after method invocation is disabled by default.
-
-	* SortKeys
-		Specifies map keys should be sorted before being printed. Use
-		this to have a more deterministic, diffable output.  Note that
-		only native types (bool, int, uint, floats, uintptr and string)
-		and types which implement error or Stringer interfaces are
-		supported with other types sorted according to the
-		reflect.Value.String() output which guarantees display
-		stability.  Natural map order is used by default.
-
-	* SpewKeys
-		Specifies that, as a last resort attempt, map keys should be
-		spewed to strings and sorted by those strings.  This is only
-		considered if SortKeys is true.
-
-Dump Usage
+
+  - Indent
+    String to use for each indentation level for Dump functions.
+    It is a single space by default.  A popular alternative is "\t".
+
+  - MaxDepth
+    Maximum number of levels to descend into nested data structures.
+    There is no limit by default.
+
+  - DisableMethods
+    Disables invocation of error and Stringer interface methods.
+    Method invocation is enabled by default.
+
+  - DisablePointerMethods
+    Disables invocation of error and Stringer interface methods on types
+    which only accept pointer receivers from non-pointer variables.
+    Pointer method invocation is enabled by default.
+
+  - DisablePointerAddresses
+    DisablePointerAddresses specifies whether to disable the printing of
+    pointer addresses. This is useful when diffing data structures in tests.
+
+  - DisableCapacities
+    DisableCapacities specifies whether to disable the printing of
+    capacities for arrays, slices, maps and channels. This is useful when
+    diffing data structures in tests.
+
+  - ContinueOnMethod
+    Enables recursion into types after invoking error and Stringer interface
+    methods. Recursion after method invocation is disabled by default.
+
+  - SortKeys
+    Specifies map keys should be sorted before being printed. Use
+    this to have a more deterministic, diffable output.  Note that
+    only native types (bool, int, uint, floats, uintptr and string)
+    and types which implement error or Stringer interfaces are
+    supported with other types sorted according to the
+    reflect.Value.String() output which guarantees display
+    stability.  Natural map order is used by default.
+
+  - SpewKeys
+    Specifies that, as a last resort attempt, map keys should be
+    spewed to strings and sorted by those strings.  This is only
+    considered if SortKeys is true.
+
+# Dump Usage
 
 Simply call spew.Dump with a list of variables you want to dump:
 
@@ -133,7 +136,7 @@ A third option is to call spew.Sdump to get the formatted output as a string:
 
 	str := spew.Sdump(myVar1, myVar2, ...)
 
-Sample Dump Output
+# Sample Dump Output
 
 See the Dump example for details on the setup of the types and variables being
 shown here.
@@ -150,13 +153,14 @@ shown here.
 
 Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
 command as shown.
+
 	([]uint8) (len=32 cap=32) {
 	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
 	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
 	 00000020  31 32                                             |12|
 	}
 
-Custom Formatter
+# Custom Formatter
 
 Spew provides a custom formatter that implements the fmt.Formatter interface
 so that it integrates cleanly with standard fmt package printing functions. The
@@ -170,7 +174,7 @@ standard fmt package for formatting.  In addition, the custom formatter ignores
 the width and precision arguments (however they will still work on the format
 specifiers not handled by the custom formatter).
 
-Custom Formatter Usage
+# Custom Formatter Usage
 
 The simplest way to make use of the spew custom formatter is to call one of the
 convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
@@ -184,15 +188,17 @@ functions have syntax you are most likely already familiar with:
 
 See the Index for the full list convenience functions.
 
-Sample Formatter Output
+# Sample Formatter Output
 
 Double pointer to a uint8:
+
 	  %v: <**>5
 	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
 	 %#v: (**uint8)5
 	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
 
 Pointer to circular struct with a uint8 field and a pointer to itself:
+
 	  %v: <*>{1 <*><shown>}
 	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
 	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
@@ -201,7 +207,7 @@ Pointer to circular struct with a uint8 field and a pointer to itself:
 See the Printf example for details on the setup of variables being shown
 here.
 
-Errors
+# Errors
 
 Since it is possible for custom Stringer/error interfaces to panic, spew
 detects them and handles them internally by printing the panic information
diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/stretchr/testify/internal/spew/dump.go
similarity index 96%
rename from vendor/github.com/davecgh/go-spew/spew/dump.go
rename to vendor/github.com/stretchr/testify/internal/spew/dump.go
index f78d89fc..8323041a 100644
--- a/vendor/github.com/davecgh/go-spew/spew/dump.go
+++ b/vendor/github.com/stretchr/testify/internal/spew/dump.go
@@ -488,15 +488,15 @@ pointer addresses used to indirect to the final value.  It provides the
 following features over the built-in printing facilities provided by the fmt
 package:
 
-	* Pointers are dereferenced and followed
-	* Circular data structures are detected and handled properly
-	* Custom Stringer/error interfaces are optionally invoked, including
-	  on unexported types
-	* Custom types which only implement the Stringer/error interfaces via
-	  a pointer receiver are optionally invoked when passing non-pointer
-	  variables
-	* Byte arrays and slices are dumped like the hexdump -C command which
-	  includes offsets, byte values in hex, and ASCII output
+  - Pointers are dereferenced and followed
+  - Circular data structures are detected and handled properly
+  - Custom Stringer/error interfaces are optionally invoked, including
+    on unexported types
+  - Custom types which only implement the Stringer/error interfaces via
+    a pointer receiver are optionally invoked when passing non-pointer
+    variables
+  - Byte arrays and slices are dumped like the hexdump -C command which
+    includes offsets, byte values in hex, and ASCII output
 
 The configuration options are controlled by an exported package global,
 spew.Config.  See ConfigState for options documentation.
diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/stretchr/testify/internal/spew/format.go
similarity index 100%
rename from vendor/github.com/davecgh/go-spew/spew/format.go
rename to vendor/github.com/stretchr/testify/internal/spew/format.go
diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/stretchr/testify/internal/spew/spew.go
similarity index 100%
rename from vendor/github.com/davecgh/go-spew/spew/spew.go
rename to vendor/github.com/stretchr/testify/internal/spew/spew.go
diff --git a/vendor/github.com/stretchr/testify/require/doc.go b/vendor/github.com/stretchr/testify/require/doc.go
index c8e3f94a..ee84cc47 100644
--- a/vendor/github.com/stretchr/testify/require/doc.go
+++ b/vendor/github.com/stretchr/testify/require/doc.go
@@ -1,4 +1,4 @@
-// Package require implements the same assertions as the `assert` package but
+// Package require implements the same assertions as the assert package but
 // stops test execution when a test fails.
 //
 // # Example Usage
@@ -21,8 +21,8 @@
 //
 // # Assertions
 //
-// The `require` package have same global functions as in the `assert` package,
-// but instead of returning a boolean result they call `t.FailNow()`.
+// The require package have same global functions as in the assert package,
+// but instead of returning a boolean result they call [testing.T.FailNow].
 // A consequence of this is that it must be called from the goroutine running
 // the test function, not from other goroutines created during the test.
 //
diff --git a/vendor/github.com/stretchr/testify/require/require.go b/vendor/github.com/stretchr/testify/require/require.go
index 2d02f9bc..652871f2 100644
--- a/vendor/github.com/stretchr/testify/require/require.go
+++ b/vendor/github.com/stretchr/testify/require/require.go
@@ -180,7 +180,7 @@ func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...i
 	t.FailNow()
 }
 
-// EqualError asserts that a function returned an error (i.e. not `nil`)
+// EqualError asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -195,7 +195,7 @@ func EqualError(t TestingT, theError error, errString string, msgAndArgs ...inte
 	t.FailNow()
 }
 
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// EqualErrorf asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -295,7 +295,7 @@ func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, ar
 	t.FailNow()
 }
 
-// Error asserts that a function returned an error (i.e. not `nil`).
+// Error asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	require.Error(t, err)
@@ -333,8 +333,8 @@ func ErrorAsf(t TestingT, err error, target interface{}, msg string, args ...int
 	t.FailNow()
 }
 
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContains asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	require.ErrorContains(t, err,  expectedErrorSubString)
@@ -348,8 +348,8 @@ func ErrorContains(t TestingT, theError error, contains string, msgAndArgs ...in
 	t.FailNow()
 }
 
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContainsf asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	require.ErrorContainsf(t, err,  expectedErrorSubString, "error message %s", "formatted")
@@ -387,7 +387,7 @@ func ErrorIsf(t TestingT, err error, target error, msg string, args ...interface
 	t.FailNow()
 }
 
-// Errorf asserts that a function returned an error (i.e. not `nil`).
+// Errorf asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	require.Errorf(t, err, "error message %s", "formatted")
@@ -429,7 +429,7 @@ func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick t
 //		time.Sleep(8*time.Second)
 //		externalValue = true
 //	}()
-//	require.EventuallyWithT(t, func(c *require.CollectT) {
+//	require.EventuallyWithT(t, func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		require.True(c, externalValue, "expected 'externalValue' to be true")
 //	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
@@ -457,10 +457,10 @@ func EventuallyWithT(t TestingT, condition func(collect *assert.CollectT), waitF
 //		time.Sleep(8*time.Second)
 //		externalValue = true
 //	}()
-//	require.EventuallyWithTf(t, func(c *require.CollectT, "error message %s", "formatted") {
+//	require.EventuallyWithTf(t, func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		require.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 10*time.Second, 1*time.Second, "error message %s", "formatted")
 func EventuallyWithTf(t TestingT, condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -671,8 +671,6 @@ func Greaterf(t TestingT, e1 interface{}, e2 interface{}, msg string, args ...in
 // body that contains a string.
 //
 //	require.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -687,8 +685,6 @@ func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url s
 // body that contains a string.
 //
 //	require.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -703,8 +699,6 @@ func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url
 // body that does not contain a string.
 //
 //	require.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -719,8 +713,6 @@ func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, ur
 // body that does not contain a string.
 //
 //	require.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -734,8 +726,6 @@ func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, u
 // HTTPError asserts that a specified handler returns an error status code.
 //
 //	require.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -749,8 +739,6 @@ func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string,
 // HTTPErrorf asserts that a specified handler returns an error status code.
 //
 //	require.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -764,8 +752,6 @@ func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string,
 // HTTPRedirect asserts that a specified handler returns a redirect status code.
 //
 //	require.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -779,8 +765,6 @@ func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url strin
 // HTTPRedirectf asserts that a specified handler returns a redirect status code.
 //
 //	require.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -794,8 +778,6 @@ func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url stri
 // HTTPStatusCode asserts that a specified handler returns a specified status code.
 //
 //	require.HTTPStatusCode(t, myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -809,8 +791,6 @@ func HTTPStatusCode(t TestingT, handler http.HandlerFunc, method string, url str
 // HTTPStatusCodef asserts that a specified handler returns a specified status code.
 //
 //	require.HTTPStatusCodef(t, myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -824,8 +804,6 @@ func HTTPStatusCodef(t TestingT, handler http.HandlerFunc, method string, url st
 // HTTPSuccess asserts that a specified handler returns a success status code.
 //
 //	require.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -839,8 +817,6 @@ func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string
 // HTTPSuccessf asserts that a specified handler returns a success status code.
 //
 //	require.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -1385,12 +1361,11 @@ func NoDirExistsf(t TestingT, path string, msg string, args ...interface{}) {
 	t.FailNow()
 }
 
-// NoError asserts that a function returned no error (i.e. `nil`).
+// NoError asserts that a function returned a nil error (ie. no error).
 //
-//	  actualObj, err := SomeFunction()
-//	  if require.NoError(t, err) {
-//		   require.Equal(t, expectedObj, actualObj)
-//	  }
+//	actualObj, err := SomeFunction()
+//	require.NoError(t, err)
+//	require.Equal(t, expectedObj, actualObj)
 func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -1401,12 +1376,11 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) {
 	t.FailNow()
 }
 
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
+// NoErrorf asserts that a function returned a nil error (ie. no error).
 //
-//	  actualObj, err := SomeFunction()
-//	  if require.NoErrorf(t, err, "error message %s", "formatted") {
-//		   require.Equal(t, expectedObj, actualObj)
-//	  }
+//	actualObj, err := SomeFunction()
+//	require.NoErrorf(t, err, "error message %s", "formatted")
+//	require.Equal(t, expectedObj, actualObj)
 func NoErrorf(t TestingT, err error, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -1515,9 +1489,8 @@ func NotElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg str
 
 // NotEmpty asserts that the specified object is NOT [Empty].
 //
-//	if require.NotEmpty(t, obj) {
-//	  require.Equal(t, "two", obj[1])
-//	}
+//	require.NotEmpty(t, obj)
+//	require.Equal(t, "two", obj[1])
 func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -1530,9 +1503,8 @@ func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) {
 
 // NotEmptyf asserts that the specified object is NOT [Empty].
 //
-//	if require.NotEmptyf(t, obj, "error message %s", "formatted") {
-//	  require.Equal(t, "two", obj[1])
-//	}
+//	require.NotEmptyf(t, obj, "error message %s", "formatted")
+//	require.Equal(t, "two", obj[1])
 func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -2135,7 +2107,19 @@ func WithinRangef(t TestingT, actual time.Time, start time.Time, end time.Time,
 	t.FailNow()
 }
 
-// YAMLEq asserts that two YAML strings are equivalent.
+// YAMLEq asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	require.YAMLEq(t, expected, actual)
 func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
@@ -2146,7 +2130,19 @@ func YAMLEq(t TestingT, expected string, actual string, msgAndArgs ...interface{
 	t.FailNow()
 }
 
-// YAMLEqf asserts that two YAML strings are equivalent.
+// YAMLEqf asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	require.YAMLEqf(t, expected, actual, "error message %s", "formatted")
 func YAMLEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) {
 	if h, ok := t.(tHelper); ok {
 		h.Helper()
diff --git a/vendor/github.com/stretchr/testify/require/require.go.tmpl b/vendor/github.com/stretchr/testify/require/require.go.tmpl
index 8b328368..6a975501 100644
--- a/vendor/github.com/stretchr/testify/require/require.go.tmpl
+++ b/vendor/github.com/stretchr/testify/require/require.go.tmpl
@@ -1,4 +1,4 @@
-{{ replace .Comment "assert." "require."}}
+{{.CommentRequire}}
 func {{.DocInfo.Name}}(t TestingT, {{.Params}}) {
 	if h, ok := t.(tHelper); ok { h.Helper() }
 	if assert.{{.DocInfo.Name}}(t, {{.ForwardedParams}}) { return }
diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go b/vendor/github.com/stretchr/testify/require/require_forward.go
index e6f7e944..edac147e 100644
--- a/vendor/github.com/stretchr/testify/require/require_forward.go
+++ b/vendor/github.com/stretchr/testify/require/require_forward.go
@@ -147,7 +147,7 @@ func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs
 	Equal(a.t, expected, actual, msgAndArgs...)
 }
 
-// EqualError asserts that a function returned an error (i.e. not `nil`)
+// EqualError asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -159,7 +159,7 @@ func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...
 	EqualError(a.t, theError, errString, msgAndArgs...)
 }
 
-// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// EqualErrorf asserts that a function returned a non-nil error (i.e. an error)
 // and that it is equal to the provided error.
 //
 //	actualObj, err := SomeFunction()
@@ -241,7 +241,7 @@ func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string
 	Equalf(a.t, expected, actual, msg, args...)
 }
 
-// Error asserts that a function returned an error (i.e. not `nil`).
+// Error asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	a.Error(err)
@@ -270,8 +270,8 @@ func (a *Assertions) ErrorAsf(err error, target interface{}, msg string, args ..
 	ErrorAsf(a.t, err, target, msg, args...)
 }
 
-// ErrorContains asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContains asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	a.ErrorContains(err,  expectedErrorSubString)
@@ -282,8 +282,8 @@ func (a *Assertions) ErrorContains(theError error, contains string, msgAndArgs .
 	ErrorContains(a.t, theError, contains, msgAndArgs...)
 }
 
-// ErrorContainsf asserts that a function returned an error (i.e. not `nil`)
-// and that the error contains the specified substring.
+// ErrorContainsf asserts that a function returned a non-nil error (i.e. an
+// error) and that the error contains the specified substring.
 //
 //	actualObj, err := SomeFunction()
 //	a.ErrorContainsf(err,  expectedErrorSubString, "error message %s", "formatted")
@@ -312,7 +312,7 @@ func (a *Assertions) ErrorIsf(err error, target error, msg string, args ...inter
 	ErrorIsf(a.t, err, target, msg, args...)
 }
 
-// Errorf asserts that a function returned an error (i.e. not `nil`).
+// Errorf asserts that a function returned a non-nil error (ie. an error).
 //
 //	actualObj, err := SomeFunction()
 //	a.Errorf(err, "error message %s", "formatted")
@@ -373,10 +373,10 @@ func (a *Assertions) EventuallyWithT(condition func(collect *assert.CollectT), w
 //		time.Sleep(8*time.Second)
 //		externalValue = true
 //	}()
-//	a.EventuallyWithTf(func(c *assert.CollectT, "error message %s", "formatted") {
+//	a.EventuallyWithTf(func(c *assert.CollectT) {
 //		// add assertions as needed; any assertion failure will fail the current tick
 //		assert.True(c, externalValue, "expected 'externalValue' to be true")
-//	}, 10*time.Second, 1*time.Second, "external state has not changed to 'true'; still false")
+//	}, 10*time.Second, 1*time.Second, "error message %s", "formatted")
 func (a *Assertions) EventuallyWithTf(condition func(collect *assert.CollectT), waitFor time.Duration, tick time.Duration, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -539,8 +539,6 @@ func (a *Assertions) Greaterf(e1 interface{}, e2 interface{}, msg string, args .
 // body that contains a string.
 //
 //	a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -552,8 +550,6 @@ func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, u
 // body that contains a string.
 //
 //	a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -565,8 +561,6 @@ func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string,
 // body that does not contain a string.
 //
 //	a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -578,8 +572,6 @@ func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string
 // body that does not contain a string.
 //
 //	a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -590,8 +582,6 @@ func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method strin
 // HTTPError asserts that a specified handler returns an error status code.
 //
 //	a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -602,8 +592,6 @@ func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url stri
 // HTTPErrorf asserts that a specified handler returns an error status code.
 //
 //	a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -614,8 +602,6 @@ func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url str
 // HTTPRedirect asserts that a specified handler returns a redirect status code.
 //
 //	a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -626,8 +612,6 @@ func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url s
 // HTTPRedirectf asserts that a specified handler returns a redirect status code.
 //
 //	a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -638,8 +622,6 @@ func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url
 // HTTPStatusCode asserts that a specified handler returns a specified status code.
 //
 //	a.HTTPStatusCode(myHandler, "GET", "/notImplemented", nil, 501)
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -650,8 +632,6 @@ func (a *Assertions) HTTPStatusCode(handler http.HandlerFunc, method string, url
 // HTTPStatusCodef asserts that a specified handler returns a specified status code.
 //
 //	a.HTTPStatusCodef(myHandler, "GET", "/notImplemented", nil, 501, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, url string, values url.Values, statuscode int, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -662,8 +642,6 @@ func (a *Assertions) HTTPStatusCodef(handler http.HandlerFunc, method string, ur
 // HTTPSuccess asserts that a specified handler returns a success status code.
 //
 //	a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -674,8 +652,6 @@ func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url st
 // HTTPSuccessf asserts that a specified handler returns a success status code.
 //
 //	a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
-//
-// Returns whether the assertion was successful (true) or not (false).
 func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1097,12 +1073,11 @@ func (a *Assertions) NoDirExistsf(path string, msg string, args ...interface{})
 	NoDirExistsf(a.t, path, msg, args...)
 }
 
-// NoError asserts that a function returned no error (i.e. `nil`).
+// NoError asserts that a function returned a nil error (ie. no error).
 //
-//	  actualObj, err := SomeFunction()
-//	  if a.NoError(err) {
-//		   assert.Equal(t, expectedObj, actualObj)
-//	  }
+//	actualObj, err := SomeFunction()
+//	a.NoError(err)
+//	a.Equal(expectedObj, actualObj)
 func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1110,12 +1085,11 @@ func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) {
 	NoError(a.t, err, msgAndArgs...)
 }
 
-// NoErrorf asserts that a function returned no error (i.e. `nil`).
+// NoErrorf asserts that a function returned a nil error (ie. no error).
 //
-//	  actualObj, err := SomeFunction()
-//	  if a.NoErrorf(err, "error message %s", "formatted") {
-//		   assert.Equal(t, expectedObj, actualObj)
-//	  }
+//	actualObj, err := SomeFunction()
+//	a.NoErrorf(err, "error message %s", "formatted")
+//	a.Equal(expectedObj, actualObj)
 func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1203,9 +1177,8 @@ func (a *Assertions) NotElementsMatchf(listA interface{}, listB interface{}, msg
 
 // NotEmpty asserts that the specified object is NOT [Empty].
 //
-//	if a.NotEmpty(obj) {
-//	  assert.Equal(t, "two", obj[1])
-//	}
+//	a.NotEmpty(obj)
+//	a.Equal("two", obj[1])
 func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1215,9 +1188,8 @@ func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) {
 
 // NotEmptyf asserts that the specified object is NOT [Empty].
 //
-//	if a.NotEmptyf(obj, "error message %s", "formatted") {
-//	  assert.Equal(t, "two", obj[1])
-//	}
+//	a.NotEmptyf(obj, "error message %s", "formatted")
+//	a.Equal("two", obj[1])
 func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1691,7 +1663,19 @@ func (a *Assertions) WithinRangef(actual time.Time, start time.Time, end time.Ti
 	WithinRangef(a.t, actual, start, end, msg, args...)
 }
 
-// YAMLEq asserts that two YAML strings are equivalent.
+// YAMLEq asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	a.YAMLEq(expected, actual)
 func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
@@ -1699,7 +1683,19 @@ func (a *Assertions) YAMLEq(expected string, actual string, msgAndArgs ...interf
 	YAMLEq(a.t, expected, actual, msgAndArgs...)
 }
 
-// YAMLEqf asserts that two YAML strings are equivalent.
+// YAMLEqf asserts that the first documents in the two YAML strings are equivalent.
+//
+//	expected := `---
+//	key: value
+//	---
+//	key: this is a second document, it is not evaluated
+//	`
+//	actual := `---
+//	key: value
+//	---
+//	key: this is a subsequent document, it is not evaluated
+//	`
+//	a.YAMLEqf(expected, actual, "error message %s", "formatted")
 func (a *Assertions) YAMLEqf(expected string, actual string, msg string, args ...interface{}) {
 	if h, ok := a.t.(tHelper); ok {
 		h.Helper()
diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl b/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl
index 54124df1..b3b751de 100644
--- a/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl
+++ b/vendor/github.com/stretchr/testify/require/require_forward.go.tmpl
@@ -1,4 +1,4 @@
-{{.CommentWithoutT "a"}}
+{{.CommentRequireWithoutT "a"}}
 func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) {
 	if h, ok := a.t.(tHelper); ok { h.Helper() }
 	{{.DocInfo.Name}}(a.t, {{.ForwardedParams}})
diff --git a/vendor/github.com/stretchr/testify/require/requirements.go b/vendor/github.com/stretchr/testify/require/requirements.go
index 6b7ce929..375adb0a 100644
--- a/vendor/github.com/stretchr/testify/require/requirements.go
+++ b/vendor/github.com/stretchr/testify/require/requirements.go
@@ -12,18 +12,18 @@ type tHelper = interface {
 
 // ComparisonAssertionFunc is a common function prototype when comparing two values.  Can be useful
 // for table driven tests.
-type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{})
+type ComparisonAssertionFunc = func(TestingT, interface{}, interface{}, ...interface{})
 
 // ValueAssertionFunc is a common function prototype when validating a single value.  Can be useful
 // for table driven tests.
-type ValueAssertionFunc func(TestingT, interface{}, ...interface{})
+type ValueAssertionFunc = func(TestingT, interface{}, ...interface{})
 
 // BoolAssertionFunc is a common function prototype when validating a bool value.  Can be useful
 // for table driven tests.
-type BoolAssertionFunc func(TestingT, bool, ...interface{})
+type BoolAssertionFunc = func(TestingT, bool, ...interface{})
 
 // ErrorAssertionFunc is a common function prototype when validating an error value.  Can be useful
 // for table driven tests.
-type ErrorAssertionFunc func(TestingT, error, ...interface{})
+type ErrorAssertionFunc = func(TestingT, error, ...interface{})
 
 //go:generate sh -c "cd ../_codegen && go build && cd - && ../_codegen/_codegen -output-package=require -template=require.go.tmpl -include-format-funcs"
diff --git a/vendor/github.com/urfave/cli/v3/README.md b/vendor/github.com/urfave/cli/v3/README.md
index e04c7295..a5396e0e 100644
--- a/vendor/github.com/urfave/cli/v3/README.md
+++ b/vendor/github.com/urfave/cli/v3/README.md
@@ -28,6 +28,27 @@ command line tools in Go featuring:
 See the hosted documentation website at <https://cli.urfave.org>. Contents of
 this website are built from the [`./docs`](./docs) directory.
 
+## Build tags
+
+You can use the following build tags:
+
+### `urfave_cli_no_template`
+
+When set, the default help and fish completion are rendered without using
+`text/template`, which makes the Go linker disable dead code elimination (see
+[Binary Size](https://cli.urfave.org/v3/binary-size/#urfave_cli_no_template)).
+The output is the same, but help templates can not be customized:
+
+- `RootCommandHelpTemplate`, `CommandHelpTemplate`, `SubcommandHelpTemplate`
+  and `FishCompletionTemplate` are constants;
+- if the default help printer is used with a custom template (such as
+  `CustomRootCommandHelpTemplate` or `CustomHelpTemplate`), it panics;
+- custom template functions other than `wrap` and `wrapAt` are ignored.
+
+Replacing `cli.HelpPrinter` works as usual, except it receives `"root"`,
+`"command"` or `"subcommand"` as `templ` instead of the default template text
+(a custom template is passed as is).
+
 ## Support
 
 Check the [Q&A discussions]. If you don't find answer to your question, [create
diff --git a/vendor/github.com/urfave/cli/v3/args.go b/vendor/github.com/urfave/cli/v3/args.go
index b3acfd5c..0dad2099 100644
--- a/vendor/github.com/urfave/cli/v3/args.go
+++ b/vendor/github.com/urfave/cli/v3/args.go
@@ -77,6 +77,11 @@ type Argument interface {
 	Get() any
 }
 
+type requiredArgument interface {
+	name() string
+	required() bool
+}
+
 // AnyArguments to differentiate between no arguments(nil) vs aleast one
 var AnyArguments = []Argument{
 	&StringArgs{
@@ -89,6 +94,7 @@ type ArgumentBase[T any, C any, VC ValueCreator[T, C]] struct {
 	Value       T      `json:"value"`     // the default value of this argument
 	Destination *T     `json:"-"`         // the destination point for this argument
 	UsageText   string `json:"usageText"` // the usage text to show
+	Required    bool   `json:"required"`  // whether the argument is required or not
 	Config      C      `json:"config"`    // config for this argument similar to Flag Config
 
 	value *T
@@ -98,18 +104,33 @@ func (a *ArgumentBase[T, C, VC]) HasName(s string) bool {
 	return s == a.Name
 }
 
+func (a *ArgumentBase[T, C, VC]) name() string {
+	return a.Name
+}
+
+func (a *ArgumentBase[T, C, VC]) required() bool {
+	return a.Required
+}
+
 func (a *ArgumentBase[T, C, VC]) Usage() string {
 	if a.UsageText != "" {
 		return a.UsageText
 	}
 
-	usageFormat := "%[1]s"
+	usageFormat := "[%[1]s]"
+	if a.Required {
+		usageFormat = "%[1]s"
+	}
 	return fmt.Sprintf(usageFormat, a.Name)
 }
 
 func (a *ArgumentBase[T, C, VC]) Parse(s []string) ([]string, error) {
 	tracef("calling arg%[1] parse with args %[2]", a.Name, s)
 
+	if a.Required && len(s) == 0 {
+		return s, &errRequiredArguments{missingArguments: []string{a.Name}}
+	}
+
 	var vc VC
 	var t T
 	value := vc.Create(a.Value, &t, a.Config)
diff --git a/vendor/github.com/urfave/cli/v3/command.go b/vendor/github.com/urfave/cli/v3/command.go
index 4cd907a5..ade9f021 100644
--- a/vendor/github.com/urfave/cli/v3/command.go
+++ b/vendor/github.com/urfave/cli/v3/command.go
@@ -46,6 +46,9 @@ type Command struct {
 	Flags []Flag `json:"flags"`
 	// Boolean to hide built-in help command and help flag
 	HideHelp bool `json:"hideHelp"`
+	// Boolean to hide the built-in help command. Applies to this command and
+	// all of its subcommands: as with HideHelp, a true value is inherited and
+	// a subcommand cannot turn it back off.
 	// Ignored if HideHelp is true.
 	HideHelpCommand bool `json:"hideHelpCommand"`
 	// Boolean to hide built-in version flag and the VERSION section of help
@@ -64,6 +67,11 @@ type Command struct {
 	// An action to execute after any subcommands are run, but after the subcommand has finished
 	// It is run even if Action() panics
 	After AfterFunc `json:"-"`
+	// An action to validate arguments before the command is run. If non-nil, it
+	// is called before Before and Action. If the current command does not set
+	// ArgValidator, the nearest ancestor that does is used instead.
+	// Returning a non-nil error short-circuits the command.
+	ArgValidator ArgValidatorFunc `json:"-"`
 	// The function to call when this command is invoked
 	Action ActionFunc `json:"-"`
 	// Execute this function if the proper command cannot be found
@@ -74,6 +82,10 @@ type Command struct {
 	InvalidFlagAccessHandler InvalidFlagAccessFunc `json:"-"`
 	// Boolean to hide this command from help or completion
 	Hidden bool `json:"hidden"`
+	// Deprecation message for this command. If non-empty, a warning is
+	// printed to ErrWriter when the command is invoked. Setting it does not
+	// hide the command; set Hidden as well for that.
+	Deprecated string `json:"deprecated"`
 	// List of all authors who contributed (string or fmt.Stringer)
 	// TODO: ~string | fmt.Stringer when interface unions are available
 	Authors []any `json:"authors"`
@@ -157,12 +169,18 @@ type Command struct {
 	didSetupDefaults bool
 	// whether in shell completion mode
 	shellCompletion bool
+	// whether the shell completion request came after a "--" separator,
+	// after which only positional arguments are accepted and nothing is
+	// suggested. The request is still a completion, never a command run.
+	shellCompletionPastDoubleDash bool
 	// whether global help flag was added
 	globaHelpFlagAdded bool
 	// whether global version flag was added
 	globaVersionFlagAdded bool
 	// generated root version flag
 	versionFlag Flag
+	// generated help flag
+	helpFlag Flag
 	// whether this is a completion command
 	isCompletionCommand bool
 	// whether this is the built-in help command
@@ -182,7 +200,31 @@ func (cmd *Command) Command(name string) *Command {
 func (cmd *Command) checkHelp() bool {
 	tracef("checking if help is wanted (cmd=%[1]q)", cmd.Name)
 
-	return HelpFlag != nil && slices.ContainsFunc(HelpFlag.Names(), cmd.Bool)
+	helpFlag := cmd.helpFlag
+	if helpFlag == nil && HelpFlag != nil {
+		// A user flag that took the name of the help flag, such as
+		// HelpFlag itself listed in Flags, still shows help.
+		helpFlag = cmd.lFlag(HelpFlag.Names()[0])
+	}
+	return helpFlag != nil && slices.ContainsFunc(helpFlag.Names(), cmd.Bool)
+}
+
+func (cmd *Command) checkDuplicateFlagNames() error {
+	seen := map[string]struct{}{}
+	for _, fl := range cmd.allFlags() {
+		// Go flags from other packages (AllowExtFlags) can't be renamed
+		// by the user, so a user flag with the same name wins instead.
+		if _, ok := fl.(*extFlag); ok {
+			continue
+		}
+		for _, name := range fl.Names() {
+			if _, ok := seen[name]; ok {
+				return fmt.Errorf("flag %q defined multiple times in command %q", name, cmd.FullName())
+			}
+			seen[name] = struct{}{}
+		}
+	}
+	return nil
 }
 
 func (cmd *Command) allFlags() []Flag {
@@ -298,12 +340,25 @@ func (cmd *Command) VisiblePersistentFlags() []Flag {
 		return nil
 	}
 	var flags []Flag
-	for _, fl := range cmd.Root().Flags {
-		pfl, ok := fl.(LocalFlag)
-		if !ok || pfl.IsLocal() {
-			continue
+	lineage := cmd.Lineage()
+	for i := len(lineage) - 1; i > 0; i-- {
+		for _, fl := range lineage[i].allFlags() {
+			pfl, ok := fl.(LocalFlag)
+			if !ok || pfl.IsLocal() {
+				continue
+			}
+			applies := true
+			for _, name := range fl.Names() {
+				if cmd.lookupFlag(name) != fl {
+					applies = false
+					break
+				}
+			}
+			if !applies {
+				continue
+			}
+			flags = append(flags, fl)
 		}
-		flags = append(flags, fl)
 	}
 	return visibleFlags(flags)
 }
@@ -454,6 +509,40 @@ func (cmd *Command) checkRequiredFlags() requiredFlagsErr {
 	return nil
 }
 
+func (cmd *Command) checkRequiredArguments() requiredArgumentsErr {
+	// The help and completion commands are allowed to run without
+	// enforcement of required arguments, since they do not invoke user
+	// actions that depend on those argument values.
+	if cmd.builtInHelp || cmd.isCompletionCommand {
+		return nil
+	}
+
+	tracef("checking for required arguments (cmd=%[1]q)", cmd.Name)
+
+	missingArguments := []string{}
+	// This count-based precheck relies on required single-value arguments
+	// being declared before optional or multi-value arguments, as documented.
+	// Argument.Parse remains the backstop for unsupported orderings.
+	providedArguments := cmd.Args().Len()
+
+	for index, arg := range cmd.Arguments {
+		requiredArg, ok := arg.(requiredArgument)
+		if ok && requiredArg.required() && index >= providedArguments {
+			missingArguments = append(missingArguments, requiredArg.name())
+		}
+	}
+
+	if len(missingArguments) != 0 {
+		tracef("found missing required arguments %[1]q (cmd=%[2]q)", missingArguments, cmd.Name)
+
+		return &errRequiredArguments{missingArguments: missingArguments}
+	}
+
+	tracef("all required arguments set (cmd=%[1]q)", cmd.Name)
+
+	return nil
+}
+
 func (cmd *Command) onInvalidFlag(ctx context.Context, name string) {
 	for cmd != nil {
 		if cmd.InvalidFlagAccessHandler != nil {
@@ -619,7 +708,9 @@ func (cmd *Command) Value(name string) any {
 }
 
 // Args returns the command line arguments associated with the
-// command.
+// command. If the command declares named Arguments, the arguments
+// consumed by them are not included in the returned Args and should
+// be retrieved via the command.{Type}Arg(name) functions instead.
 func (cmd *Command) Args() Args {
 	return cmd.parsedArgs
 }
diff --git a/vendor/github.com/urfave/cli/v3/command_parse.go b/vendor/github.com/urfave/cli/v3/command_parse.go
index 939ad90b..9265d827 100644
--- a/vendor/github.com/urfave/cli/v3/command_parse.go
+++ b/vendor/github.com/urfave/cli/v3/command_parse.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 	"unicode"
+	"unicode/utf8"
 )
 
 const (
@@ -114,15 +115,16 @@ func (cmd *Command) parseFlags(args Args) (Args, error) {
 				return &stringSliceArgs{posArgs}, nil
 			}
 
-			posArgs = append(posArgs, firstArg)
+			// firstArg is a trimmed copy that classifies the argument; the
+			// argument itself is what the action receives, byte for byte.
+			posArgs = append(posArgs, rargs[0])
 			continue
 		}
 
 		numMinuses := 1
-		// this is same as firstArg == "-"
-		if len(firstArg) == 1 {
-			posArgs = append(posArgs, firstArg)
-			break
+		if firstArg == "-" {
+			posArgs = append(posArgs, rargs[0])
+			continue
 		}
 
 		shortOptionHandling := cmd.useShortOptionHandling()
@@ -131,7 +133,7 @@ func (cmd *Command) parseFlags(args Args) (Args, error) {
 		if firstArg[1] == '-' {
 			numMinuses++
 			shortOptionHandling = false
-		} else if !unicode.IsLetter(rune(firstArg[1])) {
+		} else if firstRune, _ := utf8.DecodeRuneInString(firstArg[1:]); !unicode.IsLetter(firstRune) {
 			// this is not a flag
 			tracef("parseFlags not a unicode letter. Stop parsing")
 			posArgs = append(posArgs, rargs...)
@@ -145,7 +147,9 @@ func (cmd *Command) parseFlags(args Args) (Args, error) {
 		valFromEqual := false
 		tracef("flagName:1 (fName=%[1]q)", flagName)
 		if index := strings.Index(flagName, "="); index != -1 {
-			flagVal = flagName[index+1:]
+			// Classify the flag using the trimmed token, but leave value
+			// whitespace handling to the flag's value parser.
+			_, flagVal, _ = strings.Cut(rargs[0], "=")
 			flagName = flagName[:index]
 			valFromEqual = true
 		}
@@ -208,28 +212,42 @@ func (cmd *Command) parseFlags(args Args) (Args, error) {
 			return &stringSliceArgs{posArgs}, fmt.Errorf("%s%s", providedButNotDefinedErrMsg, flagName)
 		}
 
-		// try to split the flags
+		// ranging over flagName yields byte offsets, so the last flag starts
+		// where its rune starts, which is not len-1 for a multi-byte rune
+		_, lastSize := utf8.DecodeLastRuneInString(flagName)
+		lastIndex := len(flagName) - lastSize
+
+		// every flag of the group has to exist before any of them is set,
+		// otherwise a group holding an unknown flag is reported by whichever
+		// of its flags happens to be examined first
 		for index, c := range flagName {
-			tracef("processing flag (fName=%[1]q)", string(c))
-			if sf := cmd.lookupFlag(string(c)); sf == nil {
+			if sf := cmd.lookupAppliedFlag(string(c)); sf == nil {
 				if index == 0 && cmd.DefaultCommand != "" {
 					posArgs = append(posArgs, rargs...)
 					return &stringSliceArgs{posArgs}, nil
 				}
 				return &stringSliceArgs{posArgs}, fmt.Errorf("%s%s", providedButNotDefinedErrMsg, flagName)
-			} else if fb, ok := sf.(boolFlag); ok && fb.IsBoolFlag() {
+			}
+		}
+
+		// try to split the flags
+		for index, c := range flagName {
+			tracef("processing flag (fName=%[1]q)", string(c))
+			// the check above has already found every flag of the group
+			sf := cmd.lookupAppliedFlag(string(c))
+			if fb, ok := sf.(boolFlag); ok && fb.IsBoolFlag() {
 				fv := flagVal
-				if index == (len(flagName)-1) && flagVal == "" {
+				if index == lastIndex && flagVal == "" {
 					fv = "true"
 				}
 				if fv == "" {
 					fv = "true"
 				}
-				if err := cmd.set(flagName, sf, fv); err != nil {
+				if err := cmd.set(string(c), sf, fv); err != nil {
 					tracef("processing flag.2 (fName=%[1]q)", string(c))
 					return &stringSliceArgs{posArgs}, err
 				}
-			} else if index == len(flagName)-1 { // last flag can take an arg
+			} else if index == lastIndex { // last flag can take an arg
 				if flagVal == "" {
 					if len(rargs) == 1 {
 						return &stringSliceArgs{posArgs}, fmt.Errorf("%s%s", argumentNotProvidedErrMsg, string(c))
@@ -238,10 +256,15 @@ func (cmd *Command) parseFlags(args Args) (Args, error) {
 					rargs = rargs[1:]
 				}
 				tracef("parseFlags (flagName %[1]q) (flagVal %[2]q)", flagName, flagVal)
-				if err := cmd.set(flagName, sf, flagVal); err != nil {
+				if err := cmd.set(string(c), sf, flagVal); err != nil {
 					tracef("processing flag.4 (fName=%[1]q)", string(c))
 					return &stringSliceArgs{posArgs}, err
 				}
+			} else {
+				// only the last flag of a group can take an argument, so a flag
+				// that needs one has nothing to read it from here
+				tracef("processing flag.5 (fName=%[1]q)", string(c))
+				return &stringSliceArgs{posArgs}, fmt.Errorf("%s%s", argumentNotProvidedErrMsg, string(c))
 			}
 		}
 	}
diff --git a/vendor/github.com/urfave/cli/v3/command_run.go b/vendor/github.com/urfave/cli/v3/command_run.go
index 8d590715..9036ec2c 100644
--- a/vendor/github.com/urfave/cli/v3/command_run.go
+++ b/vendor/github.com/urfave/cli/v3/command_run.go
@@ -125,6 +125,11 @@ func (cmd *Command) run(ctx context.Context, osArgs []string) (_ context.Context
 		// note that we can only do this because the shell autocomplete function
 		// always appends the completion flag at the end of the command
 		tracef("checking osArgs %v (cmd=%[2]q)", osArgs, cmd.Name)
+		// completion request state is per-run: a Command answering several
+		// requests (tests, REPL, embedded use) must not carry one request
+		// into the next
+		cmd.shellCompletion = false
+		cmd.shellCompletionPastDoubleDash = false
 		cmd.shellCompletion, osArgs = checkShellCompleteFlag(cmd, osArgs)
 
 		tracef("setting cmd.shellCompletion=%[1]v from checkShellCompleteFlag (cmd=%[2]q)", cmd.shellCompletion && cmd.EnableShellCompletion, cmd.Name)
@@ -138,6 +143,9 @@ func (cmd *Command) run(ctx context.Context, osArgs []string) (_ context.Context
 
 	if cmd.parent == nil {
 		cmd.setupCommandGraph()
+		if err := cmd.Walk((*Command).checkDuplicateFlagNames); err != nil {
+			return ctx, err
+		}
 	}
 
 	var rargs Args = &stringSliceArgs{v: osArgs}
@@ -327,6 +335,16 @@ func (cmd *Command) run(ctx context.Context, osArgs []string) (_ context.Context
 	// First, resolve the chain of nested commands up to the parent.
 	cmdChain := commandChain(cmd)
 
+	printDeprecationWarnings(cmdChain)
+
+	// Run ArgValidator from the nearest ancestor that sets one.
+	if validator := findArgValidator(cmd); validator != nil {
+		if err := validator(ctx, cmd); err != nil {
+			deferErr = cmd.handleExitCoder(ctx, err)
+			return ctx, deferErr
+		}
+	}
+
 	// Run Before actions in order.
 	if ctx, err = runBefore(ctx, cmdChain); err != nil {
 		deferErr = err
@@ -343,21 +361,14 @@ func (cmd *Command) run(ctx context.Context, osArgs []string) (_ context.Context
 		}
 	}
 
+	var requiredErr error
 	if err := cmd.checkAllRequiredFlags(); err != nil {
-		cmd.isInError = true
-		if cmd.OnUsageError != nil {
-			err = cmd.OnUsageError(ctx, cmd, err, cmd.parent != nil)
-		} else {
-			fmt.Fprintf(cmd.Root().ErrWriter, "Incorrect Usage: %s\n\n", err.Error())
-			if cmd.parent == nil {
-				_ = ShowRootCommandHelp(cmd)
-			} else {
-				if err := ShowCommandHelp(ctx, cmd.parent, cmd.Name); err != nil {
-					_ = ShowSubcommandHelp(cmd)
-				}
-			}
-		}
-		return ctx, err
+		requiredErr = err
+	} else if err := cmd.checkRequiredArguments(); err != nil {
+		requiredErr = err
+	}
+	if requiredErr != nil {
+		return cmd.handleRequiredError(ctx, requiredErr)
 	}
 
 	// Run the command action.
@@ -369,6 +380,9 @@ func (cmd *Command) run(ctx context.Context, osArgs []string) (_ context.Context
 			rargs, err = arg.Parse(rargs)
 			if err != nil {
 				tracef("calling with %[1]v (cmd=%[2]q)", err, cmd.Name)
+				if _, ok := err.(*errRequiredArguments); ok {
+					return cmd.handleRequiredError(ctx, err)
+				}
 				if cmd.OnUsageError != nil {
 					err = cmd.OnUsageError(ctx, cmd, err, cmd.parent != nil)
 				}
@@ -388,6 +402,21 @@ func (cmd *Command) run(ctx context.Context, osArgs []string) (_ context.Context
 	return ctx, deferErr
 }
 
+func (cmd *Command) handleRequiredError(ctx context.Context, err error) (context.Context, error) {
+	cmd.isInError = true
+	if cmd.OnUsageError != nil {
+		err = cmd.OnUsageError(ctx, cmd, err, cmd.parent != nil)
+	} else {
+		fmt.Fprintf(cmd.Root().ErrWriter, "Incorrect Usage: %s\n\n", err.Error())
+		if cmd.parent == nil {
+			_ = ShowRootCommandHelp(cmd)
+		} else if helpErr := ShowCommandHelp(ctx, cmd.parent, cmd.Name); helpErr != nil {
+			_ = ShowSubcommandHelp(cmd)
+		}
+	}
+	return ctx, err
+}
+
 func commandChain(cmd *Command) []*Command {
 	var cmdChain []*Command
 	for p := cmd; p != nil; p = p.parent {
@@ -397,6 +426,41 @@ func commandChain(cmd *Command) []*Command {
 	return cmdChain
 }
 
+// printDeprecationWarnings writes a warning to the root ErrWriter for each
+// deprecated command in the chain and for each deprecated flag that has been
+// set, whether on the command line or from one of its Sources.
+func printDeprecationWarnings(cmdChain []*Command) {
+	w := cmdChain[0].ErrWriter
+	warned := map[Flag]struct{}{}
+	for _, cmd := range cmdChain {
+		if cmd.Deprecated != "" {
+			fmt.Fprintf(w, "Command %q is deprecated, %s\n", cmd.Name, cmd.Deprecated)
+		}
+		for _, fl := range cmd.appliedFlags {
+			if _, inSet := cmd.setFlags[fl]; !inSet {
+				continue
+			}
+			if _, done := warned[fl]; done {
+				continue
+			}
+			if df, ok := fl.(DeprecatedFlag); ok && df.GetDeprecated() != "" {
+				warned[fl] = struct{}{}
+				name := fl.Names()[0]
+				fmt.Fprintf(w, "Flag %s%s has been deprecated, %s\n", prefixFor(name), name, df.GetDeprecated())
+			}
+		}
+	}
+}
+
+func findArgValidator(cmd *Command) ArgValidatorFunc {
+	for c := cmd; c != nil; c = c.parent {
+		if c.ArgValidator != nil {
+			return c.ArgValidator
+		}
+	}
+	return nil
+}
+
 func runBefore(ctx context.Context, cmdChain []*Command) (context.Context, error) {
 	for _, cmd := range cmdChain {
 		if cmd.Before == nil {
diff --git a/vendor/github.com/urfave/cli/v3/command_setup.go b/vendor/github.com/urfave/cli/v3/command_setup.go
index 646e270c..c682eaf4 100644
--- a/vendor/github.com/urfave/cli/v3/command_setup.go
+++ b/vendor/github.com/urfave/cli/v3/command_setup.go
@@ -24,7 +24,7 @@ func (cmd *Command) setupDefaults(osArgs []string) {
 		cmd.ShellComplete = DefaultCompleteWithFlags
 	}
 
-	if cmd.Name == "" && isRoot {
+	if cmd.Name == "" && isRoot && len(osArgs) > 0 {
 		name := filepath.Base(osArgs[0])
 		tracef("setting cmd.Name from first arg basename (cmd=%[1]q)", name)
 		cmd.Name = name
@@ -153,6 +153,7 @@ func (cmd *Command) setupDefaults(osArgs []string) {
 	tracef("setting category on mutually exclusive flags (cmd=%[1]q)", cmd.Name)
 	for _, grp := range cmd.MutuallyExclusiveFlags {
 		grp.propagateCategory()
+		grp.propagateStringer()
 	}
 
 	tracef("setting flag categories (cmd=%[1]q)", cmd.Name)
@@ -196,6 +197,7 @@ func (cmd *Command) setupSubcommand() {
 	tracef("setting category on mutually exclusive flags (cmd=%[1]q)", cmd.Name)
 	for _, grp := range cmd.MutuallyExclusiveFlags {
 		grp.propagateCategory()
+		grp.propagateStringer()
 	}
 
 	tracef("setting flag categories (cmd=%[1]q)", cmd.Name)
@@ -227,6 +229,17 @@ func (cmd *Command) hideHelp() bool {
 	return false
 }
 
+func (cmd *Command) hideHelpCommand() bool {
+	tracef("hide help command (cmd=%[1]q)", cmd.Name)
+	for c := cmd; c != nil; c = c.parent {
+		if c.HideHelpCommand {
+			return true
+		}
+	}
+
+	return false
+}
+
 func (cmd *Command) ensureHelp() {
 	tracef("ensuring help (cmd=%[1]q)", cmd.Name)
 
@@ -234,7 +247,7 @@ func (cmd *Command) ensureHelp() {
 
 	if !cmd.hideHelp() {
 		if cmd.Command(helpCommand.Name) == nil {
-			if !cmd.HideHelpCommand {
+			if !cmd.hideHelpCommand() {
 				tracef("appending helpCommand (cmd=%[1]q)", cmd.Name)
 				cmd.appendCommand(helpCommand)
 			}
@@ -245,14 +258,21 @@ func (cmd *Command) ensureHelp() {
 				var localHelpFlag Flag
 				if globalHelpFlag, ok := HelpFlag.(*BoolFlag); ok {
 					flag := *globalHelpFlag
+					// Drop any alias a user flag already claims (e.g. -h
+					// for --host) so the user flag wins but --help still
+					// works, as for the version flag.
+					flag.Aliases = dropClashingAliases(flag.Aliases, cmd.allFlags(), flag.Name)
 					localHelpFlag = &flag
 				} else {
 					localHelpFlag = HelpFlag
 				}
 
-				tracef("appending HelpFlag (cmd=%[1]q)", cmd.Name)
-				cmd.appendFlag(localHelpFlag)
-				cmd.globaHelpFlagAdded = true
+				if !flagNamesInUse(cmd.allFlags(), localHelpFlag.Names()) {
+					tracef("appending HelpFlag (cmd=%[1]q)", cmd.Name)
+					cmd.appendFlag(localHelpFlag)
+					cmd.helpFlag = localHelpFlag
+					cmd.globaHelpFlagAdded = true
+				}
 			} else {
 				tracef("HelpFlag already added, skip (cmd=%[1]q)", cmd.Name)
 			}
diff --git a/vendor/github.com/urfave/cli/v3/completion.go b/vendor/github.com/urfave/cli/v3/completion.go
index f14b0143..b78dc385 100644
--- a/vendor/github.com/urfave/cli/v3/completion.go
+++ b/vendor/github.com/urfave/cli/v3/completion.go
@@ -59,7 +59,7 @@ source <($COMMAND completion zsh)
 $COMMAND completion fish > ~/.config/fish/completions/$COMMAND.fish
 
 # Powershell
-Output the script to path/to/autocomplete/$COMMAND.ps1 an run it.
+Output the script to path/to/autocomplete/$COMMAND.ps1 and run it.
 `
 
 func buildCompletionCommand(appName string) *Command {
diff --git a/vendor/github.com/urfave/cli/v3/docs.go b/vendor/github.com/urfave/cli/v3/docs.go
index 88461386..30c053ca 100644
--- a/vendor/github.com/urfave/cli/v3/docs.go
+++ b/vendor/github.com/urfave/cli/v3/docs.go
@@ -5,10 +5,11 @@ import (
 	"os"
 	"runtime"
 	"strings"
+	"unicode/utf8"
 )
 
 func prefixFor(name string) (prefix string) {
-	if len(name) == 1 {
+	if utf8.RuneCountInString(name) == 1 {
 		prefix = "-"
 	} else {
 		prefix = "--"
diff --git a/vendor/github.com/urfave/cli/v3/errors.go b/vendor/github.com/urfave/cli/v3/errors.go
index ffd6471f..11306967 100644
--- a/vendor/github.com/urfave/cli/v3/errors.go
+++ b/vendor/github.com/urfave/cli/v3/errors.go
@@ -61,6 +61,22 @@ func (e *errRequiredFlags) Error() string {
 	return fmt.Sprintf("Required flags %q not set", joinedMissingFlags)
 }
 
+type requiredArgumentsErr interface {
+	error
+}
+
+type errRequiredArguments struct {
+	missingArguments []string
+}
+
+func (e *errRequiredArguments) Error() string {
+	if len(e.missingArguments) == 1 {
+		return fmt.Sprintf("Required argument %q not set", e.missingArguments[0])
+	}
+	joinedMissingArguments := strings.Join(e.missingArguments, ", ")
+	return fmt.Sprintf("Required arguments %q not set", joinedMissingArguments)
+}
+
 type mutuallyExclusiveGroup struct {
 	flag1Name string
 	flag2Name string
@@ -136,6 +152,12 @@ func (ee *exitError) ExitCode() int {
 	return ee.exitCode
 }
 
+// Unwrap returns the error given to [Exit], so that [errors.Is] and
+// [errors.As] can inspect it through the ExitCoder wrapper.
+func (ee *exitError) Unwrap() error {
+	return ee.err
+}
+
 // HandleExitCoder handles errors implementing ExitCoder by printing their
 // message and calling OsExiter with the given exit code.
 //
diff --git a/vendor/github.com/urfave/cli/v3/fish.go b/vendor/github.com/urfave/cli/v3/fish.go
index 8002a33c..de0d2a86 100644
--- a/vendor/github.com/urfave/cli/v3/fish.go
+++ b/vendor/github.com/urfave/cli/v3/fish.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 	"strings"
-	"text/template"
 )
 
 // ToFishCompletion creates a fish completion string for the `*Command`
@@ -25,12 +24,6 @@ type fishCommandCompletionTemplate struct {
 }
 
 func (cmd *Command) writeFishCompletionTemplate(w io.Writer) error {
-	const name = "cli"
-	t, err := template.New(name).Parse(FishCompletionTemplate)
-	if err != nil {
-		return err
-	}
-
 	// Add global flags
 	completions := prepareFishFlags(cmd.Name, cmd)
 
@@ -57,7 +50,7 @@ func (cmd *Command) writeFishCompletionTemplate(w io.Writer) error {
 		toplevelCommandNames = append(toplevelCommandNames, child.Names()...)
 	}
 
-	return t.ExecuteTemplate(w, name, &fishCommandCompletionTemplate{
+	return renderFishCompletion(w, &fishCommandCompletionTemplate{
 		Command:     cmd,
 		Completions: completions,
 		AllCommands: toplevelCommandNames,
@@ -216,6 +209,15 @@ func commandAncestry(command *Command) string {
 	return strings.Join(ancestry, "; and ")
 }
 
+// escapeSingleQuotes escapes a string for use inside a fish single-quoted
+// string, such as a `-d '...'` description. Within single quotes fish only
+// recognizes the escape sequences \\ and \', so the backslash must be escaped
+// as well as the single quote. Escaping the quote without escaping the
+// backslash corrupts any description that contains a backslash, and a trailing
+// backslash even leaves the single-quoted string unterminated.
+// See https://fishshell.com/docs/current/language.html
 func escapeSingleQuotes(input string) string {
-	return strings.ReplaceAll(input, `'`, `\'`)
+	return fishSingleQuoteReplacer.Replace(input)
 }
+
+var fishSingleQuoteReplacer = strings.NewReplacer(`\`, `\\`, `'`, `\'`)
diff --git a/vendor/github.com/urfave/cli/v3/flag.go b/vendor/github.com/urfave/cli/v3/flag.go
index 3cb9ab96..f3a9fb54 100644
--- a/vendor/github.com/urfave/cli/v3/flag.go
+++ b/vendor/github.com/urfave/cli/v3/flag.go
@@ -118,6 +118,13 @@ type RequiredFlag interface {
 	IsRequired() bool
 }
 
+// DeprecatedFlag is an interface that allows us to mark flags as deprecated
+type DeprecatedFlag interface {
+	// GetDeprecated returns the deprecation message, or an empty string
+	// if the flag is not deprecated
+	GetDeprecated() string
+}
+
 // DocGenerationFlag is an interface that allows documentation generation for the flag
 type DocGenerationFlag interface {
 	// TakesValue returns true if the flag takes a value, otherwise false
@@ -190,6 +197,18 @@ type CategorizableFlag interface {
 	SetCategory(string)
 }
 
+// StringerSetter is an optional interface that allows an individual
+// flag to be given a per-flag override of [FlagStringer]. FlagBase and
+// BoolWithInverseFlag implement this. It's used by
+// [MutuallyExclusiveFlags.Stringer] to customize how flags within a
+// mutually exclusive group are displayed in help output.
+type StringerSetter interface {
+	// SetStringer overrides the [FlagStringFunc] used by this flag's
+	// String method. Passing nil restores the default behavior of using
+	// the package-level [FlagStringer].
+	SetStringer(FlagStringFunc)
+}
+
 // LocalFlag is an interface to enable detection of flags which are local
 // to current command
 type LocalFlag interface {
diff --git a/vendor/github.com/urfave/cli/v3/flag_bool_with_inverse.go b/vendor/github.com/urfave/cli/v3/flag_bool_with_inverse.go
index 199d22c7..d885bbda 100644
--- a/vendor/github.com/urfave/cli/v3/flag_bool_with_inverse.go
+++ b/vendor/github.com/urfave/cli/v3/flag_bool_with_inverse.go
@@ -18,6 +18,7 @@ type BoolWithInverseFlag struct {
 	Sources          ValueSourceChain                            `json:"-"`                // sources to load flag value from
 	Required         bool                                        `json:"required"`         // whether the flag is required or not
 	Hidden           bool                                        `json:"hidden"`           // whether to hide the flag in help output
+	Deprecated       string                                      `json:"deprecated"`       // deprecation message, if set a warning is printed when the flag is set
 	Local            bool                                        `json:"local"`            // whether the flag needs to be applied to subcommands as well
 	Value            bool                                        `json:"defaultValue"`     // default value for this flag if not set by from any source
 	Destination      *bool                                       `json:"-"`                // destination pointer for value when set
@@ -33,10 +34,26 @@ type BoolWithInverseFlag struct {
 	// unexported fields for internal use
 	count      int   // number of times the flag has been set
 	hasBeenSet bool  // whether the flag has been set from env or file
+	fromSource bool  // whether the current value came from Sources
 	applied    bool  // whether the flag has been applied to a flag set already
 	value      Value // value representing this flag's value
 	pset       bool
 	nset       bool
+	stringer   FlagStringFunc // optional per-flag override of FlagStringer
+}
+
+// SetStringer overrides the [FlagStringFunc] used by this flag's String
+// method. Passing nil restores the default behavior of using the
+// package-level [FlagStringer]. This is used e.g. by
+// [MutuallyExclusiveFlags.Stringer].
+//
+// Note: unlike [FlagBase], BoolWithInverseFlag.String only honors the
+// stringer partially. The names segment (the part before the first tab,
+// e.g. "--[no-]env, -e") is always recomputed from Name/Aliases/InversePrefix
+// and cannot be overridden; only the tab-delimited details after it come
+// from the stringer's output.
+func (bif *BoolWithInverseFlag) SetStringer(s FlagStringFunc) {
+	bif.stringer = s
 }
 
 func (bif *BoolWithInverseFlag) IsSet() bool {
@@ -68,10 +85,6 @@ func (bif *BoolWithInverseFlag) inversePrefix() string {
 }
 
 func (bif *BoolWithInverseFlag) PreParse() error {
-	count := bif.Config.Count
-	if count == nil {
-		count = &bif.count
-	}
 	dest := bif.Destination
 	if dest == nil {
 		dest = new(bool)
@@ -79,7 +92,7 @@ func (bif *BoolWithInverseFlag) PreParse() error {
 	*dest = bif.Value
 	bif.value = &boolValue{
 		destination: dest,
-		count:       count,
+		count:       bif.Config.Count,
 	}
 
 	// Validate the given default or values set from external sources as well
@@ -108,6 +121,7 @@ func (bif *BoolWithInverseFlag) PostParse() error {
 			}
 
 			bif.hasBeenSet = true
+			bif.fromSource = true
 		}
 	}
 
@@ -115,6 +129,15 @@ func (bif *BoolWithInverseFlag) PostParse() error {
 }
 
 func (bif *BoolWithInverseFlag) Set(name, val string) error {
+	// A value from Sources is only a fallback, so a value set afterwards
+	// replaces it (see FlagBase.Set).
+	if bif.fromSource {
+		bif.fromSource = false
+		bif.count = 0
+		bif.pset = false
+		bif.nset = false
+	}
+
 	if bif.count > 0 && bif.OnlyOnce {
 		return fmt.Errorf("can't duplicate this flag")
 	}
@@ -138,6 +161,7 @@ func (bif *BoolWithInverseFlag) Set(name, val string) error {
 		}
 		bif.nset = true
 	}
+	bif.count++
 
 	if bif.Validator != nil {
 		return bif.Validator(bif.value.Get().(bool))
@@ -171,7 +195,11 @@ func (bif *BoolWithInverseFlag) IsVisible() bool {
 // Example for BoolFlag{Name: "env", Aliases: []string{"e"}}
 // --[no-]env, -e	(default: false)
 func (bif *BoolWithInverseFlag) String() string {
-	out := FlagStringer(bif)
+	fs := FlagStringer
+	if bif.stringer != nil {
+		fs = bif.stringer
+	}
+	out := fs(bif)
 
 	i := strings.Index(out, "\t")
 
@@ -219,12 +247,17 @@ func (bif *BoolWithInverseFlag) Count() int {
 
 // GetDefaultText returns the default text for this flag
 func (bif *BoolWithInverseFlag) GetDefaultText() string {
-	if bif.Required {
+	if bif.DefaultText != "" {
 		return bif.DefaultText
 	}
 	return boolValue{}.ToString(bif.Value)
 }
 
+// GetDeprecated returns the deprecation message of the flag
+func (bif *BoolWithInverseFlag) GetDeprecated() string {
+	return bif.Deprecated
+}
+
 // GetCategory returns the category of the flag
 func (bif *BoolWithInverseFlag) GetCategory() string {
 	return bif.Category
diff --git a/vendor/github.com/urfave/cli/v3/flag_impl.go b/vendor/github.com/urfave/cli/v3/flag_impl.go
index a67208c9..410f7f08 100644
--- a/vendor/github.com/urfave/cli/v3/flag_impl.go
+++ b/vendor/github.com/urfave/cli/v3/flag_impl.go
@@ -63,6 +63,7 @@ type FlagBase[T any, C any, VC ValueCreator[T, C]] struct {
 	Sources          ValueSourceChain                         `json:"-"`                // sources to load flag value from
 	Required         bool                                     `json:"required"`         // whether the flag is required or not
 	Hidden           bool                                     `json:"hidden"`           // whether to hide the flag in help output
+	Deprecated       string                                   `json:"deprecated"`       // deprecation message, if set a warning is printed when the flag is set
 	Local            bool                                     `json:"local"`            // whether the flag needs to be applied to subcommands as well
 	Value            T                                        `json:"defaultValue"`     // default value for this flag if not set by from any source
 	Destination      *T                                       `json:"-"`                // destination pointer for value when set
@@ -75,11 +76,15 @@ type FlagBase[T any, C any, VC ValueCreator[T, C]] struct {
 	ValidateDefaults bool                                     `json:"validateDefaults"` // whether to validate defaults or not
 
 	// unexported fields for internal use
-	count      int   // number of times the flag has been set
-	hasBeenSet bool  // whether the flag has been set from env or file
-	applied    bool  // whether the flag has been applied to a flag set already
-	creator    VC    // value creator for this flag type
-	value      Value // value representing this flag's value
+	count      int            // number of times the flag has been set
+	hasBeenSet bool           // whether the flag has been set from env or file
+	fromSource bool           // whether the current value came from Sources
+	applied    bool           // whether the flag has been applied to a flag set already
+	creator    VC             // value creator for this flag type
+	value      Value          // value representing this flag's value
+	stringer   FlagStringFunc // optional per-flag override of FlagStringer
+
+	multiValueConfig *multiValueParsingConfig // last parsing config passed to value
 }
 
 // GetValue returns the flags value as string representation and an empty
@@ -130,19 +135,40 @@ func (f *FlagBase[T, C, V]) PostParse() error {
 	tracef("postparse (flag=%[1]q)", f.Name)
 
 	if !f.hasBeenSet {
-		if val, source, found := f.Sources.LookupWithSource(); found {
-			if val != "" || reflect.TypeOf(f.Value).Kind() == reflect.String {
+		// reflect.TypeOf yields nil when T is an interface type (e.g.
+		// GenericFlag) and the value is nil, so the kind has to be
+		// derived defensively.
+		kind := reflect.Invalid
+		if ty := reflect.TypeOf(f.Value); ty != nil {
+			kind = ty.Kind()
+		}
+
+		// An empty value is a value only for a string, and reads as false
+		// for a bool. Any other kind has nothing to parse from it, so an
+		// empty source is skipped: it neither marks the flag as set nor
+		// hides a later source in the chain.
+		emptyIsValue := kind == reflect.String || kind == reflect.Bool
+
+		for _, source := range f.Sources.Chain {
+			val, found := source.Lookup()
+			if !found || (val == "" && !emptyIsValue) {
+				continue
+			}
+
+			if val != "" || kind == reflect.String {
 				if err := f.Set(f.Name, val); err != nil {
 					return fmt.Errorf(
 						"could not parse %[1]q as %[2]T value from %[3]s for flag %[4]s: %[5]s",
 						val, f.Value, source, f.Name, err,
 					)
 				}
-			} else if val == "" && reflect.TypeOf(f.Value).Kind() == reflect.Bool {
+			} else {
 				_ = f.Set(f.Name, "false")
 			}
 
 			f.hasBeenSet = true
+			f.fromSource = true
+			break
 		}
 	}
 
@@ -152,19 +178,22 @@ func (f *FlagBase[T, C, V]) PostParse() error {
 // pass configuration of parsing to value
 func (f *FlagBase[T, C, V]) setMultiValueParsingConfig(c multiValueParsingConfig) {
 	tracef("setMultiValueParsingConfig %T, %+v", f.value, f.value)
+	f.multiValueConfig = &c
 	if cf, ok := f.value.(multiValueParsingConfigSetter); ok {
 		cf.setMultiValueParsingConfig(c)
 	}
 }
 
-func (f *FlagBase[T, C, V]) PreParse() error {
-	newVal := f.Value
-
+// newValue creates the flag's value holding the default Value.
+func (f *FlagBase[T, C, V]) newValue() Value {
 	if f.Destination == nil {
-		f.value = f.creator.Create(newVal, new(T), f.Config)
-	} else {
-		f.value = f.creator.Create(newVal, f.Destination, f.Config)
+		return f.creator.Create(f.Value, new(T), f.Config)
 	}
+	return f.creator.Create(f.Value, f.Destination, f.Config)
+}
+
+func (f *FlagBase[T, C, V]) PreParse() error {
+	f.value = f.newValue()
 
 	// Validate the given default or values set from external sources as well
 	if f.Validator != nil && f.ValidateDefaults {
@@ -193,6 +222,19 @@ func (f *FlagBase[T, C, V]) Set(_ string, val string) error {
 		f.applied = true
 	}
 
+	// A value from Sources is only a fallback, so a value set afterwards
+	// replaces it rather than being added to it or counted as a duplicate.
+	// This happens for a persistent flag: its command reads the Sources
+	// before a subcommand parses the flag from the command line.
+	if f.fromSource {
+		f.fromSource = false
+		f.count = 0
+		f.value = f.newValue()
+		if f.multiValueConfig != nil {
+			f.setMultiValueParsingConfig(*f.multiValueConfig)
+		}
+	}
+
 	if f.count == 1 && f.OnlyOnce {
 		return fmt.Errorf("can't duplicate this flag")
 	}
@@ -224,9 +266,20 @@ func (f *FlagBase[T, C, V]) IsDefaultVisible() bool {
 
 // String returns a readable representation of this value (for usage defaults)
 func (f *FlagBase[T, C, V]) String() string {
+	if f.stringer != nil {
+		return f.stringer(f)
+	}
 	return FlagStringer(f)
 }
 
+// SetStringer overrides the [FlagStringFunc] used by this flag's String
+// method. Passing nil restores the default behavior of using the
+// package-level [FlagStringer]. This is used e.g. by
+// [MutuallyExclusiveFlags.Stringer].
+func (f *FlagBase[T, C, V]) SetStringer(s FlagStringFunc) {
+	f.stringer = s
+}
+
 // IsSet returns whether or not the flag has been set through env or file
 func (f *FlagBase[T, C, V]) IsSet() bool {
 	return f.hasBeenSet
@@ -247,6 +300,11 @@ func (f *FlagBase[T, C, V]) IsVisible() bool {
 	return !f.Hidden
 }
 
+// GetDeprecated returns the deprecation message of the flag
+func (f *FlagBase[T, C, V]) GetDeprecated() string {
+	return f.Deprecated
+}
+
 // GetCategory returns the category of the flag
 func (f *FlagBase[T, C, V]) GetCategory() string {
 	return f.Category
@@ -316,8 +374,10 @@ func (f *FlagBase[T, C, V]) SchemaType() string {
 // SchemaItemsType returns the JSON Schema element type for slice flags.
 func (f *FlagBase[T, C, V]) SchemaItemsType() string {
 	var zero T
+	// reflect.TypeOf yields nil when T is an interface type (e.g. GenericFlag),
+	// in which case there are no slice elements to describe.
 	t := reflect.TypeOf(zero)
-	if t.Kind() == reflect.Slice {
+	if t != nil && t.Kind() == reflect.Slice {
 		switch t.Elem().Kind() {
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
 			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
diff --git a/vendor/github.com/urfave/cli/v3/flag_map_impl.go b/vendor/github.com/urfave/cli/v3/flag_map_impl.go
index cb65903b..dfe8f097 100644
--- a/vendor/github.com/urfave/cli/v3/flag_map_impl.go
+++ b/vendor/github.com/urfave/cli/v3/flag_map_impl.go
@@ -13,6 +13,7 @@ type MapBase[T any, C any, VC ValueCreator[T, C]] struct {
 	dict             *map[string]T
 	hasBeenSet       bool
 	value            Value
+	trimKeySpace     bool
 	multiValueConfig multiValueParsingConfig
 }
 
@@ -24,9 +25,16 @@ func (i MapBase[T, C, VC]) Create(val map[string]T, p *map[string]T, c C) Value
 	var t T
 	np := new(T)
 	var vc VC
+	// The key is always a string, so it answers to StringConfig.TrimSpace just
+	// like the value does.
+	trimKeySpace := false
+	if sc, ok := any(c).(StringConfig); ok {
+		trimKeySpace = sc.TrimSpace
+	}
 	return &MapBase[T, C, VC]{
-		dict:  p,
-		value: vc.Create(t, np, c),
+		dict:         p,
+		value:        vc.Create(t, np, c),
+		trimKeySpace: trimKeySpace,
 	}
 }
 
@@ -81,6 +89,9 @@ func (i *MapBase[T, C, VC]) Set(value string) error {
 		if !ok {
 			return fmt.Errorf("item %q is missing separator %q", item, keyValueSeparator)
 		}
+		if i.trimKeySpace {
+			key = strings.TrimSpace(key)
+		}
 		if err := i.value.Set(value); err != nil {
 			return err
 		}
diff --git a/vendor/github.com/urfave/cli/v3/flag_mutex.go b/vendor/github.com/urfave/cli/v3/flag_mutex.go
index 247bcb56..bd016988 100644
--- a/vendor/github.com/urfave/cli/v3/flag_mutex.go
+++ b/vendor/github.com/urfave/cli/v3/flag_mutex.go
@@ -14,35 +14,63 @@ type MutuallyExclusiveFlags struct {
 
 	// Category to apply to all flags within group
 	Category string
+
+	// Stringer overrides how each flag within this group is displayed in
+	// help output. If nil, flags use [FlagStringer] as usual.
+	//
+	// The returned string must be unique per flag within the group (the
+	// default [stringifyFlag] guarantees this by embedding the flag's
+	// name). Help rendering keys flags by their String() output
+	// (flagCategories.AddFlag), so a Stringer that returns identical text
+	// for two or more flags in the same category will cause the later
+	// flag to silently overwrite the earlier one in help output.
+	Stringer FlagStringFunc `json:"-"`
 }
 
 func (grp MutuallyExclusiveFlags) check(_ *Command) error {
-	oneSet := false
 	e := &mutuallyExclusiveGroup{}
 
-	for _, grpf := range grp.Flags {
-		for _, f := range grpf {
-			if f.IsSet() {
-				if oneSet {
-					e.flag2Name = f.Names()[0]
-					return e
-				}
-				e.flag1Name = f.Names()[0]
-				oneSet = true
-				break
-			}
-			if oneSet {
-				break
-			}
+	// Check for the use of a mutually-exclusive flag, starting at
+	// the first group.
+	name, i, ok := grp.findSetFlag(0)
+	if ok {
+		e.flag1Name = name
+		i++
+
+		// Check for the use of a flag in a mutually exclusive
+		// relationship with the one we just found.
+		if name2, _, ok := grp.findSetFlag(i); ok {
+			e.flag2Name = name2
+			return e
 		}
 	}
 
-	if !oneSet && grp.Required {
+	if !ok && grp.Required {
 		return &mutuallyExclusiveGroupRequiredFlag{flags: &grp}
 	}
+
 	return nil
 }
 
+// findSetFlag is used in [MutuallyExclusiveFlags.check] to find
+// whether at least one flag inside a mutually exclusive flag group is
+// set. If so, return the flag name, position at which it's set, and
+// Boolean true (indicating that a flag was found.) Else, return all
+// zero values.
+func (grp MutuallyExclusiveFlags) findSetFlag(startIdx int) (string, int, bool) {
+	for i := startIdx; i < len(grp.Flags); i++ {
+		flags := grp.Flags[i]
+
+		for _, flg := range flags {
+			if flg.IsSet() {
+				return flg.Names()[0], i, true
+			}
+		}
+	}
+
+	return "", 0, false
+}
+
 func (grp MutuallyExclusiveFlags) propagateCategory() {
 	for _, grpf := range grp.Flags {
 		for _, f := range grpf {
@@ -52,3 +80,22 @@ func (grp MutuallyExclusiveFlags) propagateCategory() {
 		}
 	}
 }
+
+// propagateStringer applies [MutuallyExclusiveFlags.Stringer], if set, to
+// every flag within the group that supports a [StringerSetter]. Like
+// [MutuallyExclusiveFlags.propagateCategory], this only runs during command
+// setup, so mutating Stringer between runs of a reused [Command] will not
+// re-propagate the change.
+func (grp MutuallyExclusiveFlags) propagateStringer() {
+	if grp.Stringer == nil {
+		return
+	}
+
+	for _, grpf := range grp.Flags {
+		for _, f := range grpf {
+			if sf, ok := f.(StringerSetter); ok {
+				sf.SetStringer(grp.Stringer)
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/urfave/cli/v3/flag_text.go b/vendor/github.com/urfave/cli/v3/flag_text.go
new file mode 100644
index 00000000..a1cc2c36
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v3/flag_text.go
@@ -0,0 +1,86 @@
+package cli
+
+import (
+	"encoding"
+	"strings"
+)
+
+// TextMarshalUnmarshaler is the interface implemented by types that can marshal
+// themselves to and from a textual form. It is the value type used by TextFlag,
+// mirroring the standard library's flag.TextVar, and is satisfied by types such
+// as *slog.LevelVar, *net/netip.Addr, and *time.Time.
+type TextMarshalUnmarshaler interface {
+	encoding.TextMarshaler
+	encoding.TextUnmarshaler
+}
+
+type TextFlag = FlagBase[TextMarshalUnmarshaler, StringConfig, textValue]
+
+// -- TextMarshalUnmarshaler Value
+type textValue struct {
+	destination TextMarshalUnmarshaler
+	trimSpace   bool
+}
+
+// Below functions are to satisfy the ValueCreator interface
+
+func (t textValue) Create(val TextMarshalUnmarshaler, p *TextMarshalUnmarshaler, c StringConfig) Value {
+	// Only overwrite the target when a non-nil default value is given, so that
+	// a Destination pointing at an existing target is preserved (unlike the
+	// concrete flag types, T here is an interface whose nil default would
+	// otherwise clobber the destination).
+	if val != nil {
+		*p = val
+	}
+	return &textValue{
+		destination: *p,
+		trimSpace:   c.TrimSpace,
+	}
+}
+
+func (t textValue) ToString(val TextMarshalUnmarshaler) string {
+	if val == nil {
+		return ""
+	}
+	text, err := val.MarshalText()
+	if err != nil {
+		return ""
+	}
+	return string(text)
+}
+
+// Below functions are to satisfy the flag.Value interface
+
+func (t *textValue) Set(val string) error {
+	if t.destination == nil {
+		return nil
+	}
+	if t.trimSpace {
+		val = strings.TrimSpace(val)
+	}
+	return t.destination.UnmarshalText([]byte(val))
+}
+
+func (t *textValue) Get() any { return t.destination }
+
+func (t *textValue) String() string {
+	if t.destination == nil {
+		return ""
+	}
+	text, err := t.destination.MarshalText()
+	if err != nil {
+		return ""
+	}
+	return string(text)
+}
+
+// Text looks up the value of a local TextFlag, returns nil if not found
+func (cmd *Command) Text(name string) TextMarshalUnmarshaler {
+	if v, ok := cmd.Value(name).(TextMarshalUnmarshaler); ok {
+		tracef("text available for flag name %[1]q with value=%[2]v (cmd=%[3]q)", name, v, cmd.Name)
+		return v
+	}
+
+	tracef("text NOT available for flag name %[1]q (cmd=%[2]q)", name, cmd.Name)
+	return nil
+}
diff --git a/vendor/github.com/urfave/cli/v3/flag_timestamp.go b/vendor/github.com/urfave/cli/v3/flag_timestamp.go
index 82b1cb5c..0f173654 100644
--- a/vendor/github.com/urfave/cli/v3/flag_timestamp.go
+++ b/vendor/github.com/urfave/cli/v3/flag_timestamp.go
@@ -63,6 +63,7 @@ func (t *timestampValue) Set(value string) error {
 		return errors.New("got nil/empty layouts slice")
 	}
 
+	matchedLayout := ""
 	for _, layout := range t.layouts {
 		var locErr error
 
@@ -78,6 +79,7 @@ func (t *timestampValue) Set(value string) error {
 		}
 
 		err = nil
+		matchedLayout = layout
 		break
 	}
 
@@ -85,12 +87,14 @@ func (t *timestampValue) Set(value string) error {
 		return err
 	}
 
-	defaultTS, _ := time.ParseInLocation(time.TimeOnly, time.TimeOnly, timestamp.Location())
-
 	n := time.Now().In(timestamp.Location())
 
 	// If format is missing date (or year only), set it explicitly to current
-	if timestamp.Truncate(time.Hour*24).UnixNano() == defaultTS.Truncate(time.Hour*24).UnixNano() {
+	// A layout that carries a date parses "January 1" to the same instant a date-less layout does, so ask the layout.
+	// The date is compared in the timestamp's own location: truncating the
+	// instant to a day works in UTC and misses January 1 of year 0 for part
+	// of the day whenever Timezone is not UTC.
+	if !layoutHasDate(matchedLayout) && timestamp.Year() == 0 && timestamp.YearDay() == 1 {
 		timestamp = time.Date(
 			n.Year(),
 			n.Month(),
@@ -121,6 +125,14 @@ func (t *timestampValue) Set(value string) error {
 	return nil
 }
 
+// layoutHasDate reports whether layout carries month/day components, probed by
+// round-tripping a reference date that is not January 1.
+func layoutHasDate(layout string) bool {
+	ref := time.Date(2, time.March, 4, 5, 6, 7, 0, time.UTC)
+	p, err := time.Parse(layout, ref.Format(layout))
+	return err == nil && (p.Month() != time.January || p.Day() != 1)
+}
+
 // String returns a readable representation of this value (for usage defaults)
 func (t *timestampValue) String() string {
 	return fmt.Sprintf("%v", t.timestamp)
diff --git a/vendor/github.com/urfave/cli/v3/funcs.go b/vendor/github.com/urfave/cli/v3/funcs.go
index fe1224c4..17a73eca 100644
--- a/vendor/github.com/urfave/cli/v3/funcs.go
+++ b/vendor/github.com/urfave/cli/v3/funcs.go
@@ -17,6 +17,13 @@ type AfterFunc func(context.Context, *Command) error
 // ActionFunc is the action to execute when no subcommands are specified
 type ActionFunc func(context.Context, *Command) error
 
+// ArgValidatorFunc is an action to validate arguments before the command is run.
+// If non-nil, it is called before the command's After and Action functions.
+// Returning a non-nil error short-circuits the command and propagates as
+// the exit error. If the current command does not set ArgValidator, the
+// nearest ancestor that does is used instead.
+type ArgValidatorFunc func(context.Context, *Command) error
+
 // CommandNotFoundFunc is executed if the proper command cannot be found
 type CommandNotFoundFunc func(context.Context, *Command, string)
 
diff --git a/vendor/github.com/urfave/cli/v3/godoc-current.txt b/vendor/github.com/urfave/cli/v3/godoc-current.txt
index d680c5f5..ce70dbc0 100644
--- a/vendor/github.com/urfave/cli/v3/godoc-current.txt
+++ b/vendor/github.com/urfave/cli/v3/godoc-current.txt
@@ -258,6 +258,13 @@ type AfterFunc func(context.Context, *Command) error
     AfterFunc is an action that executes after any subcommands are run and have
     finished. The AfterFunc is run even if Action() panics.
 
+type ArgValidatorFunc func(context.Context, *Command) error
+    ArgValidatorFunc is an action to validate arguments before the command
+    is run. If non-nil, it is called before the command's After and Action
+    functions. Returning a non-nil error short-circuits the command and
+    propagates as the exit error. If the current command does not set
+    ArgValidator, the nearest ancestor that does is used instead.
+
 type Args interface {
 	// Get returns the nth argument, or else a blank string
 	Get(n int) string
@@ -294,6 +301,7 @@ type ArgumentBase[T any, C any, VC ValueCreator[T, C]] struct {
 	Value       T      `json:"value"`     // the default value of this argument
 	Destination *T     `json:"-"`         // the destination point for this argument
 	UsageText   string `json:"usageText"` // the usage text to show
+	Required    bool   `json:"required"`  // whether the argument is required or not
 	Config      C      `json:"config"`    // config for this argument similar to Flag Config
 
 	// Has unexported fields.
@@ -349,6 +357,7 @@ type BoolWithInverseFlag struct {
 	Sources          ValueSourceChain                            `json:"-"`                // sources to load flag value from
 	Required         bool                                        `json:"required"`         // whether the flag is required or not
 	Hidden           bool                                        `json:"hidden"`           // whether to hide the flag in help output
+	Deprecated       string                                      `json:"deprecated"`       // deprecation message, if set a warning is printed when the flag is set
 	Local            bool                                        `json:"local"`            // whether the flag needs to be applied to subcommands as well
 	Value            bool                                        `json:"defaultValue"`     // default value for this flag if not set by from any source
 	Destination      *bool                                       `json:"-"`                // destination pointer for value when set
@@ -375,6 +384,9 @@ func (bif *BoolWithInverseFlag) GetCategory() string
 func (bif *BoolWithInverseFlag) GetDefaultText() string
     GetDefaultText returns the default text for this flag
 
+func (bif *BoolWithInverseFlag) GetDeprecated() string
+    GetDeprecated returns the deprecation message of the flag
+
 func (bif *BoolWithInverseFlag) GetEnvVars() []string
     GetEnvVars returns the env vars for this flag
 
@@ -415,6 +427,17 @@ func (bif *BoolWithInverseFlag) Set(name, val string) error
 
 func (bif *BoolWithInverseFlag) SetCategory(c string)
 
+func (bif *BoolWithInverseFlag) SetStringer(s FlagStringFunc)
+    SetStringer overrides the FlagStringFunc used by this flag's String method.
+    Passing nil restores the default behavior of using the package-level
+    FlagStringer. This is used e.g. by MutuallyExclusiveFlags.Stringer.
+
+    Note: unlike FlagBase, BoolWithInverseFlag.String only honors the
+    stringer partially. The names segment (the part before the first tab, e.g.
+    "--[no-]env, -e") is always recomputed from Name/Aliases/InversePrefix and
+    cannot be overridden; only the tab-delimited details after it come from the
+    stringer's output.
+
 func (bif *BoolWithInverseFlag) String() string
     String implements the standard Stringer interface.
 
@@ -464,6 +487,9 @@ type Command struct {
 	Flags []Flag `json:"flags"`
 	// Boolean to hide built-in help command and help flag
 	HideHelp bool `json:"hideHelp"`
+	// Boolean to hide the built-in help command. Applies to this command and
+	// all of its subcommands: as with HideHelp, a true value is inherited and
+	// a subcommand cannot turn it back off.
 	// Ignored if HideHelp is true.
 	HideHelpCommand bool `json:"hideHelpCommand"`
 	// Boolean to hide built-in version flag and the VERSION section of help
@@ -482,6 +508,11 @@ type Command struct {
 	// An action to execute after any subcommands are run, but after the subcommand has finished
 	// It is run even if Action() panics
 	After AfterFunc `json:"-"`
+	// An action to validate arguments before the command is run. If non-nil, it
+	// is called before Before and Action. If the current command does not set
+	// ArgValidator, the nearest ancestor that does is used instead.
+	// Returning a non-nil error short-circuits the command.
+	ArgValidator ArgValidatorFunc `json:"-"`
 	// The function to call when this command is invoked
 	Action ActionFunc `json:"-"`
 	// Execute this function if the proper command cannot be found
@@ -492,6 +523,10 @@ type Command struct {
 	InvalidFlagAccessHandler InvalidFlagAccessFunc `json:"-"`
 	// Boolean to hide this command from help or completion
 	Hidden bool `json:"hidden"`
+	// Deprecation message for this command. If non-empty, a warning is
+	// printed to ErrWriter when the command is invoked. Setting it does not
+	// hide the command; set Hidden as well for that.
+	Deprecated string `json:"deprecated"`
 	// List of all authors who contributed (string or fmt.Stringer)
 	// TODO: ~string | fmt.Stringer when interface unions are available
 	Authors []any `json:"authors"`
@@ -564,6 +599,9 @@ type Command struct {
 
 func (cmd *Command) Args() Args
     Args returns the command line arguments associated with the command.
+    If the command declares named Arguments, the arguments consumed by them
+    are not included in the returned Args and should be retrieved via the
+    command.{Type}Arg(name) functions instead.
 
 func (cmd *Command) Bool(name string) bool
 
@@ -726,6 +764,9 @@ func (cmd *Command) StringSlice(name string) []string
     StringSlice looks up the value of a local StringSliceFlag, returns nil if
     not found
 
+func (cmd *Command) Text(name string) TextMarshalUnmarshaler
+    Text looks up the value of a local TextFlag, returns nil if not found
+
 func (cmd *Command) Timestamp(name string) time.Time
     Timestamp gets the timestamp from a flag name
 
@@ -846,6 +887,13 @@ type Countable interface {
     Countable is an interface to enable detection of flag values which support
     repetitive flags
 
+type DeprecatedFlag interface {
+	// GetDeprecated returns the deprecation message, or an empty string
+	// if the flag is not deprecated
+	GetDeprecated() string
+}
+    DeprecatedFlag is an interface that allows us to mark flags as deprecated
+
 type DocGenerationFlag interface {
 	// TakesValue returns true if the flag takes a value, otherwise false
 	TakesValue() bool
@@ -974,6 +1022,7 @@ type FlagBase[T any, C any, VC ValueCreator[T, C]] struct {
 	Sources          ValueSourceChain                         `json:"-"`                // sources to load flag value from
 	Required         bool                                     `json:"required"`         // whether the flag is required or not
 	Hidden           bool                                     `json:"hidden"`           // whether to hide the flag in help output
+	Deprecated       string                                   `json:"deprecated"`       // deprecation message, if set a warning is printed when the flag is set
 	Local            bool                                     `json:"local"`            // whether the flag needs to be applied to subcommands as well
 	Value            T                                        `json:"defaultValue"`     // default value for this flag if not set by from any source
 	Destination      *T                                       `json:"-"`                // destination pointer for value when set
@@ -1005,6 +1054,9 @@ func (f *FlagBase[T, C, V]) GetCategory() string
 func (f *FlagBase[T, C, V]) GetDefaultText() string
     GetDefaultText returns the default text for this flag
 
+func (f *FlagBase[T, C, V]) GetDeprecated() string
+    GetDeprecated returns the deprecation message of the flag
+
 func (f *FlagBase[T, C, V]) GetEnvVars() []string
     GetEnvVars returns the env vars for this flag
 
@@ -1059,6 +1111,11 @@ func (f *FlagBase[T, C, V]) Set(_ string, val string) error
 
 func (f *FlagBase[T, C, V]) SetCategory(c string)
 
+func (f *FlagBase[T, C, V]) SetStringer(s FlagStringFunc)
+    SetStringer overrides the FlagStringFunc used by this flag's String method.
+    Passing nil restores the default behavior of using the package-level
+    FlagStringer. This is used e.g. by MutuallyExclusiveFlags.Stringer.
+
 func (f *FlagBase[T, C, V]) String() string
     String returns a readable representation of this value (for usage defaults)
 
@@ -1296,6 +1353,17 @@ type MutuallyExclusiveFlags struct {
 
 	// Category to apply to all flags within group
 	Category string
+
+	// Stringer overrides how each flag within this group is displayed in
+	// help output. If nil, flags use [FlagStringer] as usual.
+	//
+	// The returned string must be unique per flag within the group (the
+	// default [stringifyFlag] guarantees this by embedding the flag's
+	// name). Help rendering keys flags by their String() output
+	// (flagCategories.AddFlag), so a Stringer that returns identical text
+	// for two or more flags in the same category will cause the later
+	// flag to silently overwrite the earlier one in help output.
+	Stringer FlagStringFunc `json:"-"`
 }
     MutuallyExclusiveFlags defines a mutually exclusive flag group Multiple
     option paths can be provided out of which only one can be defined on cmdline
@@ -1393,10 +1461,32 @@ type StringSlice = SliceBase[string, StringConfig, stringValue]
 
 type StringSliceFlag = FlagBase[[]string, StringConfig, StringSlice]
 
+type StringerSetter interface {
+	// SetStringer overrides the [FlagStringFunc] used by this flag's
+	// String method. Passing nil restores the default behavior of using
+	// the package-level [FlagStringer].
+	SetStringer(FlagStringFunc)
+}
+    StringerSetter is an optional interface that allows an individual flag to be
+    given a per-flag override of FlagStringer. FlagBase and BoolWithInverseFlag
+    implement this. It's used by MutuallyExclusiveFlags.Stringer to customize
+    how flags within a mutually exclusive group are displayed in help output.
+
 type SuggestCommandFunc func(commands []*Command, provided string) string
 
 type SuggestFlagFunc func(flags []Flag, provided string, hideHelp bool) string
 
+type TextFlag = FlagBase[TextMarshalUnmarshaler, StringConfig, textValue]
+
+type TextMarshalUnmarshaler interface {
+	encoding.TextMarshaler
+	encoding.TextUnmarshaler
+}
+    TextMarshalUnmarshaler is the interface implemented by types that can
+    marshal themselves to and from a textual form. It is the value type used by
+    TextFlag, mirroring the standard library's flag.TextVar, and is satisfied by
+    types such as *slog.LevelVar, *net/netip.Addr, and *time.Time.
+
 type TimestampArg = ArgumentBase[time.Time, TimestampConfig, timestampValue]
 
 type TimestampArgs = ArgumentsBase[time.Time, TimestampConfig, timestampValue]
diff --git a/vendor/github.com/urfave/cli/v3/help.go b/vendor/github.com/urfave/cli/v3/help.go
index 4bedf87d..382735bf 100644
--- a/vendor/github.com/urfave/cli/v3/help.go
+++ b/vendor/github.com/urfave/cli/v3/help.go
@@ -7,8 +7,6 @@ import (
 	"os"
 	"slices"
 	"strings"
-	"text/tabwriter"
-	"text/template"
 	"unicode/utf8"
 )
 
@@ -216,7 +214,7 @@ func printFlagSuggestions(lastArg string, flags []Flag, writer io.Writer) {
 	// Trim to handle both "-short" and "--long" flags.
 	cur := strings.TrimLeft(lastArg, "-")
 	for _, flag := range flags {
-		if bflag, ok := flag.(*BoolFlag); ok && bflag.Hidden {
+		if vf, ok := flag.(VisibleFlag); ok && !vf.IsVisible() {
 			continue
 		}
 
@@ -257,12 +255,13 @@ func DefaultCompleteWithFlags(ctx context.Context, cmd *Command) {
 	}
 	argsLen := len(args)
 	lastArg := ""
-	// parent command will have --generate-shell-completion so we need
-	// to account for that
-	if argsLen > 1 {
-		lastArg = args[argsLen-2]
-	} else if argsLen > 0 {
+	// os.Args retains the completion marker, but a child's parsed arguments
+	// have already had it removed.
+	if argsLen > 0 {
 		lastArg = args[argsLen-1]
+		if lastArg == completionFlag && argsLen > 1 {
+			lastArg = args[argsLen-2]
+		}
 	}
 
 	if lastArg == completionFlag {
@@ -271,7 +270,15 @@ func DefaultCompleteWithFlags(ctx context.Context, cmd *Command) {
 
 	if strings.HasPrefix(lastArg, "-") {
 		tracef("printing flag suggestion for flag[%v] on command %[1]q", lastArg, cmd.Name)
-		printFlagSuggestions(lastArg, cmd.Flags, cmd.Root().Writer)
+		flags := cmd.allFlags()
+		if !cmd.SkipFlagParsing {
+			for _, fl := range cmd.VisiblePersistentFlags() {
+				if !hasFlag(flags, fl) {
+					flags = append(flags, fl)
+				}
+			}
+		}
+		printFlagSuggestions(lastArg, flags, cmd.Root().Writer)
 		return
 	}
 
@@ -369,99 +376,6 @@ func handleTemplateError(err error) {
 	}
 }
 
-// DefaultPrintHelpCustom is the default implementation of HelpPrinterCustom.
-//
-// The customFuncs map will be combined with a default template.FuncMap to
-// allow using arbitrary functions in template rendering.
-func DefaultPrintHelpCustom(out io.Writer, templ string, data any, customFuncs map[string]any) {
-	const maxLineLength = 10000
-
-	tracef("building default funcMap")
-	funcMap := template.FuncMap{
-		"join":           strings.Join,
-		"subtract":       subtract,
-		"indent":         indent,
-		"nindent":        nindent,
-		"trim":           strings.TrimSpace,
-		"wrap":           func(input string, offset int) string { return wrap(input, offset, maxLineLength) },
-		"offset":         offset,
-		"offsetCommands": offsetCommands,
-	}
-
-	if wa, ok := customFuncs["wrapAt"]; ok {
-		if wrapAtFunc, ok := wa.(func() int); ok {
-			wrapAt := wrapAtFunc()
-			customFuncs["wrap"] = func(input string, offset int) string {
-				return wrap(input, offset, wrapAt)
-			}
-		}
-	}
-
-	for key, value := range customFuncs {
-		funcMap[key] = value
-	}
-
-	w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0)
-	t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
-
-	if _, err := t.New("helpNameTemplate").Parse(helpNameTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("argsTemplate").Parse(argsTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("usageTemplate").Parse(usageTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("descriptionTemplate").Parse(descriptionTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("visibleCommandTemplate").Parse(visibleCommandTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("copyrightTemplate").Parse(copyrightTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("versionTemplate").Parse(versionTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("visibleFlagCategoryTemplate").Parse(visibleFlagCategoryTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("visibleFlagTemplate").Parse(visibleFlagTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("visiblePersistentFlagTemplate").Parse(visiblePersistentFlagTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("visibleGlobalFlagCategoryTemplate").Parse(strings.ReplaceAll(visibleFlagCategoryTemplate, "OPTIONS", "GLOBAL OPTIONS")); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("authorsTemplate").Parse(authorsTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	if _, err := t.New("visibleCommandCategoryTemplate").Parse(visibleCommandCategoryTemplate); err != nil {
-		handleTemplateError(err)
-	}
-
-	tracef("executing template")
-	handleTemplateError(t.Execute(w, data))
-
-	_ = w.Flush()
-}
-
 // DefaultPrintHelp is the default implementation of HelpPrinter.
 func DefaultPrintHelp(out io.Writer, templ string, data any) {
 	HelpPrinterCustom(out, templ, data, nil)
@@ -476,6 +390,10 @@ func checkShellCompleteFlag(c *Command, arguments []string) (bool, []string) {
 		return false, arguments
 	}
 
+	if len(arguments) == 0 {
+		return false, arguments
+	}
+
 	pos := len(arguments) - 1
 	lastArg := arguments[pos]
 
@@ -483,13 +401,16 @@ func checkShellCompleteFlag(c *Command, arguments []string) (bool, []string) {
 		return false, arguments
 	}
 
-	// If arguments include "--" before the token being completed, shell completion
-	// is disabled because after "--" only positional arguments are accepted.
+	// If the token being completed is preceded by a "--", only positional
+	// arguments are accepted after it, so nothing will be suggested.
 	// https://unix.stackexchange.com/a/11382
 	// Note: The token being completed is at position pos-1 (immediately before completionFlag).
-	// We only check arguments before that position, so completing "--" itself still works.
+	// A "--" at exactly that position is the token being completed, not a
+	// separator, so completing "--" itself still suggests flags.
+	// The request is still recognized as a completion so that the command
+	// action is never executed (https://github.com/urfave/cli/issues/1993).
 	if pos >= 1 && slices.Contains(arguments[:pos-1], "--") {
-		return false, arguments[:pos]
+		c.shellCompletionPastDoubleDash = true
 	}
 
 	return true, arguments[:pos]
@@ -516,6 +437,13 @@ func shouldRunCompletion(cmd *Command) bool {
 }
 
 func runCompletion(ctx context.Context, cmd *Command) {
+	// Nothing is suggested past a "--": after it, only positional arguments
+	// are accepted. The request is still treated as a completion so that the
+	// command action is never executed (https://github.com/urfave/cli/issues/1993).
+	if cmd.Root().shellCompletionPastDoubleDash {
+		tracef("completion requested past double dash; suggesting nothing (cmd=%[1]q)", cmd.Name)
+		return
+	}
 	if cmd.ShellComplete != nil {
 		tracef("running shell completion func for command %[1]q", cmd.Name)
 		cmd.ShellComplete(ctx, cmd)
diff --git a/vendor/github.com/urfave/cli/v3/help_notemplate.go b/vendor/github.com/urfave/cli/v3/help_notemplate.go
new file mode 100644
index 00000000..b417034b
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v3/help_notemplate.go
@@ -0,0 +1,338 @@
+//go:build urfave_cli_no_template
+
+package cli
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+	"text/tabwriter"
+)
+
+// templatesSupported is true unless built with the urfave_cli_no_template tag.
+const templatesSupported = false
+
+// With urfave_cli_no_template tag, templates are not used, and these are
+// only used to tell which help is requested.
+const (
+	// RootCommandHelpTemplate identifies the help for the root command.
+	RootCommandHelpTemplate = "root"
+	// CommandHelpTemplate identifies the help for a command.
+	CommandHelpTemplate = "command"
+	// SubcommandHelpTemplate identifies the help for a command with subcommands.
+	SubcommandHelpTemplate = "subcommand"
+	// FishCompletionTemplate is not used.
+	FishCompletionTemplate = "fish"
+)
+
+var errNoTemplate = errors.New("custom templates are not supported when built with urfave_cli_no_template tag")
+
+// DefaultPrintHelpCustom is the default implementation of HelpPrinterCustom.
+//
+// The customFuncs map will be combined with a default template.FuncMap to
+// allow using arbitrary functions in template rendering.
+//
+// When built with the urfave_cli_no_template tag, text/template is not used
+// (as it disables linker's dead code elimination), and the help is rendered
+// directly. In this mode, only the default templates are supported (it panics
+// otherwise), and the only custom functions used are "wrap" and "wrapAt".
+func DefaultPrintHelpCustom(out io.Writer, templ string, data any, customFuncs map[string]any) {
+	const maxLineLength = 10000
+
+	cmd, ok := data.(*Command)
+	if !ok {
+		panic(errNoTemplate)
+	}
+
+	h := helpRenderer{
+		cmd:  cmd,
+		wrap: func(input string, offset int) string { return wrap(input, offset, maxLineLength) },
+	}
+	if f, ok := customFuncs["wrap"].(func(string, int) string); ok {
+		h.wrap = f
+	}
+	if wa, ok := customFuncs["wrapAt"]; ok {
+		if wrapAtFunc, ok := wa.(func() int); ok {
+			wrapAt := wrapAtFunc()
+			h.wrap = func(input string, offset int) string {
+				return wrap(input, offset, wrapAt)
+			}
+		}
+	}
+
+	switch templ {
+	case RootCommandHelpTemplate:
+		h.root()
+	case CommandHelpTemplate:
+		h.command()
+	case SubcommandHelpTemplate:
+		h.subcommand()
+	default:
+		panic(fmt.Errorf("command %q: %w", cmd.FullName(), errNoTemplate))
+	}
+
+	w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0)
+	_, err := io.WriteString(w, h.String())
+	handleTemplateError(err)
+	_ = w.Flush()
+}
+
+// helpRenderer renders the default help templates (see template.go)
+// without using text/template.
+type helpRenderer struct {
+	strings.Builder
+	cmd  *Command
+	wrap func(string, int) string
+}
+
+func (h *helpRenderer) root() {
+	c := h.cmd
+	h.WriteString("NAME:\n   ")
+	h.helpName()
+	h.WriteString("\n\nUSAGE:\n   ")
+	if c.UsageText != "" {
+		h.WriteString(h.wrap(c.UsageText, 3))
+	} else {
+		h.WriteString(c.FullName() + " ")
+		if len(c.VisibleFlags()) > 0 {
+			h.WriteString("[global options]")
+		}
+		if len(c.VisibleCommands()) > 0 {
+			h.WriteString(" [command [command options]]")
+		}
+		h.argsUsage()
+	}
+	if c.Version != "" && !c.HideVersion {
+		h.WriteString("\n\nVERSION:\n   " + c.Version)
+	}
+	h.description()
+	if len(c.Authors) > 0 {
+		h.WriteString("\n\nAUTHOR")
+		h.authors()
+	}
+	if len(c.VisibleCommands()) > 0 {
+		h.WriteString("\n\nCOMMANDS:")
+		h.visibleCommandCategories()
+	}
+	h.flags("GLOBAL OPTIONS:")
+	if c.Copyright != "" {
+		h.WriteString("\n\nCOPYRIGHT:\n   " + h.wrap(c.Copyright, 3))
+	}
+	h.WriteString("\n")
+}
+
+func (h *helpRenderer) command() {
+	h.WriteString("NAME:\n   ")
+	h.helpName()
+	h.WriteString("\n\nUSAGE:\n   ")
+	h.usage()
+	h.category()
+	h.description()
+	h.flags("OPTIONS:")
+	h.persistentFlags()
+	h.WriteString("\n")
+}
+
+func (h *helpRenderer) subcommand() {
+	c := h.cmd
+	h.WriteString("NAME:\n   ")
+	h.helpName()
+	h.WriteString("\n\nUSAGE:\n   ")
+	if c.UsageText != "" {
+		h.WriteString(h.wrap(c.UsageText, 3))
+	} else {
+		h.WriteString(c.FullName())
+		if len(c.VisibleCommands()) > 0 {
+			h.WriteString(" [command [command options]]")
+		}
+		h.argsUsage()
+	}
+	h.category()
+	h.description()
+	if cmds := c.VisibleCommands(); len(cmds) > 0 {
+		h.WriteString("\n\nCOMMANDS:")
+		h.visibleCommands(cmds)
+	}
+	h.flags("OPTIONS:")
+	h.persistentFlags()
+	h.WriteString("\n")
+}
+
+// helpName implements helpNameTemplate.
+func (h *helpRenderer) helpName() {
+	name := h.cmd.FullName()
+	h.WriteString(h.wrap(name, 3))
+	if h.cmd.Usage != "" {
+		h.WriteString(" - " + h.wrap(h.cmd.Usage, offset(name, 6)))
+	}
+}
+
+// usage implements usageTemplate.
+func (h *helpRenderer) usage() {
+	c := h.cmd
+	if c.UsageText != "" {
+		h.WriteString(h.wrap(c.UsageText, 3))
+		return
+	}
+	h.WriteString(c.FullName())
+	if len(c.VisibleFlags()) > 0 {
+		h.WriteString(" [options]")
+	}
+	if len(c.VisibleCommands()) > 0 {
+		h.WriteString(" [command [command options]]")
+	}
+	if c.ArgsUsage != "" {
+		h.WriteString(" " + c.ArgsUsage)
+	} else if len(c.Arguments) > 0 {
+		// argsTemplate.
+		h.WriteString(" ")
+		for _, arg := range c.Arguments {
+			h.WriteString(arg.Usage() + " ")
+		}
+	}
+}
+
+// argsUsage implements the part of root and subcommand usage
+// that follows the command name and options.
+func (h *helpRenderer) argsUsage() {
+	if h.cmd.ArgsUsage != "" {
+		h.WriteString(" " + h.cmd.ArgsUsage)
+	} else if len(h.cmd.Arguments) > 0 {
+		h.WriteString(" [arguments...]")
+	}
+}
+
+func (h *helpRenderer) category() {
+	if h.cmd.Category != "" {
+		h.WriteString("\n\nCATEGORY:\n   " + h.cmd.Category)
+	}
+}
+
+// description implements descriptionTemplate.
+func (h *helpRenderer) description() {
+	if h.cmd.Description != "" {
+		h.WriteString("\n\nDESCRIPTION:\n   " + h.wrap(h.cmd.Description, 3))
+	}
+}
+
+// authors implements authorsTemplate.
+func (h *helpRenderer) authors() {
+	if len(h.cmd.Authors) != 1 {
+		h.WriteString("S")
+	}
+	h.WriteString(":\n   ")
+	for i, author := range h.cmd.Authors {
+		if i > 0 {
+			h.WriteString("\n   ")
+		}
+		h.WriteString(printableValue(author))
+	}
+}
+
+// visibleCommandCategories implements visibleCommandCategoryTemplate.
+func (h *helpRenderer) visibleCommandCategories() {
+	for _, cat := range h.cmd.VisibleCategories() {
+		if cat.Name() == "" {
+			h.visibleCommands(cat.VisibleCommands())
+			continue
+		}
+		h.WriteString("\n\n   " + cat.Name() + ":")
+		for _, cmd := range cat.VisibleCommands() {
+			h.WriteString("\n     " + strings.Join(cmd.Names(), ", ") + "\t" + cmd.Usage)
+		}
+	}
+}
+
+// visibleCommands implements visibleCommandTemplate.
+func (h *helpRenderer) visibleCommands(cmds []*Command) {
+	cv := offsetCommands(cmds, 5)
+	for _, cmd := range cmds {
+		s := strings.Join(cmd.Names(), ", ")
+		h.WriteString("\n   " + s + indent(subtract(cv, offset(s, 3)), "") + h.wrap(cmd.Usage, cv))
+	}
+}
+
+// flags implements the OPTIONS (or GLOBAL OPTIONS) section,
+// using visibleFlagCategoryTemplate or visibleFlagTemplate.
+func (h *helpRenderer) flags(title string) {
+	if cats := h.cmd.VisibleFlagCategories(); len(cats) > 0 {
+		h.WriteString("\n\n" + title)
+		for _, cat := range cats {
+			h.WriteString("\n   ")
+			if cat.Name() != "" {
+				h.WriteString(cat.Name() + "\n\n   ")
+			}
+			flags := cat.Flags()
+			for i, f := range flags {
+				h.WriteString(printableValue(f))
+				if i == len(flags)-1 {
+					h.WriteString("\n")
+				} else {
+					h.WriteString("\n   ")
+				}
+			}
+		}
+	} else if flags := h.cmd.VisibleFlags(); len(flags) > 0 {
+		h.WriteString("\n\n" + title)
+		h.visibleFlags(flags)
+	}
+}
+
+// persistentFlags implements the GLOBAL OPTIONS section
+// of command and subcommand help.
+func (h *helpRenderer) persistentFlags() {
+	if flags := h.cmd.VisiblePersistentFlags(); len(flags) > 0 {
+		h.WriteString("\n\nGLOBAL OPTIONS:")
+		h.visibleFlags(flags)
+	}
+}
+
+// visibleFlags implements visibleFlagTemplate
+// and visiblePersistentFlagTemplate.
+func (h *helpRenderer) visibleFlags(flags []Flag) {
+	for _, f := range flags {
+		h.WriteString("\n   " + h.wrap(f.String(), 6))
+	}
+}
+
+// printableValue formats v the same way text/template prints a value.
+func printableValue(v any) string {
+	if v == nil {
+		return "<no value>"
+	}
+	switch v.(type) {
+	case error, fmt.Stringer:
+		return fmt.Sprint(v)
+	}
+	rv := reflect.ValueOf(v)
+	for rv.Kind() == reflect.Pointer && !rv.IsNil() {
+		rv = rv.Elem()
+	}
+	return fmt.Sprint(rv.Interface())
+}
+
+func renderFishCompletion(w io.Writer, data *fishCommandCompletionTemplate) error {
+	name := data.Command.Name
+	var b strings.Builder
+	b.WriteString("# " + name + " fish shell completion\n\n" +
+		"function __fish_" + name + "_no_subcommand --description 'Test if there has been any subcommand yet'\n" +
+		"    for i in (commandline -opc)\n" +
+		"        if contains -- $i")
+	for _, c := range data.AllCommands {
+		b.WriteString(" " + c)
+	}
+	b.WriteString("\n" +
+		"            return 1\n" +
+		"        end\n" +
+		"    end\n" +
+		"    return 0\n" +
+		"end\n\n")
+	for _, c := range data.Completions {
+		b.WriteString(c + "\n")
+	}
+
+	_, err := io.WriteString(w, b.String())
+	return err
+}
diff --git a/vendor/github.com/urfave/cli/v3/help_template.go b/vendor/github.com/urfave/cli/v3/help_template.go
new file mode 100644
index 00000000..a05cb5ae
--- /dev/null
+++ b/vendor/github.com/urfave/cli/v3/help_template.go
@@ -0,0 +1,204 @@
+//go:build !urfave_cli_no_template
+
+package cli
+
+import (
+	"io"
+	"strings"
+	"text/tabwriter"
+	"text/template"
+)
+
+// templatesSupported is true unless built with the urfave_cli_no_template tag.
+const templatesSupported = true
+
+// RootCommandHelpTemplate is the text template for the Default help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var RootCommandHelpTemplate = `NAME:
+   {{template "helpNameTemplate" .}}
+
+USAGE:
+   {{if .UsageText}}{{wrap .UsageText 3}}{{else}}{{.FullName}} {{if .VisibleFlags}}[global options]{{end}}{{if .VisibleCommands}} [command [command options]]{{end}}{{if .ArgsUsage}} {{.ArgsUsage}}{{else}}{{if .Arguments}} [arguments...]{{end}}{{end}}{{end}}{{if .Version}}{{if not .HideVersion}}
+
+VERSION:
+   {{.Version}}{{end}}{{end}}{{if .Description}}
+
+DESCRIPTION:
+   {{template "descriptionTemplate" .}}{{end}}
+{{- if len .Authors}}
+
+AUTHOR{{template "authorsTemplate" .}}{{end}}{{if .VisibleCommands}}
+
+COMMANDS:{{template "visibleCommandCategoryTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
+
+GLOBAL OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
+
+GLOBAL OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .Copyright}}
+
+COPYRIGHT:
+   {{template "copyrightTemplate" .}}{{end}}
+`
+
+// CommandHelpTemplate is the text template for the command help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var CommandHelpTemplate = `NAME:
+   {{template "helpNameTemplate" .}}
+
+USAGE:
+   {{template "usageTemplate" .}}{{if .Category}}
+
+CATEGORY:
+   {{.Category}}{{end}}{{if .Description}}
+
+DESCRIPTION:
+   {{template "descriptionTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
+
+OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
+
+OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .VisiblePersistentFlags}}
+
+GLOBAL OPTIONS:{{template "visiblePersistentFlagTemplate" .}}{{end}}
+`
+
+// SubcommandHelpTemplate is the text template for the subcommand help topic.
+// cli.go uses text/template to render templates. You can
+// render custom help text by setting this variable.
+var SubcommandHelpTemplate = `NAME:
+   {{template "helpNameTemplate" .}}
+
+USAGE:
+   {{if .UsageText}}{{wrap .UsageText 3}}{{else}}{{.FullName}}{{if .VisibleCommands}} [command [command options]]{{end}}{{if .ArgsUsage}} {{.ArgsUsage}}{{else}}{{if .Arguments}} [arguments...]{{end}}{{end}}{{end}}{{if .Category}}
+
+CATEGORY:
+   {{.Category}}{{end}}{{if .Description}}
+
+DESCRIPTION:
+   {{template "descriptionTemplate" .}}{{end}}{{if .VisibleCommands}}
+
+COMMANDS:{{template "visibleCommandTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
+
+OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
+
+OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .VisiblePersistentFlags}}
+
+GLOBAL OPTIONS:{{template "visiblePersistentFlagTemplate" .}}{{end}}
+`
+
+var FishCompletionTemplate = `# {{ .Command.Name }} fish shell completion
+
+function __fish_{{ .Command.Name }}_no_subcommand --description 'Test if there has been any subcommand yet'
+    for i in (commandline -opc)
+        if contains -- $i{{ range $v := .AllCommands }} {{ $v }}{{ end }}
+            return 1
+        end
+    end
+    return 0
+end
+
+{{ range $v := .Completions }}{{ $v }}
+{{ end }}`
+
+// DefaultPrintHelpCustom is the default implementation of HelpPrinterCustom.
+//
+// The customFuncs map will be combined with a default template.FuncMap to
+// allow using arbitrary functions in template rendering.
+func DefaultPrintHelpCustom(out io.Writer, templ string, data any, customFuncs map[string]any) {
+	const maxLineLength = 10000
+
+	tracef("building default funcMap")
+	funcMap := template.FuncMap{
+		"join":           strings.Join,
+		"subtract":       subtract,
+		"indent":         indent,
+		"nindent":        nindent,
+		"trim":           strings.TrimSpace,
+		"wrap":           func(input string, offset int) string { return wrap(input, offset, maxLineLength) },
+		"offset":         offset,
+		"offsetCommands": offsetCommands,
+	}
+
+	if wa, ok := customFuncs["wrapAt"]; ok {
+		if wrapAtFunc, ok := wa.(func() int); ok {
+			wrapAt := wrapAtFunc()
+			customFuncs["wrap"] = func(input string, offset int) string {
+				return wrap(input, offset, wrapAt)
+			}
+		}
+	}
+
+	for key, value := range customFuncs {
+		funcMap[key] = value
+	}
+
+	w := tabwriter.NewWriter(out, 1, 8, 2, ' ', 0)
+	t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
+
+	if _, err := t.New("helpNameTemplate").Parse(helpNameTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("argsTemplate").Parse(argsTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("usageTemplate").Parse(usageTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("descriptionTemplate").Parse(descriptionTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("visibleCommandTemplate").Parse(visibleCommandTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("copyrightTemplate").Parse(copyrightTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("versionTemplate").Parse(versionTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("visibleFlagCategoryTemplate").Parse(visibleFlagCategoryTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("visibleFlagTemplate").Parse(visibleFlagTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("visiblePersistentFlagTemplate").Parse(visiblePersistentFlagTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("visibleGlobalFlagCategoryTemplate").Parse(strings.ReplaceAll(visibleFlagCategoryTemplate, "OPTIONS", "GLOBAL OPTIONS")); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("authorsTemplate").Parse(authorsTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	if _, err := t.New("visibleCommandCategoryTemplate").Parse(visibleCommandCategoryTemplate); err != nil {
+		handleTemplateError(err)
+	}
+
+	tracef("executing template")
+	handleTemplateError(t.Execute(w, data))
+
+	_ = w.Flush()
+}
+
+func renderFishCompletion(w io.Writer, data *fishCommandCompletionTemplate) error {
+	const name = "cli"
+	t, err := template.New(name).Parse(FishCompletionTemplate)
+	if err != nil {
+		return err
+	}
+
+	return t.ExecuteTemplate(w, name, data)
+}
diff --git a/vendor/github.com/urfave/cli/v3/mkdocs-requirements.txt b/vendor/github.com/urfave/cli/v3/mkdocs-requirements.txt
index 701403ae..8ed82f8c 100644
--- a/vendor/github.com/urfave/cli/v3/mkdocs-requirements.txt
+++ b/vendor/github.com/urfave/cli/v3/mkdocs-requirements.txt
@@ -1,5 +1,5 @@
-mkdocs-git-revision-date-localized-plugin==1.5.3
-mkdocs-material==9.7.6
+mkdocs-git-revision-date-localized-plugin==1.6.0
+mkdocs-material==9.7.7
 mkdocs==1.6.1
 mkdocs-redirects==1.2.3
-pygments==2.20.0
+pygments==2.21.0
diff --git a/vendor/github.com/urfave/cli/v3/suggestions.go b/vendor/github.com/urfave/cli/v3/suggestions.go
index 401dcef2..4c1ce9aa 100644
--- a/vendor/github.com/urfave/cli/v3/suggestions.go
+++ b/vendor/github.com/urfave/cli/v3/suggestions.go
@@ -120,13 +120,14 @@ func suggestFlag(flags []Flag, provided string, hideHelp bool) string {
 		}
 	}
 
-	if len(suggestion) == 1 {
-		suggestion = "-" + suggestion
-	} else if len(suggestion) > 1 {
-		suggestion = "--" + suggestion
+	if len(suggestion) == 0 {
+		return ""
 	}
 
-	return suggestion
+	// Use the same rune-counting rule that drives the help output
+	// (prefixFor) so that a single-rune name is suggested as a short flag
+	// regardless of how many bytes that rune is encoded in.
+	return prefixFor(suggestion) + suggestion
 }
 
 // suggestCommand takes a list of commands and a provided string to suggest a
diff --git a/vendor/github.com/urfave/cli/v3/template.go b/vendor/github.com/urfave/cli/v3/template.go
index 92030cc8..48fbcf85 100644
--- a/vendor/github.com/urfave/cli/v3/template.go
+++ b/vendor/github.com/urfave/cli/v3/template.go
@@ -37,91 +37,3 @@ VERSION:
    {{.Version}}{{end}}{{end}}`
 
 var copyrightTemplate = `{{wrap .Copyright 3}}`
-
-// RootCommandHelpTemplate is the text template for the Default help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var RootCommandHelpTemplate = `NAME:
-   {{template "helpNameTemplate" .}}
-
-USAGE:
-   {{if .UsageText}}{{wrap .UsageText 3}}{{else}}{{.FullName}} {{if .VisibleFlags}}[global options]{{end}}{{if .VisibleCommands}} [command [command options]]{{end}}{{if .ArgsUsage}} {{.ArgsUsage}}{{else}}{{if .Arguments}} [arguments...]{{end}}{{end}}{{end}}{{if .Version}}{{if not .HideVersion}}
-
-VERSION:
-   {{.Version}}{{end}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{template "descriptionTemplate" .}}{{end}}
-{{- if len .Authors}}
-
-AUTHOR{{template "authorsTemplate" .}}{{end}}{{if .VisibleCommands}}
-
-COMMANDS:{{template "visibleCommandCategoryTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
-
-GLOBAL OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
-
-GLOBAL OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .Copyright}}
-
-COPYRIGHT:
-   {{template "copyrightTemplate" .}}{{end}}
-`
-
-// CommandHelpTemplate is the text template for the command help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var CommandHelpTemplate = `NAME:
-   {{template "helpNameTemplate" .}}
-
-USAGE:
-   {{template "usageTemplate" .}}{{if .Category}}
-
-CATEGORY:
-   {{.Category}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{template "descriptionTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
-
-OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
-
-OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .VisiblePersistentFlags}}
-
-GLOBAL OPTIONS:{{template "visiblePersistentFlagTemplate" .}}{{end}}
-`
-
-// SubcommandHelpTemplate is the text template for the subcommand help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var SubcommandHelpTemplate = `NAME:
-   {{template "helpNameTemplate" .}}
-
-USAGE:
-   {{if .UsageText}}{{wrap .UsageText 3}}{{else}}{{.FullName}}{{if .VisibleCommands}} [command [command options]]{{end}}{{if .ArgsUsage}} {{.ArgsUsage}}{{else}}{{if .Arguments}} [arguments...]{{end}}{{end}}{{end}}{{if .Category}}
-
-CATEGORY:
-   {{.Category}}{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{template "descriptionTemplate" .}}{{end}}{{if .VisibleCommands}}
-
-COMMANDS:{{template "visibleCommandTemplate" .}}{{end}}{{if .VisibleFlagCategories}}
-
-OPTIONS:{{template "visibleFlagCategoryTemplate" .}}{{else if .VisibleFlags}}
-
-OPTIONS:{{template "visibleFlagTemplate" .}}{{end}}{{if .VisiblePersistentFlags}}
-
-GLOBAL OPTIONS:{{template "visiblePersistentFlagTemplate" .}}{{end}}
-`
-
-var FishCompletionTemplate = `# {{ .Command.Name }} fish shell completion
-
-function __fish_{{ .Command.Name }}_no_subcommand --description 'Test if there has been any subcommand yet'
-    for i in (commandline -opc)
-        if contains -- $i{{ range $v := .AllCommands }} {{ $v }}{{ end }}
-            return 1
-        end
-    end
-    return 0
-end
-
-{{ range $v := .Completions }}{{ $v }}
-{{ end }}`
diff --git a/vendor/github.com/urfave/cli/v3/value_source.go b/vendor/github.com/urfave/cli/v3/value_source.go
index 44b0173b..2dcee758 100644
--- a/vendor/github.com/urfave/cli/v3/value_source.go
+++ b/vendor/github.com/urfave/cli/v3/value_source.go
@@ -119,6 +119,7 @@ func (e *envVarValueSource) Key() string {
 }
 
 func (e *envVarValueSource) String() string { return fmt.Sprintf("environment variable %[1]q", e.key) }
+
 func (e *envVarValueSource) GoString() string {
 	return fmt.Sprintf("&envVarValueSource{Key:%[1]q}", e.key)
 }
diff --git a/vendor/go.yaml.in/yaml/v3/parserc.go b/vendor/go.yaml.in/yaml/v3/parserc.go
index 25fe8236..f35829db 100644
--- a/vendor/go.yaml.in/yaml/v3/parserc.go
+++ b/vendor/go.yaml.in/yaml/v3/parserc.go
@@ -226,9 +226,9 @@ func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool
 }
 
 // Parse the production:
-// stream   ::= STREAM-START implicit_document? explicit_document* STREAM-END
 //
-//	************
+//	stream   ::= STREAM-START implicit_document? explicit_document* STREAM-END
+//	             ************
 func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -249,13 +249,11 @@ func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t)
 }
 
 // Parse the productions:
-// implicit_document    ::= block_node DOCUMENT-END*
-//
-//	*
 //
-// explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
-//
-//	*************************
+//	implicit_document    ::= block_node DOCUMENT-END*
+//	                         *
+//	explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+//	                         *************************
 func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool {
 
 	token := peek_token(parser)
@@ -359,9 +357,9 @@ func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t
 }
 
 // Parse the productions:
-// explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 //
-//	***********
+//	explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+//	                                                   ***********
 func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -382,11 +380,10 @@ func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event
 }
 
 // Parse the productions:
-// implicit_document    ::= block_node DOCUMENT-END*
-//
-//	*************
 //
-// explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+//	implicit_document    ::= block_node DOCUMENT-END*
+//	                                    *************
+//	explicit_document    ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
 func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -432,42 +429,32 @@ func yaml_parser_set_event_comments(parser *yaml_parser_t, event *yaml_event_t)
 }
 
 // Parse the productions:
-// block_node_or_indentless_sequence    ::=
-//
-//	ALIAS
-//	*****
-//	| properties (block_content | indentless_block_sequence)?
-//	  **********  *
-//	| block_content | indentless_block_sequence
-//	  *
-//
-// block_node           ::= ALIAS
-//
-//	*****
-//	| properties block_content?
-//	  ********** *
-//	| block_content
-//	  *
-//
-// flow_node            ::= ALIAS
-//
-//	*****
-//	| properties flow_content?
-//	  ********** *
-//	| flow_content
-//	  *
-//
-// properties           ::= TAG ANCHOR? | ANCHOR TAG?
-//
-//	*************************
-//
-// block_content        ::= block_collection | flow_collection | SCALAR
-//
-//	******
 //
-// flow_content         ::= flow_collection | SCALAR
-//
-//	******
+//	block_node_or_indentless_sequence    ::=
+//	                         ALIAS
+//	                         *****
+//	                         | properties (block_content | indentless_block_sequence)?
+//	                           **********  *
+//	                         | block_content | indentless_block_sequence
+//	                           *
+//	block_node           ::= ALIAS
+//	                         *****
+//	                         | properties block_content?
+//	                           ********** *
+//	                         | block_content
+//	                           *
+//	flow_node            ::= ALIAS
+//	                         *****
+//	                         | properties flow_content?
+//	                           ********** *
+//	                         | flow_content
+//	                           *
+//	properties           ::= TAG ANCHOR? | ANCHOR TAG?
+//	                         *************************
+//	block_content        ::= block_collection | flow_collection | SCALAR
+//	                                                              ******
+//	flow_content         ::= flow_collection | SCALAR
+//	                                           ******
 func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool {
 	//defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
 
@@ -697,9 +684,9 @@ func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, i
 }
 
 // Parse the productions:
-// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
 //
-//	********************  *********** *             *********
+//	block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+//	                   ********************  *********** *             *********
 func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 	if first {
 		token := peek_token(parser)
@@ -755,9 +742,9 @@ func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_e
 }
 
 // Parse the productions:
-// indentless_sequence  ::= (BLOCK-ENTRY block_node?)+
 //
-//	*********** *
+//	indentless_sequence  ::= (BLOCK-ENTRY block_node?)+
+//	                          *********** *
 func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -821,15 +808,15 @@ func yaml_parser_split_stem_comment(parser *yaml_parser_t, stem_len int) {
 }
 
 // Parse the productions:
-// block_mapping        ::= BLOCK-MAPPING_START
 //
-//	*******************
-//	((KEY block_node_or_indentless_sequence?)?
-//	  *** *
-//	(VALUE block_node_or_indentless_sequence?)?)*
+//	block_mapping        ::= BLOCK-MAPPING_START
+//	                         *******************
+//	                         ((KEY block_node_or_indentless_sequence?)?
+//	                           *** *
+//	                         (VALUE block_node_or_indentless_sequence?)?)*
 //
-//	BLOCK-END
-//	*********
+//	                         BLOCK-END
+//	                         *********
 func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 	if first {
 		token := peek_token(parser)
@@ -896,13 +883,14 @@ func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_even
 }
 
 // Parse the productions:
-// block_mapping        ::= BLOCK-MAPPING_START
 //
-//	((KEY block_node_or_indentless_sequence?)?
+//	block_mapping        ::= BLOCK-MAPPING_START
+//
+//	                          ((KEY block_node_or_indentless_sequence?)?
 //
-//	(VALUE block_node_or_indentless_sequence?)?)*
-//	 ***** *
-//	BLOCK-END
+//	                          (VALUE block_node_or_indentless_sequence?)?)*
+//	                           ***** *
+//	                          BLOCK-END
 func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -929,19 +917,17 @@ func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_ev
 }
 
 // Parse the productions:
-// flow_sequence        ::= FLOW-SEQUENCE-START
-//
-//	*******************
-//	(flow_sequence_entry FLOW-ENTRY)*
-//	 *                   **********
-//	flow_sequence_entry?
-//	*
-//	FLOW-SEQUENCE-END
-//	*****************
 //
-// flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-//
-//	*
+//	flow_sequence        ::= FLOW-SEQUENCE-START
+//	                         *******************
+//	                         (flow_sequence_entry FLOW-ENTRY)*
+//	                          *                   **********
+//	                         flow_sequence_entry?
+//	                         *
+//	                         FLOW-SEQUENCE-END
+//	                         *****************
+//	flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//	                         *
 func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 	if first {
 		token := peek_token(parser)
@@ -1005,9 +991,9 @@ func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_ev
 }
 
 // Parse the productions:
-// flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 //
-//	*** *
+//	flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//	                                     *** *
 func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -1026,9 +1012,9 @@ func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, ev
 }
 
 // Parse the productions:
-// flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 //
-//	***** *
+//	flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//	                                                     ***** *
 func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -1050,9 +1036,9 @@ func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t,
 }
 
 // Parse the productions:
-// flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
 //
-//	*
+//	flow_sequence_entry  ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//	                                                                     *
 func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool {
 	token := peek_token(parser)
 	if token == nil {
@@ -1068,18 +1054,17 @@ func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, ev
 }
 
 // Parse the productions:
-// flow_mapping         ::= FLOW-MAPPING-START
-//
-//	******************
-//	(flow_mapping_entry FLOW-ENTRY)*
-//	 *                  **********
-//	flow_mapping_entry?
-//	******************
-//	FLOW-MAPPING-END
-//	****************
 //
-// flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-//   - *** *
+//	flow_mapping         ::= FLOW-MAPPING-START
+//	                         ******************
+//	                         (flow_mapping_entry FLOW-ENTRY)*
+//	                          *                  **********
+//	                         flow_mapping_entry?
+//	                         ******************
+//	                         FLOW-MAPPING-END
+//	                         ****************
+//	flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//	                         *           *** *
 func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
 	if first {
 		token := peek_token(parser)
@@ -1144,8 +1129,9 @@ func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event
 }
 
 // Parse the productions:
-// flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
-//   - ***** *
+//
+//	flow_mapping_entry   ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//	                                  *                  ***** *
 func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool {
 	token := peek_token(parser)
 	if token == nil {
diff --git a/vendor/go.yaml.in/yaml/v3/yamlh.go b/vendor/go.yaml.in/yaml/v3/yamlh.go
index f59aa40f..07c44236 100644
--- a/vendor/go.yaml.in/yaml/v3/yamlh.go
+++ b/vendor/go.yaml.in/yaml/v3/yamlh.go
@@ -433,21 +433,19 @@ type yaml_document_t struct {
 
 // The prototype of a read handler.
 //
-// The read handler is called when the parser needs to read more bytes from the
-// source. The handler should write not more than size bytes to the buffer.
-// The number of written bytes should be set to the size_read variable.
+//	The read handler is called when the parser needs to read more bytes from the
+//	source. The handler should write not more than size bytes to the buffer.
+//	The number of written bytes should be set to the size_read variable.
 //
-// [in,out]   data        A pointer to an application data specified by
+//	[in,out]   data        A pointer to an application data specified by
+//	                       yaml_parser_set_input().
+//	[out]      buffer      The buffer to write the data from the source.
+//	[in]       size        The size of the buffer.
+//	[out]      size_read   The actual number of bytes read from the source.
 //
-//	yaml_parser_set_input().
-//
-// [out]      buffer      The buffer to write the data from the source.
-// [in]       size        The size of the buffer.
-// [out]      size_read   The actual number of bytes read from the source.
-//
-// On success, the handler should return 1.  If the handler failed,
-// the returned value should be 0. On EOF, the handler should set the
-// size_read to 0 and return 1.
+//	On success, the handler should return 1.  If the handler failed,
+//	the returned value should be 0. On EOF, the handler should set the
+//	size_read to 0 and return 1.
 type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error)
 
 // This structure holds information about a potential simple key.
@@ -655,19 +653,17 @@ type yaml_comment_t struct {
 
 // The prototype of a write handler.
 //
-// The write handler is called when the emitter needs to flush the accumulated
-// characters to the output.  The handler should write @a size bytes of the
-// @a buffer to the output.
-//
-// @param[in,out]   data        A pointer to an application data specified by
-//
-//	yaml_emitter_set_output().
+//	The write handler is called when the emitter needs to flush the accumulated
+//	characters to the output.  The handler should write @a size bytes of the
+//	@a buffer to the output.
 //
-// @param[in]       buffer      The buffer with bytes to be written.
-// @param[in]       size        The size of the buffer.
+//	@param[in,out]   data        A pointer to an application data specified by
+//	                             yaml_emitter_set_output().
+//	@param[in]       buffer      The buffer with bytes to be written.
+//	@param[in]       size        The size of the buffer.
 //
-// @returns On success, the handler should return @c 1.  If the handler failed,
-// the returned value should be @c 0.
+//	@returns On success, the handler should return @c 1.  If the handler failed,
+//	the returned value should be @c 0.
 type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error
 
 type yaml_emitter_state_t int
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 921bf7f5..297f90ac 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -128,9 +128,6 @@ github.com/aws/smithy-go/traits
 github.com/aws/smithy-go/transport/http
 github.com/aws/smithy-go/transport/http/internal/io
 github.com/aws/smithy-go/waiter
-# github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
-## explicit
-github.com/davecgh/go-spew/spew
 # github.com/fxamacker/cbor/v2 v2.9.1
 ## explicit; go 1.20
 github.com/fxamacker/cbor/v2
@@ -208,15 +205,14 @@ github.com/onsi/gomega/types
 github.com/pkg/sftp
 github.com/pkg/sftp/internal/encoding/ssh/filexfer
 github.com/pkg/sftp/internal/encoding/ssh/filexfer/openssh
-# github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2
-## explicit
-github.com/pmezard/go-difflib/difflib
-# github.com/stretchr/testify v1.11.1
+# github.com/stretchr/testify v1.12.1
 ## explicit; go 1.17
 github.com/stretchr/testify/assert
 github.com/stretchr/testify/assert/yaml
+github.com/stretchr/testify/internal/difflib
+github.com/stretchr/testify/internal/spew
 github.com/stretchr/testify/require
-# github.com/urfave/cli/v3 v3.10.1
+# github.com/urfave/cli/v3 v3.14.0
 ## explicit; go 1.22
 github.com/urfave/cli/v3
 # github.com/x448/float16 v0.8.4
@@ -225,7 +221,7 @@ github.com/x448/float16
 # go.yaml.in/yaml/v2 v2.4.4
 ## explicit; go 1.15
 go.yaml.in/yaml/v2
-# go.yaml.in/yaml/v3 v3.0.4
+# go.yaml.in/yaml/v3 v3.0.5
 ## explicit; go 1.16
 go.yaml.in/yaml/v3
 # golang.org/x/crypto v0.58.0

From e24f37a84f63e625dac1a629c870dac48347dafa Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 11:09:59 +0000
Subject: [PATCH 5/6] chore(deps): Bump github.com/onsi/gomega from 1.42.1 to
 1.44.0

Bumps [github.com/onsi/gomega](https://github.com/onsi/gomega) from 1.42.1 to 1.44.0.
- [Release notes](https://github.com/onsi/gomega/releases)
- [Changelog](https://github.com/onsi/gomega/blob/master/CHANGELOG.md)
- [Commits](https://github.com/onsi/gomega/compare/v1.42.1...v1.44.0)

---
updated-dependencies:
- dependency-name: github.com/onsi/gomega
  dependency-version: 1.44.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Carlos Eduardo Arango Gutierrez <eduardoa@nvidia.com>
---
 go.mod                                        |   2 +-
 go.sum                                        |   4 +-
 vendor/github.com/onsi/gomega/.gitignore      |   3 +-
 vendor/github.com/onsi/gomega/CHANGELOG.md    |  34 ++++
 vendor/github.com/onsi/gomega/README.md       |   7 +-
 vendor/github.com/onsi/gomega/RELEASING.md    | 166 +++++++++++++++---
 vendor/github.com/onsi/gomega/gomega_dsl.go   |   2 +-
 vendor/github.com/onsi/gomega/matchers.go     |   6 +
 .../onsi/gomega/matchers/attributes_slice.go  |   8 +-
 .../gomega/matchers/be_numerically_matcher.go |  58 +++---
 .../gomega/matchers/have_exact_elements.go    |  11 +-
 .../onsi/gomega/matchers/have_key_matcher.go  |  42 +++--
 .../matchers/have_key_with_value_matcher.go   |  62 +++----
 .../gomega/matchers/match_json_matcher.go     |  98 ++++++++++-
 .../onsi/gomega/matchers/match_xml_matcher.go |  20 ++-
 .../gomega/matchers/match_yaml_matcher.go     | 106 +++++++++--
 .../onsi/gomega/matchers/type_support.go      |  22 +--
 vendor/modules.txt                            |   2 +-
 18 files changed, 498 insertions(+), 155 deletions(-)

diff --git a/go.mod b/go.mod
index 32e0a290..4b43906a 100644
--- a/go.mod
+++ b/go.mod
@@ -10,7 +10,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/ssm v1.79.3
 	github.com/mattn/go-isatty v0.0.23
 	github.com/onsi/ginkgo/v2 v2.32.0
-	github.com/onsi/gomega v1.42.1
+	github.com/onsi/gomega v1.44.0
 	github.com/pkg/sftp v1.13.11
 	github.com/stretchr/testify v1.12.1
 	github.com/urfave/cli/v3 v3.14.0
diff --git a/go.sum b/go.sum
index 42e57970..5dd45788 100644
--- a/go.sum
+++ b/go.sum
@@ -81,8 +81,8 @@ github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee h1:W5t00kpgFd
 github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/onsi/ginkgo/v2 v2.32.0 h1:Hw7s2pVrQo/8Yz5N77qdnpHaoc+c6cC9WIV1Jce+J6E=
 github.com/onsi/ginkgo/v2 v2.32.0/go.mod h1:+aXOY+vzZ5mu2iI2HpTZUPmM//oQfsNFX6gU9kNcA44=
-github.com/onsi/gomega v1.42.1 h1:iN1rCUX+44NZ1Dc97MPoeFYbFR0vh8zxoxMFwKdyZ6I=
-github.com/onsi/gomega v1.42.1/go.mod h1:REff/hsDsodHoKlWsP2mAPhu1+5/6hVYNf9rIEBpeSg=
+github.com/onsi/gomega v1.44.0 h1:eAiGl3Pw5jz5GQdDff0BcxYpAX1JxW8xD7mFUuwNfZQ=
+github.com/onsi/gomega v1.44.0/go.mod h1:e/C2HwaZ1DhvjzXXuFhcR7hY7Sh9pl7MmoWKEjzwcdA=
 github.com/pkg/sftp v1.13.11 h1:0N92SLTB8JqASJB14ZLHHzFnBV8mG9zw4K7jghEFWuE=
 github.com/pkg/sftp v1.13.11/go.mod h1:uNkH9roSXglNJqM+glJJi+TQXQUm0fXFWqCFmT8hsN0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
diff --git a/vendor/github.com/onsi/gomega/.gitignore b/vendor/github.com/onsi/gomega/.gitignore
index 425d0a50..b3003b4e 100644
--- a/vendor/github.com/onsi/gomega/.gitignore
+++ b/vendor/github.com/onsi/gomega/.gitignore
@@ -4,4 +4,5 @@
 .idea
 gomega.iml
 TODO
-.vscode
\ No newline at end of file
+.vscode
+/.release/
diff --git a/vendor/github.com/onsi/gomega/CHANGELOG.md b/vendor/github.com/onsi/gomega/CHANGELOG.md
index 7cd26c2c..07f33258 100644
--- a/vendor/github.com/onsi/gomega/CHANGELOG.md
+++ b/vendor/github.com/onsi/gomega/CHANGELOG.md
@@ -1,3 +1,37 @@
+## Unreleased
+
+### Features
+
+### Fixes
+
+### Maintenance
+
+## 1.44.0
+
+### Fixes
+- `BeNumerically` compares signed and unsigned integers by value: `-1` no longer equals `uint64(math.MaxUint64)` and `uint(5)` is now greater than `-3` (#925) [26e3c6b]
+- `BeNumerically("~")` no longer overflows when computing the distance between extreme integers (#928) [1955764]
+- `BeNumerically("==", x, threshold)` now honors the threshold for floats, as it already did for integers (#927) [10e2aca]
+- `HaveKeyWithValue` succeeds if any key accepted by the key matcher has a matching value, rather than depending on map iteration order (#929) [ffc577a]
+- `HaveKey` and `HaveKeyWithValue` treat key and value matcher errors like `ContainElement` does: a match wins, and an error is only reported when nothing matches (#926) [dc91598]
+- `MatchJSON` no longer treats numbers too large for a float64 as equal to one another (#930) [9d619a5]
+- `MatchJSON` compares integers beyond ±2^53 exactly, so neighboring large integers (e.g. IDs) no longer match; all other numbers are still compared as float64s (#931) [8ef1aa7, 630fe12]
+- `HaveExactElements` reports missing or extra elements that start at index 0, and reports the first extra element's index rather than the last (#934) [af1b777]
+- `MatchYAML` compares every document in a multi-document stream rather than only the first; empty documents (e.g. a leading or trailing `---`) are ignored (#933) [2773796]
+- `MatchXML` ignores namespace prefixes: elements and attributes are compared by namespace URI, and the URIs declared on each element must match whatever prefix they are bound to (#932) [c0dbd89, 2565350]
+
+## 1.43.1
+
+### Maintenance
+- Update go.yaml.in/yaml/v3 to v3.0.5 [d547015]
+- Releases are now cut by a GitHub Actions workflow (Actions -> Release -> Run workflow) rather than by hand, with changelog entries collected under `## Unreleased` as the work happens.  Releases still ship the stripped-down tree on `master-lite` - tests removed and Ginkgo dropped from `go.mod` - and the workflow now builds it and checks it on every push.  See RELEASING.md. [e9dc84d]
+
+## 1.43.0
+
+### Features
+
+Add gomock adaptor extension for using Gomega matchers with gomock
+
 ## 1.42.1
 
 Bump Dependencies
diff --git a/vendor/github.com/onsi/gomega/README.md b/vendor/github.com/onsi/gomega/README.md
index 6eb36fdf..ac545907 100644
--- a/vendor/github.com/onsi/gomega/README.md
+++ b/vendor/github.com/onsi/gomega/README.md
@@ -1,6 +1,9 @@
-![Gomega: Ginkgo's Preferred Matcher Library](http://onsi.github.io/gomega/images/gomega.png)
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="docs/images/gomega-dark.png">
+  <img alt="Gomega: Ginkgo's Preferred Matcher Library" src="docs/images/gomega.png">
+</picture>
 
-[![test](https://github.com/onsi/gomega/actions/workflows/test.yml/badge.svg)](https://github.com/onsi/gomega/actions/workflows/test.yml)
+[![test](https://github.com/onsi/gomega/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/onsi/gomega/actions/workflows/test.yml?query=branch%3Amaster) [![Gomega Docs](docs/images/docs-badge.svg)](https://onsi.github.io/gomega/) [![Sponsor onsi](docs/images/sponsor-badge.svg)](https://github.com/sponsors/onsi)
 
 Jump straight to the [docs](http://onsi.github.io/gomega/) to learn about Gomega, including a list of [all available matchers](http://onsi.github.io/gomega/#provided-matchers).
 
diff --git a/vendor/github.com/onsi/gomega/RELEASING.md b/vendor/github.com/onsi/gomega/RELEASING.md
index 9973fff4..fdbeb37c 100644
--- a/vendor/github.com/onsi/gomega/RELEASING.md
+++ b/vendor/github.com/onsi/gomega/RELEASING.md
@@ -1,23 +1,143 @@
-A Gomega release is a tagged sha and a GitHub release.  To cut a release:
-
-1. Ensure CHANGELOG.md is up to date.
-  - Use 
-    ```bash
-    LAST_VERSION=$(git tag --sort=version:refname | tail -n1)
-    CHANGES=$(git log --pretty=format:'- %s [%h]' HEAD...$LAST_VERSION)
-    echo -e "## NEXT\n\n$CHANGES\n\n### Features\n\n### Fixes\n\n### Maintenance\n\n$(cat CHANGELOG.md)" > CHANGELOG.md
-    ```
-   to update the changelog
-  - Categorize the changes into
-    - Breaking Changes (requires a major version)
-    - New Features (minor version)
-    - Fixes (fix version)
-    - Maintenance (which in general should not be mentioned in `CHANGELOG.md` as they have no user impact)
-1. Update GOMEGA_VERSION in `gomega_dsl.go`
-1. Commit, push, and release:
-  ```
-  git commit -m "vM.m.p"
-  git push
-  gh release create "vM.m.p"
-  git fetch --tags origin master
-  ```
\ No newline at end of file
+# Releasing Gomega
+
+A release is one GitHub Actions run: **Actions → Release → Run workflow → bump: patch | minor**,
+from `master`. From the command line:
+
+```bash
+gh workflow run release.yml -f bump=patch   # or -f bump=minor
+```
+
+The run:
+
+1. Runs the whole test workflow (`test.yml`). Nothing else happens unless it passes.
+2. Runs `scripts/release.sh`, which
+   - computes the next version from `GOMEGA_VERSION` in `gomega_dsl.go`,
+   - renames `## Unreleased` in `CHANGELOG.md` to `## X.Y.Z` (dropping empty `###` subsections) and
+     puts a fresh, empty `## Unreleased` above it,
+   - writes `GOMEGA_VERSION` and stamps the version into every plugin manifest
+     (`plugins/*/.claude-plugin/plugin.json`), so the Claude Code plugin ships in lockstep,
+   - commits that on `master` as `vX.Y.Z (full)`, as `github-actions[bot]`,
+   - builds the released tree on `master-lite` and tags **that** commit `vX.Y.Z` (see below),
+   - pushes `master`, `master-lite`, and the tag together (`git push --atomic`, fast-forward only),
+   - creates the GitHub release `vX.Y.Z`, whose notes are the body of `## X.Y.Z`.
+
+## master and master-lite
+
+Gomega uses Ginkgo for its own tests, and the go toolchain pulls a dependency's *test* dependencies
+into consuming projects as indirect requirements — so a project that uses only Gomega would end up
+with all of Ginkgo in its `go.mod`. Since 1.40.0, releases therefore ship a stripped-down tree:
+
+- `master` holds the real repository, tests and all. The release commit there is `vX.Y.Z (full)`,
+  and it is **not** what the go toolchain resolves.
+- `master-lite` holds the released trees: the same tree with every `_test.go` file deleted and
+  `go.mod` re-tidied, which drops Ginkgo. `scripts/strip-tests.sh` does that, and asserts that the
+  result still builds and no longer requires Ginkgo.
+- Each release adds one commit to `master-lite`: a merge whose tree is the stripped tree and whose
+  parents are the previous `master-lite` commit and the `vX.Y.Z (full)` commit on `master`. So
+  `master-lite`'s history connects to master's, and `git log master-lite` reads as the release
+  history.
+- The `vX.Y.Z` tag is on that `master-lite` commit. It is what `go get github.com/onsi/gomega`
+  resolves, so `go build` never even sees the test files.
+
+The test workflow's **Check the released (lite) tree** job runs `scripts/strip-tests.sh` on every
+push. If a non-test file ever imports Ginkgo, that job fails long before release day — the released
+module could not be built otherwise.
+
+Release tags are not on `master`, so `git describe` on master does not find them. `GOMEGA_VERSION`
+in `gomega_dsl.go` is the version of record, and `git tag --sort=version:refname | tail -n1` names
+the latest release.
+
+If this release process ever causes unexpected changes for a project, please open an issue.
+
+### Never merge master-lite into master
+
+`master-lite` always looks ahead of `master`, because its newest commit merges master's release
+commit. But its *tree* has the tests taken out, so merging or rebasing it back into master deletes
+every `_test.go` file and drops Ginkgo from `go.mod` — cleanly, with no conflicts. GitHub's
+"master-lite had recent pushes — Compare & pull request" banner is the one click to avoid.
+
+Nothing you do locally needs `master-lite`: the release workflow writes it from a fresh checkout. A
+stale local `master-lite` branch is harmless, and you can delete it.
+
+`scripts/check-full-tree.sh` guards against a stripped master: it asserts that a checkout has
+`_test.go` files and that `go.mod` requires Ginkgo. The test workflow runs it on every push and
+`scripts/release.sh` runs it before cutting a release, so a stripped master gets reported plainly
+instead of turning into a test run with nothing in it.
+
+### Cutting one release after another
+
+Work on master as usual between releases. The `vX.Y.Z (full)` commit the workflow pushed is an
+ordinary commit: `git pull` fast-forwards onto it, it carries the released `CHANGELOG.md` and
+`GOMEGA_VERSION`, and you add new `## Unreleased` entries above it. The next release repeats the
+same two steps — a new `vX.Y.Z (full)` commit on master, and a new merge on `master-lite` whose
+tree is the stripped version of it, carrying the tag.
+
+Nothing accumulates between releases, and nothing needs reconciling in either direction: each
+`master-lite` commit's tree is built from the release commit rather than merged into the previous
+one, so `git diff vX.Y.Z vX.Y.Z+1` over two releases shows only the real changes.
+
+## The changelog
+
+`CHANGELOG.md` starts with an `## Unreleased` section:
+
+```markdown
+## Unreleased
+
+### Features
+
+### Fixes
+
+### Maintenance
+
+## 1.43.0
+...
+```
+
+Add an entry under `## Unreleased` with each user-facing change, as you make it. Never edit a
+released section. Empty subsections are dropped when the section is released, so leaving
+`### Maintenance` empty costs nothing.
+
+If `## Unreleased` has no entries (only blank lines and `###` headings), the release stops before
+changing anything — and so does a re-run after a successful release.
+
+To draft entries from the commits since the last release:
+
+```bash
+git log --pretty=format:'- %s [%h]' "$(git tag --sort=version:refname | tail -n1)"..HEAD
+```
+
+Categorize what you keep into
+
+- Breaking changes (these need a major version, which this workflow does not cut)
+- `### Features` (minor version)
+- `### Fixes` (patch version)
+- `### Maintenance` (in general, changes with no user impact don't belong in the changelog at all)
+
+## If a release fails
+
+Open the failed run and click **Re-run failed jobs**. A re-run checks out the same commit as the
+first attempt and computes the same version. It resumes based on what already exists:
+
+| Where it failed | What a re-run does |
+|---|---|
+| Tests, or before the push | Nothing reached GitHub. The re-run starts over. |
+| The push (master or master-lite moved during the run) | The re-run fails the same way. Start a new run from the current master. |
+| After the push (the tag `vX.Y.Z` is on GitHub) | The re-run builds from the tag instead of making new commits. |
+| Creating the GitHub release | The release is created, or its notes are refreshed if it already exists. |
+
+Both branches and the tag are pushed together, so the tag being on GitHub means both release
+commits are there too.
+
+## Trying the release script locally
+
+`GOMEGA_RELEASE_DRY_RUN=1 scripts/release.sh patch` does the whole release locally — the changelog
+and version rewrites, the `master` commit, the stripped `master-lite` commit and the tag on it —
+then skips the push and the GitHub release. It still checks `origin` for an existing tag and needs
+`origin/master-lite`, so run it in a throwaway clone whose `origin` is a local bare repository, not
+in your working copy.
+
+`scripts/strip-tests.sh` rewrites the working tree in place, so run *it* only on a throwaway
+checkout too.
+
+The version and changelog logic lives in `scripts/release`, with its own Ginkgo suite
+(`scripts/release/release_test.go`) that runs with the rest of the suites.
diff --git a/vendor/github.com/onsi/gomega/gomega_dsl.go b/vendor/github.com/onsi/gomega/gomega_dsl.go
index db84085b..cf4eaefa 100644
--- a/vendor/github.com/onsi/gomega/gomega_dsl.go
+++ b/vendor/github.com/onsi/gomega/gomega_dsl.go
@@ -22,7 +22,7 @@ import (
 	"github.com/onsi/gomega/types"
 )
 
-const GOMEGA_VERSION = "1.42.1"
+const GOMEGA_VERSION = "1.44.0"
 
 const nilGomegaPanic = `You are trying to make an assertion, but haven't registered Gomega's fail handler.
 If you're using Ginkgo then you probably forgot to put your assertion in an It().
diff --git a/vendor/github.com/onsi/gomega/matchers.go b/vendor/github.com/onsi/gomega/matchers.go
index bf572260..e3e01f66 100644
--- a/vendor/github.com/onsi/gomega/matchers.go
+++ b/vendor/github.com/onsi/gomega/matchers.go
@@ -291,6 +291,8 @@ func HaveSuffix(suffix string, args ...any) types.GomegaMatcher {
 // MatchJSON succeeds if actual is a string or stringer of JSON that matches
 // the expected JSON.  The JSONs are decoded and the resulting objects are compared via
 // reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter.
+// Numbers are compared as float64s, except for integers too large to be represented
+// exactly by a float64 (beyond ±2^53), which are compared exactly.
 func MatchJSON(json any) types.GomegaMatcher {
 	return &matchers.MatchJSONMatcher{
 		JSONToMatch: json,
@@ -300,6 +302,8 @@ func MatchJSON(json any) types.GomegaMatcher {
 // MatchXML succeeds if actual is a string or stringer of XML that matches
 // the expected XML.  The XMLs are decoded and the resulting objects are compared via
 // reflect.DeepEqual so things like whitespaces shouldn't matter.
+// Namespace prefixes are ignored: element and attribute names are compared by
+// namespace URI, and the namespace URIs declared on each element must match.
 func MatchXML(xml any) types.GomegaMatcher {
 	return &matchers.MatchXMLMatcher{
 		XMLToMatch: xml,
@@ -309,6 +313,8 @@ func MatchXML(xml any) types.GomegaMatcher {
 // MatchYAML succeeds if actual is a string or stringer of YAML that matches
 // the expected YAML.  The YAML's are decoded and the resulting objects are compared via
 // reflect.DeepEqual so things like key-ordering and whitespace shouldn't matter.
+// Multi-document YAML streams are compared document by document; empty documents
+// (e.g. from a leading or trailing "---") are ignored.
 func MatchYAML(yaml any) types.GomegaMatcher {
 	return &matchers.MatchYAMLMatcher{
 		YAMLToMatch: yaml,
diff --git a/vendor/github.com/onsi/gomega/matchers/attributes_slice.go b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
index 355b362f..ea8e5ba1 100644
--- a/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
+++ b/vendor/github.com/onsi/gomega/matchers/attributes_slice.go
@@ -9,6 +9,12 @@ type attributesSlice []xml.Attr
 
 func (attrs attributesSlice) Len() int { return len(attrs) }
 func (attrs attributesSlice) Less(i, j int) bool {
-	return strings.Compare(attrs[i].Name.Local, attrs[j].Name.Local) == -1
+	if attrs[i].Name.Local != attrs[j].Name.Local {
+		return strings.Compare(attrs[i].Name.Local, attrs[j].Name.Local) == -1
+	}
+	if attrs[i].Name.Space != attrs[j].Name.Space {
+		return strings.Compare(attrs[i].Name.Space, attrs[j].Name.Space) == -1
+	}
+	return strings.Compare(attrs[i].Value, attrs[j].Value) == -1
 }
 func (attrs attributesSlice) Swap(i, j int) { attrs[i], attrs[j] = attrs[j], attrs[i] }
diff --git a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
index 7e6ce154..02839f34 100644
--- a/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/be_numerically_matcher.go
@@ -5,6 +5,7 @@ package matchers
 import (
 	"fmt"
 	"math"
+	"math/big"
 
 	"github.com/onsi/gomega/format"
 )
@@ -60,18 +61,12 @@ func (matcher *BeNumericallyMatcher) Match(actual any) (success bool, err error)
 			secondOperand = toFloat(matcher.CompareTo[1])
 		}
 		success = matcher.matchFloats(toFloat(actual), toFloat(matcher.CompareTo[0]), secondOperand)
-	} else if isInteger(actual) {
-		var secondOperand int64 = 0
+	} else if isInteger(actual) || isUnsignedInteger(actual) {
+		var threshold any = 0
 		if len(matcher.CompareTo) == 2 {
-			secondOperand = toInteger(matcher.CompareTo[1])
+			threshold = matcher.CompareTo[1]
 		}
-		success = matcher.matchIntegers(toInteger(actual), toInteger(matcher.CompareTo[0]), secondOperand)
-	} else if isUnsignedInteger(actual) {
-		var secondOperand uint64 = 0
-		if len(matcher.CompareTo) == 2 {
-			secondOperand = toUnsignedInteger(matcher.CompareTo[1])
-		}
-		success = matcher.matchUnsignedIntegers(toUnsignedInteger(actual), toUnsignedInteger(matcher.CompareTo[0]), secondOperand)
+		success = matcher.matchIntegers(toBigInt(actual), toBigInt(matcher.CompareTo[0]), threshold)
 	} else {
 		return false, fmt.Errorf("Failed to compare:\n%s\n%s:\n%s", format.Object(actual, 1), matcher.Comparator, format.Object(matcher.CompareTo[0], 1))
 	}
@@ -79,40 +74,35 @@ func (matcher *BeNumericallyMatcher) Match(actual any) (success bool, err error)
 	return success, nil
 }
 
-func (matcher *BeNumericallyMatcher) matchIntegers(actual, compareTo, threshold int64) (success bool) {
+// matchIntegers compares signed and unsigned integers by their exact mathematical value, using math/big so
+// that neither mixing signedness nor computing the distance between the two values can overflow
+func (matcher *BeNumericallyMatcher) matchIntegers(actual, compareTo *big.Int, threshold any) (success bool) {
 	switch matcher.Comparator {
 	case "==", "~":
-		diff := actual - compareTo
-		return -threshold <= diff && diff <= threshold
+		distance := new(big.Int).Sub(actual, compareTo)
+		return isWithinThreshold(distance.Abs(distance), threshold)
 	case ">":
-		return (actual > compareTo)
+		return actual.Cmp(compareTo) > 0
 	case ">=":
-		return (actual >= compareTo)
+		return actual.Cmp(compareTo) >= 0
 	case "<":
-		return (actual < compareTo)
+		return actual.Cmp(compareTo) < 0
 	case "<=":
-		return (actual <= compareTo)
+		return actual.Cmp(compareTo) <= 0
 	}
 	return false
 }
 
-func (matcher *BeNumericallyMatcher) matchUnsignedIntegers(actual, compareTo, threshold uint64) (success bool) {
-	switch matcher.Comparator {
-	case "==", "~":
-		if actual < compareTo {
-			actual, compareTo = compareTo, actual
+// isWithinThreshold reports whether the (non-negative) distance is no greater than the threshold, which may be any number
+func isWithinThreshold(distance *big.Int, threshold any) bool {
+	if isFloat(threshold) {
+		t := toFloat(threshold)
+		if math.IsNaN(t) {
+			return false
 		}
-		return actual-compareTo <= threshold
-	case ">":
-		return (actual > compareTo)
-	case ">=":
-		return (actual >= compareTo)
-	case "<":
-		return (actual < compareTo)
-	case "<=":
-		return (actual <= compareTo)
+		return new(big.Float).SetInt(distance).Cmp(big.NewFloat(t)) <= 0
 	}
-	return false
+	return distance.Cmp(toBigInt(threshold)) <= 0
 }
 
 func (matcher *BeNumericallyMatcher) matchFloats(actual, compareTo, threshold float64) (success bool) {
@@ -120,6 +110,10 @@ func (matcher *BeNumericallyMatcher) matchFloats(actual, compareTo, threshold fl
 	case "~":
 		return math.Abs(actual-compareTo) <= threshold
 	case "==":
+		// an explicit threshold is honored, as it is for integers; without one == means exact equality
+		if len(matcher.CompareTo) == 2 {
+			return math.Abs(actual-compareTo) <= threshold
+		}
 		return (actual == compareTo)
 	case ">":
 		return (actual > compareTo)
diff --git a/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go b/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go
index 8b2d297c..18f7b284 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_exact_elements.go
@@ -79,7 +79,7 @@ func (matcher *HaveExactElementsMatcher) Match(actual any) (success bool, err er
 		if i >= lenMatchers {
 			matcher.extraIndex = i
 			success = false
-			continue
+			return
 		}
 
 		if i >= lenValues {
@@ -110,10 +110,10 @@ func (matcher *HaveExactElementsMatcher) Match(actual any) (success bool, err er
 
 func (matcher *HaveExactElementsMatcher) FailureMessage(actual any) (message string) {
 	message = format.Message(actual, "to have exact elements with", presentable(matcher.Elements))
-	if matcher.missingIndex > 0 {
+	if matcher.missingIndex >= 0 {
 		message = fmt.Sprintf("%s\nthe missing elements start from index %d", message, matcher.missingIndex)
 	}
-	if matcher.extraIndex > 0 {
+	if matcher.extraIndex >= 0 {
 		message = fmt.Sprintf("%s\nthe extra elements start from index %d", message, matcher.extraIndex)
 	}
 	if len(matcher.mismatchFailures) != 0 {
@@ -131,6 +131,7 @@ func (matcher *HaveExactElementsMatcher) NegatedFailureMessage(actual any) (mess
 
 func (matcher *HaveExactElementsMatcher) resetState() {
 	matcher.mismatchFailures = nil
-	matcher.missingIndex = 0
-	matcher.extraIndex = 0
+	// -1 means "no missing/extra elements"; 0 is a valid starting index
+	matcher.missingIndex = -1
+	matcher.extraIndex = -1
 }
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
index 16630c18..5b27babe 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_matcher.go
@@ -24,31 +24,41 @@ func (matcher *HaveKeyMatcher) Match(actual any) (success bool, err error) {
 		keyMatcher = &EqualMatcher{Expected: matcher.Key}
 	}
 
+	// As with ContainElement, a key the key matcher accepts wins regardless of
+	// errors on other keys; the matcher's (last) error is only reported when
+	// no key matches.
+	var lastError error
 	if miter.IsSeq2(actual) {
-		var success bool
-		var err error
+		found := false
 		miter.IterateKV(actual, func(k, v reflect.Value) bool {
-			success, err = keyMatcher.Match(k.Interface())
+			success, err := keyMatcher.Match(k.Interface())
 			if err != nil {
-				err = fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error())
-				return false
+				lastError = err
+				return true
 			}
-			return !success
+			found = success
+			return !found
 		})
-		return success, err
-	}
-
-	keys := reflect.ValueOf(actual).MapKeys()
-	for i := range keys {
-		success, err := keyMatcher.Match(keys[i].Interface())
-		if err != nil {
-			return false, fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error())
-		}
-		if success {
+		if found {
 			return true, nil
 		}
+	} else {
+		keys := reflect.ValueOf(actual).MapKeys()
+		for i := range keys {
+			success, err := keyMatcher.Match(keys[i].Interface())
+			if err != nil {
+				lastError = err
+				continue
+			}
+			if success {
+				return true, nil
+			}
+		}
 	}
 
+	if lastError != nil {
+		return false, fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, lastError.Error())
+	}
 	return false, nil
 }
 
diff --git a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
index 0cd70815..29410a5f 100644
--- a/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/have_key_with_value_matcher.go
@@ -30,44 +30,46 @@ func (matcher *HaveKeyWithValueMatcher) Match(actual any) (success bool, err err
 		valueMatcher = &EqualMatcher{Expected: matcher.Value}
 	}
 
+	// As with ContainElement, an entry whose key and value both match wins
+	// regardless of errors on other entries; the (last) key or value matcher
+	// error is only reported when no entry matches.
+	var lastError error
+	entryMatches := func(k, v reflect.Value) bool {
+		success, err := keyMatcher.Match(k.Interface())
+		if err != nil {
+			lastError = fmt.Errorf("HaveKeyWithValue's key matcher failed with:\n%s%s", format.Indent, err.Error())
+			return false
+		}
+		if !success {
+			return false
+		}
+		success, err = valueMatcher.Match(v.Interface())
+		if err != nil {
+			lastError = fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error())
+			return false
+		}
+		return success
+	}
+
 	if miter.IsSeq2(actual) {
-		var success bool
-		var err error
+		found := false
 		miter.IterateKV(actual, func(k, v reflect.Value) bool {
-			success, err = keyMatcher.Match(k.Interface())
-			if err != nil {
-				err = fmt.Errorf("HaveKey's key matcher failed with:\n%s%s", format.Indent, err.Error())
-				return false
-			}
-			if success {
-				success, err = valueMatcher.Match(v.Interface())
-				if err != nil {
-					err = fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error())
-					return false
-				}
-			}
-			return !success
+			found = entryMatches(k, v)
+			return !found
 		})
-		return success, err
-	}
-
-	keys := reflect.ValueOf(actual).MapKeys()
-	for i := range keys {
-		success, err := keyMatcher.Match(keys[i].Interface())
-		if err != nil {
-			return false, fmt.Errorf("HaveKeyWithValue's key matcher failed with:\n%s%s", format.Indent, err.Error())
+		if found {
+			return true, nil
 		}
-		if success {
-			actualValue := reflect.ValueOf(actual).MapIndex(keys[i])
-			success, err := valueMatcher.Match(actualValue.Interface())
-			if err != nil {
-				return false, fmt.Errorf("HaveKeyWithValue's value matcher failed with:\n%s%s", format.Indent, err.Error())
+	} else {
+		value := reflect.ValueOf(actual)
+		for _, k := range value.MapKeys() {
+			if entryMatches(k, value.MapIndex(k)) {
+				return true, nil
 			}
-			return success, nil
 		}
 	}
 
-	return false, nil
+	return false, lastError
 }
 
 func (matcher *HaveKeyWithValueMatcher) FailureMessage(actual any) (message string) {
diff --git a/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
index 331f289a..96f5246f 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_json_matcher.go
@@ -4,6 +4,9 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"math/big"
+	"strconv"
+	"strings"
 
 	"github.com/onsi/gomega/format"
 )
@@ -22,14 +25,103 @@ func (matcher *MatchJSONMatcher) Match(actual any) (success bool, err error) {
 	var aval any
 	var eval any
 
-	// this is guarded by prettyPrint
-	json.Unmarshal([]byte(actualString), &aval)
-	json.Unmarshal([]byte(expectedString), &eval)
+	// prettyPrint has already checked the syntax, so decoding is not expected to fail
+	if aval, err = decodeJSON(actualString); err != nil {
+		return false, fmt.Errorf("Actual '%s' should be valid JSON, but it is not.\nUnderlying error:%s", actualString, err)
+	}
+	if eval, err = decodeJSON(expectedString); err != nil {
+		return false, fmt.Errorf("Expected '%s' should be valid JSON, but it is not.\nUnderlying error:%s", expectedString, err)
+	}
 	var equal bool
 	equal, matcher.firstFailurePath = deepEqual(aval, eval)
 	return equal, nil
 }
 
+// decodeJSON decodes s as json.Unmarshal would into an any, except that
+// integers too large to be represented exactly by a float64 are decoded as
+// canonicalJSONNumbers, so that they are compared exactly rather than after
+// rounding to the nearest float64.
+func decodeJSON(s string) (any, error) {
+	decoder := json.NewDecoder(strings.NewReader(s))
+	decoder.UseNumber()
+	var value any
+	if err := decoder.Decode(&value); err != nil {
+		return nil, err
+	}
+	return decodeJSONNumbers(value), nil
+}
+
+func decodeJSONNumbers(value any) any {
+	switch v := value.(type) {
+	case []any:
+		for i, element := range v {
+			v[i] = decodeJSONNumbers(element)
+		}
+	case map[string]any:
+		for key, element := range v {
+			v[key] = decodeJSONNumbers(element)
+		}
+	case json.Number:
+		return decodeJSONNumber(v)
+	}
+	return value
+}
+
+// canonicalJSONNumber is a JSON number written as its significant digits
+// followed by a base-10 exponent, e.g. 12345678901234567890 and
+// 1.234567890123456789e19 are both 123456789012345678900e1. Two JSON numbers
+// have the same value exactly when they have the same canonical form.
+type canonicalJSONNumber string
+
+// maxExactFloat64Integer is 2^53: every integer with a magnitude no greater
+// than this is represented exactly by a float64.
+var maxExactFloat64Integer = new(big.Int).Lsh(big.NewInt(1), 53)
+
+// decodeJSONNumber returns integers whose magnitude exceeds 2^53 in canonical
+// form, and every other number as the float64 that json.Unmarshal would
+// produce.  Numbers that are not integers but are too large for a float64 are
+// also returned in canonical form.
+func decodeJSONNumber(n json.Number) any {
+	s, sign := string(n), ""
+	if rest, negative := strings.CutPrefix(s, "-"); negative {
+		s, sign = rest, "-"
+	}
+	mantissa, exponentString, _ := strings.Cut(strings.ToLower(s), "e")
+	integerPart, fractionPart, _ := strings.Cut(mantissa, ".")
+
+	digits := strings.TrimLeft(integerPart+fractionPart, "0")
+	significantDigits := strings.TrimRight(digits, "0")
+
+	// the exponent is parsed as a big.Int as JSON puts no limit on its size
+	exponent := new(big.Int)
+	if exponentString != "" {
+		exponent.SetString(exponentString, 10) // the syntax has been checked by the decoder
+	}
+	exponent.Add(exponent, big.NewInt(int64(len(digits)-len(significantDigits)-len(fractionPart))))
+	canonical := canonicalJSONNumber(sign + significantDigits + "e" + exponent.String())
+
+	if significantDigits != "" && exponent.Sign() >= 0 && exceedsMaxExactFloat64Integer(significantDigits, exponent) {
+		return canonical
+	}
+	f, err := strconv.ParseFloat(string(n), 64)
+	if err != nil {
+		// the syntax has been checked, so the number must be too large for a float64
+		return canonical
+	}
+	return f
+}
+
+// exceedsMaxExactFloat64Integer reports whether significantDigits * 10^exponent,
+// with exponent >= 0, is greater than 2^53.
+func exceedsMaxExactFloat64Integer(significantDigits string, exponent *big.Int) bool {
+	if exponent.Cmp(big.NewInt(16)) >= 0 {
+		return true // 10^16 > 2^53
+	}
+	value, _ := new(big.Int).SetString(significantDigits, 10)
+	value.Mul(value, new(big.Int).Exp(big.NewInt(10), exponent, nil))
+	return value.Cmp(maxExactFloat64Integer) > 0
+}
+
 func (matcher *MatchJSONMatcher) FailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.prettyPrint(actual)
 	return formattedMessage(format.Message(actualString, "to match JSON of", expectedString), matcher.firstFailurePath)
diff --git a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
index f7dcaf6f..86bf2f2d 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_xml_matcher.go
@@ -83,9 +83,9 @@ func parseXmlContent(content string) (*xmlNode, error) {
 
 		switch tok := tok.(type) {
 		case xml.StartElement:
-			attrs := attributesSlice(tok.Attr)
+			attrs := withNormalizedNamespaceDeclarations(tok.Attr)
 			sort.Sort(attrs)
-			allNodes = append(allNodes, &xmlNode{XMLName: tok.Name, XMLAttr: tok.Attr})
+			allNodes = append(allNodes, &xmlNode{XMLName: tok.Name, XMLAttr: attrs})
 		case xml.EndElement:
 			if len(allNodes) > 1 {
 				allNodes[lastNodeIndex-1].Nodes = append(allNodes[lastNodeIndex-1].Nodes, lastNode)
@@ -109,6 +109,22 @@ func parseXmlContent(content string) (*xmlNode, error) {
 	return firstNode, nil
 }
 
+// withNormalizedNamespaceDeclarations replaces the name of each xmlns="..." and
+// xmlns:prefix="..." attribute with the same placeholder name, so that only the
+// namespace URIs declared on the element are compared, not the prefixes bound
+// to them.  The decoder has already resolved element and attribute names to
+// namespace URIs, so the prefixes play no other part in the comparison.
+func withNormalizedNamespaceDeclarations(attrs []xml.Attr) attributesSlice {
+	normalized := make(attributesSlice, len(attrs))
+	for i, attr := range attrs {
+		if attr.Name.Space == "xmlns" || (attr.Name.Space == "" && attr.Name.Local == "xmlns") {
+			attr.Name = xml.Name{Space: "xmlns"}
+		}
+		normalized[i] = attr
+	}
+	return normalized
+}
+
 func newXmlDecoder(reader io.Reader) *xml.Decoder {
 	dec := xml.NewDecoder(reader)
 	dec.CharsetReader = charset.NewReaderLabel
diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
index c3da9bd4..a6c558d9 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
@@ -1,7 +1,9 @@
 package matchers
 
 import (
+	"errors"
 	"fmt"
+	"io"
 	"strings"
 
 	"github.com/onsi/gomega/format"
@@ -11,37 +13,60 @@ import (
 type MatchYAMLMatcher struct {
 	YAMLToMatch      any
 	firstFailurePath []any
+	// the 1-based number of the first mismatched document when comparing
+	// multi-document streams; 0 otherwise
+	firstFailureDocument int
 }
 
 func (matcher *MatchYAMLMatcher) Match(actual any) (success bool, err error) {
+	matcher.firstFailurePath = nil
+	matcher.firstFailureDocument = 0
+
 	actualString, expectedString, err := matcher.toStrings(actual)
 	if err != nil {
 		return false, err
 	}
 
-	var aval any
-	var eval any
-
-	if err := yaml.Unmarshal([]byte(actualString), &aval); err != nil {
+	adocs, err := decodeYAMLDocuments(actualString)
+	if err != nil {
 		return false, fmt.Errorf("Actual '%s' should be valid YAML, but it is not.\nUnderlying error:%s", actualString, err)
 	}
-	if err := yaml.Unmarshal([]byte(expectedString), &eval); err != nil {
+	edocs, err := decodeYAMLDocuments(expectedString)
+	if err != nil {
 		return false, fmt.Errorf("Expected '%s' should be valid YAML, but it is not.\nUnderlying error:%s", expectedString, err)
 	}
 
-	var equal bool
-	equal, matcher.firstFailurePath = deepEqual(aval, eval)
-	return equal, nil
+	if len(adocs) != len(edocs) {
+		return false, nil
+	}
+	for i := range adocs {
+		var equal bool
+		equal, matcher.firstFailurePath = deepEqual(adocs[i], edocs[i])
+		if !equal {
+			if len(adocs) > 1 {
+				matcher.firstFailureDocument = i + 1
+			}
+			return false, nil
+		}
+	}
+	return true, nil
 }
 
 func (matcher *MatchYAMLMatcher) FailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
-	return formattedMessage(format.Message(actualString, "to match YAML of", expectedString), matcher.firstFailurePath)
+	return matcher.formattedMessage(format.Message(actualString, "to match YAML of", expectedString))
 }
 
 func (matcher *MatchYAMLMatcher) NegatedFailureMessage(actual any) (message string) {
 	actualString, expectedString, _ := matcher.toNormalisedStrings(actual)
-	return formattedMessage(format.Message(actualString, "not to match YAML of", expectedString), matcher.firstFailurePath)
+	return matcher.formattedMessage(format.Message(actualString, "not to match YAML of", expectedString))
+}
+
+func (matcher *MatchYAMLMatcher) formattedMessage(comparisonMessage string) string {
+	if matcher.firstFailureDocument > 0 {
+		comparisonMessage = fmt.Sprintf("%s\n\nfirst mismatched document: %d (counting from 1)", comparisonMessage, matcher.firstFailureDocument)
+	}
+	return formattedMessage(comparisonMessage, matcher.firstFailurePath)
 }
 
 func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual any) (actualFormatted, expectedFormatted string, err error) {
@@ -50,16 +75,63 @@ func (matcher *MatchYAMLMatcher) toNormalisedStrings(actual any) (actualFormatte
 }
 
 func normalise(input string) string {
-	var val any
-	err := yaml.Unmarshal([]byte(input), &val)
+	docs, err := decodeYAMLDocuments(input)
 	if err != nil {
-		panic(err) // unreachable since Match already calls Unmarshal
+		panic(err) // unreachable since Match already decodes the input
 	}
-	output, err := yaml.Marshal(val)
-	if err != nil {
-		panic(err) // untested section, unreachable since we Unmarshal above
+	outputs := make([]string, len(docs))
+	for i, doc := range docs {
+		output, err := yaml.Marshal(doc)
+		if err != nil {
+			panic(err) // untested section, unreachable since we decode above
+		}
+		outputs[i] = string(output)
+	}
+	return strings.TrimSpace(strings.Join(outputs, "---\n"))
+}
+
+// decodeYAMLDocuments decodes every document in a YAML stream.
+//
+// Empty documents - such as those produced by a leading or trailing "---" - are
+// skipped, so "---\na: 1\n---\n" is the single document "a: 1".  A stream with
+// no documents at all is treated as a single null document, as yaml.Unmarshal
+// does.
+func decodeYAMLDocuments(input string) ([]any, error) {
+	docs := []any{}
+	decoder := yaml.NewDecoder(strings.NewReader(input))
+	for {
+		var node yaml.Node
+		err := decoder.Decode(&node)
+		if errors.Is(err, io.EOF) {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+		if isEmptyYAMLDocument(&node) {
+			continue
+		}
+		var doc any
+		if err := node.Decode(&doc); err != nil {
+			return nil, err
+		}
+		docs = append(docs, doc)
+	}
+	if len(docs) == 0 {
+		docs = append(docs, nil)
+	}
+	return docs, nil
+}
+
+// isEmptyYAMLDocument reports whether a document has no content at all.
+// Explicit nulls (e.g. "~" or "null") are content.
+func isEmptyYAMLDocument(document *yaml.Node) bool {
+	if len(document.Content) != 1 {
+		return false
 	}
-	return strings.TrimSpace(string(output))
+	content := document.Content[0]
+	return content.Kind == yaml.ScalarNode && content.ShortTag() == "!!null" && content.Value == "" &&
+		content.Style == 0 && content.Anchor == ""
 }
 
 func (matcher *MatchYAMLMatcher) toStrings(actual any) (actualFormatted, expectedFormatted string, err error) {
diff --git a/vendor/github.com/onsi/gomega/matchers/type_support.go b/vendor/github.com/onsi/gomega/matchers/type_support.go
index d020dedc..89056f44 100644
--- a/vendor/github.com/onsi/gomega/matchers/type_support.go
+++ b/vendor/github.com/onsi/gomega/matchers/type_support.go
@@ -14,6 +14,7 @@ package matchers
 import (
 	"encoding/json"
 	"fmt"
+	"math/big"
 	"reflect"
 
 	"github.com/onsi/gomega/matchers/internal/miter"
@@ -52,26 +53,11 @@ func isFloat(a any) bool {
 	return reflect.Float32 <= kind && kind <= reflect.Float64
 }
 
-func toInteger(a any) int64 {
+func toBigInt(a any) *big.Int {
 	if isInteger(a) {
-		return reflect.ValueOf(a).Int()
-	} else if isUnsignedInteger(a) {
-		return int64(reflect.ValueOf(a).Uint())
-	} else if isFloat(a) {
-		return int64(reflect.ValueOf(a).Float())
-	}
-	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
-}
-
-func toUnsignedInteger(a any) uint64 {
-	if isInteger(a) {
-		return uint64(reflect.ValueOf(a).Int())
-	} else if isUnsignedInteger(a) {
-		return reflect.ValueOf(a).Uint()
-	} else if isFloat(a) {
-		return uint64(reflect.ValueOf(a).Float())
+		return big.NewInt(reflect.ValueOf(a).Int())
 	}
-	panic(fmt.Sprintf("Expected a number!  Got <%T> %#v", a, a))
+	return new(big.Int).SetUint64(reflect.ValueOf(a).Uint())
 }
 
 func toFloat(a any) float64 {
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 297f90ac..b0f01e1f 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -187,7 +187,7 @@ github.com/onsi/ginkgo/v2/internal/reporters
 github.com/onsi/ginkgo/v2/internal/testingtproxy
 github.com/onsi/ginkgo/v2/reporters
 github.com/onsi/ginkgo/v2/types
-# github.com/onsi/gomega v1.42.1
+# github.com/onsi/gomega v1.44.0
 ## explicit; go 1.25.0
 github.com/onsi/gomega
 github.com/onsi/gomega/format

From 590208a59b35b3ca6791edf250318d4ce5f22431 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 14 Oct 2026 11:10:05 +0000
Subject: [PATCH 6/6] chore(deps): Bump github.com/mattn/go-isatty from 0.0.23
 to 0.0.24

Bumps [github.com/mattn/go-isatty](https://github.com/mattn/go-isatty) from 0.0.23 to 0.0.24.
- [Commits](https://github.com/mattn/go-isatty/compare/v0.0.23...v0.0.24)

---
updated-dependencies:
- dependency-name: github.com/mattn/go-isatty
  dependency-version: 0.0.24
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Carlos Eduardo Arango Gutierrez <eduardoa@nvidia.com>
---
 go.mod                                                      | 2 +-
 go.sum                                                      | 4 ++--
 .../go-isatty/{isatty_tcgets.go => isatty_tiocgwinsz.go}    | 6 +++++-
 vendor/modules.txt                                          | 2 +-
 4 files changed, 9 insertions(+), 5 deletions(-)
 rename vendor/github.com/mattn/go-isatty/{isatty_tcgets.go => isatty_tiocgwinsz.go} (62%)

diff --git a/go.mod b/go.mod
index 4b43906a..2668dc45 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/ec2 v1.338.4
 	github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.57.0
 	github.com/aws/aws-sdk-go-v2/service/ssm v1.79.3
-	github.com/mattn/go-isatty v0.0.23
+	github.com/mattn/go-isatty v0.0.24
 	github.com/onsi/ginkgo/v2 v2.32.0
 	github.com/onsi/gomega v1.44.0
 	github.com/pkg/sftp v1.13.11
diff --git a/go.sum b/go.sum
index 5dd45788..175ab990 100644
--- a/go.sum
+++ b/go.sum
@@ -69,8 +69,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/maruel/natural v1.1.1 h1:Hja7XhhmvEFhcByqDoHz9QZbkWey+COd9xWfCfn1ioo=
 github.com/maruel/natural v1.1.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
-github.com/mattn/go-isatty v0.0.23 h1:cYwCQTQf3HB6xUC+BtyCLZNr7IzbOmoZbmssVNzSyiQ=
-github.com/mattn/go-isatty v0.0.23/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
+github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI=
+github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
 github.com/mfridman/tparse v0.18.0 h1:wh6dzOKaIwkUGyKgOntDW4liXSo37qg5AXbIhkMV3vE=
 github.com/mfridman/tparse v0.18.0/go.mod h1:gEvqZTuCgEhPbYk/2lS3Kcxg1GmTxxU7kTC8DvP0i/A=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
diff --git a/vendor/github.com/mattn/go-isatty/isatty_tcgets.go b/vendor/github.com/mattn/go-isatty/isatty_tiocgwinsz.go
similarity index 62%
rename from vendor/github.com/mattn/go-isatty/isatty_tcgets.go
rename to vendor/github.com/mattn/go-isatty/isatty_tiocgwinsz.go
index 0337d8cf..6aecf870 100644
--- a/vendor/github.com/mattn/go-isatty/isatty_tcgets.go
+++ b/vendor/github.com/mattn/go-isatty/isatty_tiocgwinsz.go
@@ -8,8 +8,12 @@ package isatty
 import "golang.org/x/sys/unix"
 
 // IsTerminal return true if the file descriptor is terminal.
+// TIOCGWINSZ is used instead of TCGETS because TCGETS shares its ioctl
+// number with SNDCTL_TMR_TIMEBASE of the OSS sound API, so it may succeed
+// (and even change the device mode) on non-tty devices. musl's isatty does
+// the same.
 func IsTerminal(fd uintptr) bool {
-	_, err := unix.IoctlGetTermios(int(fd), unix.TCGETS)
+	_, err := unix.IoctlGetWinsize(int(fd), unix.TIOCGWINSZ)
 	return err == nil
 }
 
diff --git a/vendor/modules.txt b/vendor/modules.txt
index b0f01e1f..d3bbb954 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -154,7 +154,7 @@ github.com/json-iterator/go
 # github.com/kr/fs v0.1.0
 ## explicit
 github.com/kr/fs
-# github.com/mattn/go-isatty v0.0.23
+# github.com/mattn/go-isatty v0.0.24
 ## explicit; go 1.20
 github.com/mattn/go-isatty
 # github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd