From aba79f1c20d5172b78ac7d49b22afd3a5484b4b8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Jul 2026 18:53:14 +0000
Subject: [PATCH] chore: bump github.com/prometheus/client_golang from 1.23.2
 to 1.24.0

Bumps [github.com/prometheus/client_golang](https://github.com/prometheus/client_golang) from 1.23.2 to 1.24.0.
- [Release notes](https://github.com/prometheus/client_golang/releases)
- [Changelog](https://github.com/prometheus/client_golang/blob/v1.24.0/CHANGELOG.md)
- [Commits](https://github.com/prometheus/client_golang/compare/v1.23.2...v1.24.0)

---
updated-dependencies:
- dependency-name: github.com/prometheus/client_golang
  dependency-version: 1.24.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 go.mod                                        |    6 +-
 go.sum                                        |   12 +-
 .../klauspost/compress/huff0/build_table.go   |  168 +
 .../compress/internal/snapref/decode.go       |    2 +-
 .../klauspost/compress/zstd/README.md         |   37 +-
 .../klauspost/compress/zstd/dict.go           |    3 +-
 .../klauspost/compress/zstd/enc_base.go       |   28 +
 .../klauspost/compress/zstd/enc_best.go       |   15 +
 .../klauspost/compress/zstd/enc_better.go     |   18 +
 .../klauspost/compress/zstd/enc_dfast.go      |   16 +
 .../klauspost/compress/zstd/enc_fast.go       |   17 +
 .../klauspost/compress/zstd/enc_jobs.go       |  352 +++
 .../klauspost/compress/zstd/encoder.go        |  210 +-
 .../compress/zstd/encoder_options.go          |   69 +-
 .../compress/zstd/fse_decoder_amd64.s         |    2 +-
 .../compress/zstd/fse_decoder_arm64.s         |  146 +
 ...se_decoder_amd64.go => fse_decoder_asm.go} |    8 +-
 .../compress/zstd/fse_decoder_generic.go      |    2 +-
 .../klauspost/compress/zstd/seqdec_amd64.go   |  362 +--
 .../klauspost/compress/zstd/seqdec_amd64.s    |    2 +-
 .../klauspost/compress/zstd/seqdec_arm64.go   |   70 +
 .../klauspost/compress/zstd/seqdec_arm64.s    | 2705 +++++++++++++++++
 .../klauspost/compress/zstd/seqdec_asm.go     |  289 ++
 .../klauspost/compress/zstd/seqdec_generic.go |    2 +-
 .../prometheus/client_golang/api/client.go    |   19 +-
 .../client_golang/api/prometheus/v1/api.go    |   98 +-
 .../golang/gddo/httputil/header/header.go     |    2 +-
 .../collectors/go_collector_go116.go          |   49 -
 .../collectors/go_collector_latest.go         |    4 +-
 .../client_golang/prometheus/counter.go       |   11 +-
 .../client_golang/prometheus/desc.go          |   37 +-
 .../prometheus/expvar_collector.go            |    8 +-
 .../client_golang/prometheus/gauge.go         |   11 +-
 .../prometheus/go_collector_go116.go          |  122 -
 .../prometheus/go_collector_latest.go         |   20 +-
 .../client_golang/prometheus/histogram.go     |   29 +-
 .../prometheus/internal/difflib.go            |    4 +-
 .../client_golang/prometheus/labels.go        |    3 +-
 .../client_golang/prometheus/metric.go        |    3 +
 .../prometheus/process_collector_darwin.go    |   13 +-
 .../prometheus/process_collector_windows.go   |   19 +-
 .../client_golang/prometheus/promhttp/http.go |  194 +-
 .../prometheus/promhttp/instrument_client.go  |   12 +-
 .../prometheus/promhttp/instrument_server.go  |   88 +-
 .../prometheus/promhttp/option.go             |   42 +-
 .../client_golang/prometheus/registry.go      |   63 +-
 .../client_golang/prometheus/summary.go       |    9 +-
 .../client_golang/prometheus/timer.go         |   10 +-
 .../client_golang/prometheus/vec.go           |   10 +-
 .../client_golang/prometheus/wrap.go          |    5 +-
 .../prometheus/procfs/net_wireless.go         |   18 +-
 .../prometheus/procfs/proc_cgroup.go          |    2 +-
 vendor/modules.txt                            |    8 +-
 53 files changed, 4765 insertions(+), 689 deletions(-)
 create mode 100644 vendor/github.com/klauspost/compress/huff0/build_table.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/enc_jobs.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/fse_decoder_arm64.s
 rename vendor/github.com/klauspost/compress/zstd/{fse_decoder_amd64.go => fse_decoder_asm.go} (81%)
 create mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_arm64.go
 create mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_arm64.s
 create mode 100644 vendor/github.com/klauspost/compress/zstd/seqdec_asm.go
 delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_go116.go
 delete mode 100644 vendor/github.com/prometheus/client_golang/prometheus/go_collector_go116.go

diff --git a/go.mod b/go.mod
index 4450b22ca9..632d7281e0 100644
--- a/go.mod
+++ b/go.mod
@@ -27,7 +27,7 @@ require (
 	github.com/jstemmer/go-junit-report/v2 v2.1.0
 	github.com/kylelemons/godebug v1.1.0
 	github.com/open-policy-agent/cert-controller v0.16.0
-	github.com/prometheus/client_golang v1.23.2
+	github.com/prometheus/client_golang v1.24.0
 	github.com/prometheus/common v0.70.0
 	github.com/spf13/cobra v1.10.2
 	github.com/spyzhov/ajson v0.9.6
@@ -113,7 +113,7 @@ require (
 	github.com/jonboulle/clockwork v0.5.0 // indirect
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.18.6 // indirect
+	github.com/klauspost/compress v1.19.0 // indirect
 	github.com/liggitt/tabwriter v0.0.0-20181228230101-89fcab3d43de // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
@@ -133,7 +133,7 @@ require (
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/procfs v0.21.0 // indirect
+	github.com/prometheus/procfs v0.21.1 // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/sergi/go-diff v1.4.0 // indirect
diff --git a/go.sum b/go.sum
index 17a9624683..81077874bf 100644
--- a/go.sum
+++ b/go.sum
@@ -202,8 +202,8 @@ github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnr
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jstemmer/go-junit-report/v2 v2.1.0 h1:X3+hPYlSczH9IMIpSC9CQSZA0L+BipYafciZUWHEmsc=
 github.com/jstemmer/go-junit-report/v2 v2.1.0/go.mod h1:mgHVr7VUo5Tn8OLVr1cKnLuEy0M92wdRntM99h7RkgQ=
-github.com/klauspost/compress v1.18.6 h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao=
-github.com/klauspost/compress v1.18.6/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+github.com/klauspost/compress v1.19.0 h1:sXLILfc9jV2QYWkzFOPWStmcUVH2RHEB1JCdY2oVvCQ=
+github.com/klauspost/compress v1.19.0/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
@@ -271,15 +271,15 @@ github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10/go.mod h1
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
-github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
+github.com/prometheus/client_golang v1.24.0 h1:5XStIklKuAtJSNpdD3s8XJj/Yv78IQmE1kbNk87JrAI=
+github.com/prometheus/client_golang v1.24.0/go.mod h1:QcsNdotprC2nS4BTM2ucbcqxd2CeXTEa9jW7zHO9iDE=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
 github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
 github.com/prometheus/common v0.70.0 h1:bcpru3tWPVnxGnETLgOV5jbp/JRXgYEyv65CuBLAMMI=
 github.com/prometheus/common v0.70.0/go.mod h1:S/SFasQmgGiYH6C81LKCtYa8QACgthGg5zxL2udV7SY=
-github.com/prometheus/procfs v0.21.0 h1:Qh/e6TlBjZf+XLLqNCqFGmCU6Kj/2Bu7kj3oAc0UnXc=
-github.com/prometheus/procfs v0.21.0/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
+github.com/prometheus/procfs v0.21.1 h1:GljZCt+zSTS+NZq88cyQ1LjZ+RCHp3uVuabBWA5+OJI=
+github.com/prometheus/procfs v0.21.1/go.mod h1:aB55Cww9pdSJVHk0hUf0inxWyyjPogFIjmHKYgMKmtY=
 github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
 github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
diff --git a/vendor/github.com/klauspost/compress/huff0/build_table.go b/vendor/github.com/klauspost/compress/huff0/build_table.go
new file mode 100644
index 0000000000..e3757c87e0
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/huff0/build_table.go
@@ -0,0 +1,168 @@
+package huff0
+
+import "errors"
+
+// BuildCTable builds a Huffman compression table from a precomputed symbol
+// histogram and installs it as the previous (reuse) table on s.
+//
+// After this call:
+//   - EstimateSize/CanUseTable can probe the table against other histograms.
+//   - Compress1X/Compress4X with Reuse = ReusePolicyMust will encode without
+//     emitting a new table header.
+//   - TransferCTable can hand the table to a sibling Scratch.
+//
+// count[i] is the number of occurrences of symbol i. The histogram must have
+// at least 2 distinct non-zero symbols; ErrUseRLE is returned for a single
+// symbol and an error is returned for an empty histogram.
+func (s *Scratch) BuildCTable(count *[256]uint32) error {
+	if s == nil {
+		return errors.New("huff0: BuildCTable on nil Scratch")
+	}
+	if count == nil {
+		return errors.New("huff0: nil count passed to BuildCTable")
+	}
+	var err error
+	s, err = s.prepare(nil)
+	if err != nil {
+		return err
+	}
+	s.count = *count
+	var total, maxCount int
+	var symLen uint16
+	for i, v := range s.count {
+		total += int(v)
+		if int(v) > maxCount {
+			maxCount = int(v)
+		}
+		if v != 0 {
+			symLen = uint16(i) + 1
+		}
+	}
+	if total == 0 {
+		return errors.New("huff0: empty histogram")
+	}
+	if symLen < 2 || maxCount == total {
+		return ErrUseRLE
+	}
+	// huff0's internal rank table assumes total ≤ BlockSizeMax (it uses
+	// highBit32(count+1) + 1 as a rank index into a fixed-size array).
+	// Histograms summed across multiple blocks can exceed that; scale the
+	// counts down preserving the distribution. Non-zero entries round up so
+	// rare symbols stay representable.
+	if total > BlockSizeMax {
+		shift := uint(0)
+		for total>>shift > BlockSizeMax {
+			shift++
+		}
+		round := uint32(1<<shift) - 1
+		var newTotal, newMax int
+		for i, v := range s.count {
+			if v == 0 {
+				continue
+			}
+			scaled := (v + round) >> shift
+			if scaled == 0 {
+				scaled = 1
+			}
+			s.count[i] = scaled
+			newTotal += int(scaled)
+			if int(scaled) > newMax {
+				newMax = int(scaled)
+			}
+		}
+		total = newTotal
+		maxCount = newMax
+		if maxCount == total {
+			return ErrUseRLE
+		}
+	}
+	s.symbolLen = symLen
+	s.maxCount = maxCount
+	s.srcLen = total
+	if err := s.buildCTable(); err != nil {
+		return err
+	}
+	if cap(s.prevTable) < len(s.cTable) {
+		s.prevTable = make(cTable, 0, maxSymbolValue+1)
+	}
+	s.prevTable = s.prevTable[:len(s.cTable)]
+	copy(s.prevTable, s.cTable)
+	s.prevTableLog = s.actualTableLog
+	// Force the next Compress* to recount from real input.
+	s.clearCount = true
+	s.maxCount = 0
+	return nil
+}
+
+// EstimateSize returns an estimated compressed payload size in bytes for the
+// supplied histogram using the table currently stored in prevTable. It returns
+// -1 when the table cannot encode every non-zero symbol of hist (i.e. when
+// CanUseTable would return false). The estimate excludes the table header.
+func (s *Scratch) EstimateSize(hist *[256]uint32) int {
+	if s == nil || hist == nil || len(s.prevTable) == 0 {
+		return -1
+	}
+	pt := s.prevTable
+	nbBits := uint32(7)
+	for i, v := range hist {
+		if v == 0 {
+			continue
+		}
+		if i >= len(pt) || pt[i].nBits == 0 {
+			return -1
+		}
+		nbBits += uint32(pt[i].nBits) * v
+	}
+	return int(nbBits >> 3)
+}
+
+// CanUseTable reports whether the table in prevTable can encode every
+// non-zero symbol present in hist.
+func (s *Scratch) CanUseTable(hist *[256]uint32) bool {
+	if s == nil || hist == nil || len(s.prevTable) == 0 {
+		return false
+	}
+	pt := s.prevTable
+	for i, v := range hist {
+		if v == 0 {
+			continue
+		}
+		if i >= len(pt) || pt[i].nBits == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// AppendTable serializes the table currently stored in prevTable (e.g. as
+// installed by BuildCTable or carried over from a previous Compress call)
+// into a self-delimiting zstd-style header and appends it to dst. The
+// returned slice can be parsed back by ReadTable.
+func (s *Scratch) AppendTable(dst []byte) ([]byte, error) {
+	if s == nil || len(s.prevTable) == 0 {
+		return dst, errors.New("huff0: AppendTable with empty table")
+	}
+	// cTable.write reads s.actualTableLog, s.symbolLen, s.huffWeight, s.fse
+	// and writes into s.Out. Save/restore Out so we don't disturb in-flight
+	// compression buffers.
+	saveOut := s.Out
+	saveTL := s.actualTableLog
+	saveSL := s.symbolLen
+	if s.fse == nil {
+		// Lazily init in case AppendTable is called on a fresh Scratch.
+		if _, err := s.prepare(nil); err != nil {
+			return dst, err
+		}
+		saveOut = s.Out
+	}
+	s.Out = s.Out[:0]
+	s.actualTableLog = s.prevTableLog
+	s.symbolLen = uint16(len(s.prevTable))
+	if err := s.prevTable.write(s); err != nil {
+		s.Out, s.actualTableLog, s.symbolLen = saveOut, saveTL, saveSL
+		return dst, err
+	}
+	dst = append(dst, s.Out...)
+	s.Out, s.actualTableLog, s.symbolLen = saveOut, saveTL, saveSL
+	return dst, nil
+}
diff --git a/vendor/github.com/klauspost/compress/internal/snapref/decode.go b/vendor/github.com/klauspost/compress/internal/snapref/decode.go
index a2c82fcd22..584b7574b2 100644
--- a/vendor/github.com/klauspost/compress/internal/snapref/decode.go
+++ b/vendor/github.com/klauspost/compress/internal/snapref/decode.go
@@ -31,7 +31,7 @@ func DecodedLen(src []byte) (int, error) {
 // that the length header occupied.
 func decodedLen(src []byte) (blockLen, headerLen int, err error) {
 	v, n := binary.Uvarint(src)
-	if n <= 0 || v > 0xffffffff {
+	if n <= 0 || n > 5 || v > 0xffffffff {
 		return 0, 0, ErrCorrupt
 	}
 
diff --git a/vendor/github.com/klauspost/compress/zstd/README.md b/vendor/github.com/klauspost/compress/zstd/README.md
index c11d7fa28e..a5aeeaed06 100644
--- a/vendor/github.com/klauspost/compress/zstd/README.md
+++ b/vendor/github.com/klauspost/compress/zstd/README.md
@@ -75,14 +75,47 @@ The above is fine for big encodes. However, whenever possible try to *reuse* the
 To reuse the encoder, you can use the `Reset(io.Writer)` function to change to another output. 
 This will allow the encoder to reuse all resources and avoid wasteful allocations. 
 
-Currently stream encoding has 'light' concurrency, meaning up to 2 goroutines can be working on part 
-of a stream. This is independent of the `WithEncoderConcurrency(n)`, but that is likely to change 
+By default, stream encoding has 'light' concurrency, meaning up to 2 goroutines can be working on part
+of a stream. This is independent of the `WithEncoderConcurrency(n)`, but that is likely to change
 in the future. So if you want to limit concurrency for future updates, specify the concurrency
 you would like.
 
 If you would like stream encoding to be done without spawning async goroutines, use `WithEncoderConcurrency(1)`
 which will compress input as each block is completed, blocking on writes until each has completed.
 
+#### Parallel Stream Compression
+
+For maximum throughput on large streams, use `WithConcurrentBlocks(true)` together with
+`WithEncoderConcurrency(n)` where n is the number of CPU cores you want to use.
+This splits the input into large sections (jobs) that are compressed simultaneously by multiple goroutines,
+similar to how the C zstd library does multithreaded compression.
+
+```Go
+enc, err := zstd.NewWriter(out,
+    zstd.WithEncoderLevel(zstd.SpeedDefault),
+    zstd.WithEncoderConcurrency(runtime.GOMAXPROCS(0)),
+    zstd.WithConcurrentBlocks(true),
+)
+```
+
+Each non-first job receives an overlap prefix from the previous job for match context,
+so compression ratio is only marginally affected. Output is flushed in order,
+producing a valid single-frame zstd stream.
+
+Benchmark on 1.8GB GOB stream (AMD Ryzen 9 9950X):
+
+| Level   |  1 thread  |     4 threads      |     16 threads      | 1T ratio | 16T ratio |
+|---------|:----------:|:------------------:|:-------------------:|:--------:|:---------:|
+| fastest | 783 MB/s   | 2950 MB/s (3.8×)   | 6939 MB/s (8.9×)    | 12.24%   | 12.26%    |
+| default | 728 MB/s   | 2533 MB/s (3.5×)   | 5340 MB/s (7.3×)    | 10.67%   | 10.68%    |
+| better  | 434 MB/s   | 1105 MB/s (2.5×)   | 2206 MB/s (5.1×)    | 9.14%    | 9.21%     |
+| best    | 129 MB/s   | 367 MB/s (2.8×)    | 884 MB/s (6.8×)     | 8.48%    | 8.63%     |
+
+Notes:
+* Not compatible with dictionary encoding.
+* `Flush()` dispatches the current partial job, so latency-sensitive callers can force output.
+* `EncodeAll` is unaffected — it uses its own concurrency via the encoder pool.
+
 You can specify your desired compression level using `WithEncoderLevel()` option. Currently only pre-defined 
 compression settings can be specified.
 
diff --git a/vendor/github.com/klauspost/compress/zstd/dict.go b/vendor/github.com/klauspost/compress/zstd/dict.go
index 2ffbfdf379..4f1c4938cd 100644
--- a/vendor/github.com/klauspost/compress/zstd/dict.go
+++ b/vendor/github.com/klauspost/compress/zstd/dict.go
@@ -230,7 +230,7 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 	}
 	block := blockEnc{lowMem: false}
 	block.init()
-	enc := encoder(&bestFastEncoder{fastBase: fastBase{maxMatchOff: int32(maxMatchLen), bufferReset: math.MaxInt32 - int32(maxMatchLen*2), lowMem: false}})
+	var enc encoder
 	if o.Level != 0 {
 		eOpts := encoderOptions{
 			level:      o.Level,
@@ -242,6 +242,7 @@ func BuildDict(o BuildDictOptions) ([]byte, error) {
 		enc = eOpts.encoder()
 	} else {
 		o.Level = SpeedBestCompression
+		enc = encoder(&bestFastEncoder{fastBase: fastBase{maxMatchOff: int32(maxMatchLen), bufferReset: math.MaxInt32 - int32(maxMatchLen*2), lowMem: false}})
 	}
 	var (
 		remain [256]int
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_base.go b/vendor/github.com/klauspost/compress/zstd/enc_base.go
index c4de134a7a..c4fea575d6 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_base.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_base.go
@@ -128,6 +128,34 @@ func (e *fastBase) matchlen(s, t int32, src []byte) int32 {
 	return int32(matchLen(src[s:], src[t:]))
 }
 
+// resetBasePrefix resets the encoder state and loads prefix as initial history.
+// This is used for parallel job encoding where non-first jobs need overlap context.
+// Rep offsets are set to defaults [1,4,8] (invalidated, matching C behavior).
+func (e *fastBase) resetBasePrefix(prefix []byte) {
+	if e.blk == nil {
+		e.blk = &blockEnc{lowMem: e.lowMem}
+		e.blk.init()
+	} else {
+		e.blk.reset(nil)
+	}
+	e.blk.initNewEncode()
+	if e.crc == nil {
+		e.crc = xxhash.New()
+	} else {
+		e.crc.Reset()
+	}
+	e.blk.dictLitEnc = nil
+	e.ensureHist(len(prefix) + maxCompressedBlockSize)
+	// Bump cur so old table entries fall outside the window.
+	// When cur >= bufferReset, leave it; the first Encode call
+	// will shift/clear tables, preserving valid prefix entries.
+	if e.cur < e.bufferReset {
+		e.cur += e.maxMatchOff + int32(len(e.hist))
+	}
+	e.hist = e.hist[:0]
+	e.hist = append(e.hist, prefix...)
+}
+
 // Reset the encoding table.
 func (e *fastBase) resetBase(d *dict, singleBlock bool) {
 	if e.blk == nil {
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_best.go b/vendor/github.com/klauspost/compress/zstd/enc_best.go
index 851799322b..c71382dde6 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_best.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_best.go
@@ -551,3 +551,18 @@ func (e *bestFastEncoder) Reset(d *dict, singleBlock bool) {
 	// Reset table to initial state
 	copy(e.table[:], e.dictTable)
 }
+
+func (e *bestFastEncoder) ResetPrefix(prefix []byte) {
+	e.resetBasePrefix(prefix)
+	if len(prefix) < 8 {
+		return
+	}
+	end := e.cur + int32(len(prefix)) - 8
+	for i := e.cur; i < end; i++ {
+		cv := load6432(prefix, i-e.cur)
+		h := hashLen(cv, bestLongTableBits, bestLongLen)
+		e.longTable[h] = prevEntry{offset: i, prev: e.longTable[h].offset}
+		h0 := hashLen(cv, bestShortTableBits, bestShortLen)
+		e.table[h0] = prevEntry{offset: i, prev: e.table[h0].offset}
+	}
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_better.go b/vendor/github.com/klauspost/compress/zstd/enc_better.go
index 3305f09248..523d57f3ad 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_better.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_better.go
@@ -1096,6 +1096,20 @@ func (e *betterFastEncoder) Reset(d *dict, singleBlock bool) {
 	}
 }
 
+func (e *betterFastEncoder) ResetPrefix(prefix []byte) {
+	e.resetBasePrefix(prefix)
+	if len(prefix) < 8 {
+		return
+	}
+	end := e.cur + int32(len(prefix)) - 8
+	for i := e.cur; i < end; i += 2 {
+		cv := load6432(prefix, i-e.cur)
+		h := hashLen(cv, betterLongTableBits, betterLongLen)
+		e.longTable[h] = prevEntry{offset: i, prev: e.longTable[h].offset}
+		e.table[hashLen(cv>>8, betterShortTableBits, betterShortLen)] = tableEntry{val: uint32(cv >> 8), offset: i + 1}
+	}
+}
+
 // ResetDict will reset and set a dictionary if not nil
 func (e *betterFastEncoderDict) Reset(d *dict, singleBlock bool) {
 	e.resetBase(d, singleBlock)
@@ -1229,6 +1243,10 @@ func (e *betterFastEncoderDict) Reset(d *dict, singleBlock bool) {
 	e.allDirty = false
 }
 
+func (e *betterFastEncoderDict) ResetPrefix([]byte) {
+	panic("ResetPrefix not supported for dict encoders")
+}
+
 func (e *betterFastEncoderDict) markLongShardDirty(entryNum uint32) {
 	e.longTableShardDirty[entryNum/betterLongTableShardSize] = true
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_dfast.go b/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
index 2fb6da112b..712ba7ab58 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_dfast.go
@@ -1037,6 +1037,18 @@ func (e *doubleFastEncoder) Reset(d *dict, singleBlock bool) {
 	}
 }
 
+func (e *doubleFastEncoder) ResetPrefix(prefix []byte) {
+	e.fastEncoder.ResetPrefix(prefix)
+	if len(prefix) < 8 {
+		return
+	}
+	end := e.cur + int32(len(prefix)) - 8
+	for i := e.cur + 1; i < end; i += 2 {
+		cv := load6432(prefix, i-e.cur)
+		e.longTable[hashLen(cv, dFastLongTableBits, dFastLongLen)] = tableEntry{val: uint32(cv), offset: i}
+	}
+}
+
 // ResetDict will reset and set a dictionary if not nil
 func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 	allDirty := e.allDirty
@@ -1102,6 +1114,10 @@ func (e *doubleFastEncoderDict) Reset(d *dict, singleBlock bool) {
 	}
 }
 
+func (e *doubleFastEncoderDict) ResetPrefix([]byte) {
+	panic("ResetPrefix not supported for dict encoders")
+}
+
 func (e *doubleFastEncoderDict) markLongShardDirty(entryNum uint32) {
 	e.longTableShardDirty[entryNum/dLongTableShardSize] = true
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_fast.go b/vendor/github.com/klauspost/compress/zstd/enc_fast.go
index 5e104f1a48..06045e2463 100644
--- a/vendor/github.com/klauspost/compress/zstd/enc_fast.go
+++ b/vendor/github.com/klauspost/compress/zstd/enc_fast.go
@@ -797,6 +797,19 @@ func (e *fastEncoder) Reset(d *dict, singleBlock bool) {
 	}
 }
 
+func (e *fastEncoder) ResetPrefix(prefix []byte) {
+	e.resetBasePrefix(prefix)
+	if len(prefix) < 8 {
+		return
+	}
+	end := e.cur + int32(len(prefix)) - 8
+	// Index every 4th
+	for i := e.cur + 1; i < end; i += 4 {
+		cv := load6432(prefix, i-e.cur)
+		e.table[hashLen(cv, tableBits, tableFastHashLen)] = tableEntry{val: uint32(cv), offset: i}
+	}
+}
+
 // ResetDict will reset and set a dictionary if not nil
 func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 	e.resetBase(d, singleBlock)
@@ -866,6 +879,10 @@ func (e *fastEncoderDict) Reset(d *dict, singleBlock bool) {
 	e.allDirty = false
 }
 
+func (e *fastEncoderDict) ResetPrefix([]byte) {
+	panic("ResetPrefix not supported for dict encoders")
+}
+
 func (e *fastEncoderDict) markAllShardsDirty() {
 	e.allDirty = true
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/enc_jobs.go b/vendor/github.com/klauspost/compress/zstd/enc_jobs.go
new file mode 100644
index 0000000000..95ce67ac05
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/enc_jobs.go
@@ -0,0 +1,352 @@
+// Copyright 2019+ Klaus Post. All rights reserved.
+// License information can be found in the LICENSE file.
+// Based on work by Yann Collet, released under BSD License.
+
+package zstd
+
+import (
+	"fmt"
+	rdebug "runtime/debug"
+	"sync"
+)
+
+type encJob struct {
+	prefix []byte        // overlap from previous job (nil for first)
+	input  []byte        // job's own input data (swapped from filling)
+	last   bool          // last block of last job gets last=true
+	output []byte        // compressed blocks (filled by worker)
+	err    error         // encoding error
+	done   chan struct{} // closed when complete
+}
+
+type jobState struct {
+	jobSize     int
+	overlapSize int
+	filling     []byte // accumulates input up to jobSize
+	nextPrefix  []byte // overlap prefix prepared for the next dispatched job
+
+	jobSeq int // next job sequence number
+
+	jobCh    chan *encJob // dispatch to workers
+	resultCh chan *encJob // ordered results to flusher
+
+	workerWg  sync.WaitGroup
+	flusherWg sync.WaitGroup
+
+	mu         sync.Mutex
+	flushedSeq int // last flushed sequence number
+	cond       *sync.Cond
+
+	flusherErr error
+	started    bool
+
+	inputPool   sync.Pool // *[]byte buffers of jobSize cap
+	outputPool  sync.Pool // *[]byte buffers for compressed output
+	overlapPool sync.Pool // *[]byte buffers for overlap prefixes
+}
+
+func (e *Encoder) startJobWorkers() {
+	js := &e.state.jobs
+	n := e.o.concurrent
+	js.jobCh = make(chan *encJob, n)
+	js.resultCh = make(chan *encJob, n)
+	js.flushedSeq = 0
+	js.cond = sync.NewCond(&js.mu)
+
+	// Workers borrow encoders from the shared e.encoders pool per-job.
+	// Ensure the pool is initialized before any worker tries to borrow.
+	e.init.Do(e.initialize)
+
+	for range n {
+		js.workerWg.Add(1)
+		go e.jobWorker()
+	}
+	js.flusherWg.Add(1)
+	go e.jobFlusher()
+	js.started = true
+}
+
+func (e *Encoder) jobWorker() {
+	js := &e.state.jobs
+	defer js.workerWg.Done()
+	for job := range js.jobCh {
+		enc := <-e.encoders
+		e.compressJob(enc, job)
+		e.encoders <- enc
+		close(job.done)
+	}
+}
+
+func (e *Encoder) compressJob(enc encoder, job *encJob) {
+	defer func() {
+		if r := recover(); r != nil {
+			job.err = fmt.Errorf("panic in parallel job: %v", r)
+			rdebug.PrintStack()
+		}
+	}()
+
+	if len(job.prefix) > 0 {
+		enc.ResetPrefix(job.prefix)
+	} else {
+		enc.Reset(nil, false)
+	}
+
+	data := job.input
+	if len(data) == 0 && job.last {
+		blk := enc.Block()
+		blk.reset(nil)
+		blk.last = true
+		blk.encodeRaw(nil)
+		job.output = append(job.output, blk.output...)
+		return
+	}
+
+	blk := enc.Block()
+	for len(data) > 0 {
+		todo := data
+		if len(todo) > e.o.blockSize {
+			todo = todo[:e.o.blockSize]
+		}
+		data = data[len(todo):]
+
+		blk.pushOffsets()
+		enc.Encode(blk, todo)
+		blk.last = len(data) == 0 && job.last
+
+		err := blk.encode(todo, e.o.noEntropy, !e.o.allLitEntropy)
+		if err != nil {
+			job.err = err
+			return
+		}
+		job.output = append(job.output, blk.output...)
+		blk.reset(nil)
+	}
+}
+
+func (js *jobState) getInputBuf(size int) []byte {
+	if v := js.inputPool.Get(); v != nil {
+		bp := v.(*[]byte)
+		b := *bp
+		if cap(b) >= size {
+			return b[:0]
+		}
+	}
+	return make([]byte, 0, size)
+}
+
+func (js *jobState) putInputBuf(b []byte) {
+	if cap(b) > 0 {
+		b = b[:0]
+		js.inputPool.Put(&b)
+	}
+}
+
+func (js *jobState) getOutputBuf(size int) []byte {
+	if v := js.outputPool.Get(); v != nil {
+		bp := v.(*[]byte)
+		b := *bp
+		if cap(b) >= size {
+			return b[:0]
+		}
+	}
+	return make([]byte, 0, size)
+}
+
+func (js *jobState) putOutputBuf(b []byte) {
+	if cap(b) > 0 {
+		b = b[:0]
+		js.outputPool.Put(&b)
+	}
+}
+
+func (js *jobState) getOverlapBuf(size int) []byte {
+	if v := js.overlapPool.Get(); v != nil {
+		bp := v.(*[]byte)
+		b := *bp
+		if cap(b) >= size {
+			return b[:size]
+		}
+	}
+	return make([]byte, size)
+}
+
+func (js *jobState) putOverlapBuf(b []byte) {
+	if cap(b) > 0 {
+		b = b[:0]
+		js.overlapPool.Put(&b)
+	}
+}
+
+func (e *Encoder) jobFlusher() {
+	js := &e.state.jobs
+	defer js.flusherWg.Done()
+	for job := range js.resultCh {
+		<-job.done
+		// Worker has fully exited compressJob, so the prefix is no longer
+		// in use. Return it to the pool regardless of outcome.
+		if job.prefix != nil {
+			js.putOverlapBuf(job.prefix)
+			job.prefix = nil
+		}
+		if job.err != nil {
+			js.mu.Lock()
+			js.flusherErr = job.err
+			js.cond.Broadcast()
+			js.mu.Unlock()
+			for range js.resultCh {
+			}
+			return
+		}
+		if len(job.output) > 0 {
+			_, err := e.state.w.Write(job.output)
+			if err != nil {
+				js.mu.Lock()
+				js.flusherErr = err
+				js.cond.Broadcast()
+				js.mu.Unlock()
+				for range js.resultCh {
+				}
+				return
+			}
+			e.state.nWritten += int64(len(job.output))
+		}
+		// Return buffers to pools.
+		js.putInputBuf(job.input)
+		js.putOutputBuf(job.output)
+		job.input = nil
+		job.output = nil
+
+		js.mu.Lock()
+		js.flushedSeq++
+		js.cond.Broadcast()
+		js.mu.Unlock()
+	}
+}
+
+func (e *Encoder) shutdownJobWorkers() {
+	js := &e.state.jobs
+	if !js.started {
+		return
+	}
+	close(js.jobCh)
+	js.workerWg.Wait()
+	close(js.resultCh)
+	js.flusherWg.Wait()
+	js.started = false
+}
+
+// waitAllJobs blocks until all dispatched jobs have been flushed.
+func (e *Encoder) waitAllJobs() {
+	js := &e.state.jobs
+	if !js.started {
+		return
+	}
+	js.mu.Lock()
+	for js.flushedSeq < js.jobSeq && js.flusherErr == nil {
+		js.cond.Wait()
+	}
+	js.mu.Unlock()
+}
+
+func (e *Encoder) dispatchJob(final bool) error {
+	s := &e.state
+	js := &s.jobs
+
+	js.mu.Lock()
+	fErr := js.flusherErr
+	js.mu.Unlock()
+	if fErr != nil {
+		return fErr
+	}
+
+	if !s.headerWritten {
+		// Single-block optimization: fall through to encodeAll path.
+		if final && len(js.filling) > 0 && len(js.filling) <= e.o.blockSize {
+			s.current = e.encodeAll(s.encoder, js.filling, s.current[:0])
+			var n2 int
+			n2, s.err = s.w.Write(s.current)
+			if s.err != nil {
+				return s.err
+			}
+			s.nWritten += int64(n2)
+			s.nInput += int64(len(js.filling))
+			s.current = s.current[:0]
+			js.filling = js.filling[:0]
+			s.headerWritten = true
+			s.fullFrameWritten = true
+			s.eofWritten = true
+			return nil
+		}
+		if final && len(js.filling) == 0 && !e.o.fullZero {
+			s.headerWritten = true
+			s.fullFrameWritten = true
+			s.eofWritten = true
+			return nil
+		}
+
+		var tmp [maxHeaderSize]byte
+		fh := frameHeader{
+			ContentSize:   uint64(s.frameContentSize),
+			WindowSize:    uint32(s.encoder.WindowSize(s.frameContentSize)),
+			SingleSegment: false,
+			Checksum:      e.o.crc,
+			DictID:        0,
+		}
+		dst := fh.appendTo(tmp[:0])
+		var n2 int
+		n2, s.err = s.w.Write(dst)
+		if s.err != nil {
+			return s.err
+		}
+		s.nWritten += int64(n2)
+		s.headerWritten = true
+	}
+
+	if len(js.filling) == 0 && !final {
+		return nil
+	}
+
+	if !js.started {
+		e.startJobWorkers()
+	}
+
+	// Estimate output size for pooled buffer.
+	outputEst := max(len(js.filling)/2, 512)
+
+	job := &encJob{
+		last:   final,
+		done:   make(chan struct{}),
+		output: js.getOutputBuf(outputEst),
+	}
+
+	// Each job owns its prefix slice; the flusher returns it to the pool
+	// after <-job.done, so workers and dispatch never share a buffer.
+	if js.nextPrefix != nil {
+		job.prefix = js.nextPrefix
+		js.nextPrefix = nil
+	}
+
+	// Build the next job's prefix from the tail of this job's input.
+	if !final && len(js.filling) > 0 {
+		overlapLen := min(js.overlapSize, len(js.filling))
+		np := js.getOverlapBuf(overlapLen)
+		copy(np, js.filling[len(js.filling)-overlapLen:])
+		js.nextPrefix = np
+	}
+
+	// Swap filling buffer into job — zero-copy for the input data.
+	job.input = js.filling
+	js.filling = js.getInputBuf(js.jobSize)
+
+	s.nInput += int64(len(job.input))
+	js.jobSeq++
+
+	if final {
+		s.eofWritten = true
+	}
+
+	js.resultCh <- job
+	js.jobCh <- job
+
+	return nil
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/encoder.go b/vendor/github.com/klauspost/compress/zstd/encoder.go
index 0f2a00a003..6ee96d8730 100644
--- a/vendor/github.com/klauspost/compress/zstd/encoder.go
+++ b/vendor/github.com/klauspost/compress/zstd/encoder.go
@@ -38,6 +38,7 @@ type encoder interface {
 	WindowSize(size int64) int32
 	UseBlock(*blockEnc)
 	Reset(d *dict, singleBlock bool)
+	ResetPrefix(prefix []byte)
 }
 
 type encoderState struct {
@@ -60,6 +61,9 @@ type encoderState struct {
 	wg sync.WaitGroup
 	// This waitgroup indicates we have a block encoding/writing.
 	wWg sync.WaitGroup
+
+	// Parallel job state (used when concurrentBlocks is enabled).
+	jobs jobState
 }
 
 // NewWriter will create a new Zstandard encoder.
@@ -74,6 +78,9 @@ func NewWriter(w io.Writer, opts ...EOption) (*Encoder, error) {
 			return nil, err
 		}
 	}
+	if e.o.concurrentBlocks && (e.o.dict != nil || e.o.concurrent <= 1) {
+		e.o.concurrentBlocks = false
+	}
 	if w != nil {
 		e.Reset(w)
 	}
@@ -95,12 +102,31 @@ func (e *Encoder) initialize() {
 // as a new, independent stream.
 func (e *Encoder) Reset(w io.Writer) {
 	s := &e.state
+
+	if e.o.concurrentBlocks {
+		e.shutdownJobWorkers()
+		js := &s.jobs
+		js.jobSize = e.o.jobSize()
+		js.overlapSize = e.o.overlapSize()
+		// js.filling is allocated lazily on first Write/ReadFrom so callers
+		// that only use EncodeAll don't pay the (up to ~32 MB) jobSize cost.
+		js.filling = js.filling[:0]
+		if js.nextPrefix != nil {
+			js.putOverlapBuf(js.nextPrefix)
+			js.nextPrefix = nil
+		}
+		js.jobSeq = 0
+		js.flushedSeq = 0
+		js.flusherErr = nil
+		js.started = false
+	}
+
 	s.wg.Wait()
 	s.wWg.Wait()
 	if cap(s.filling) == 0 {
 		s.filling = make([]byte, 0, e.o.blockSize)
 	}
-	if e.o.concurrent > 1 {
+	if e.o.concurrent > 1 && !e.o.concurrentBlocks {
 		if cap(s.current) == 0 {
 			s.current = make([]byte, 0, e.o.blockSize)
 		}
@@ -145,6 +171,9 @@ func (e *Encoder) ResetWithOptions(w io.Writer, opts ...EOption) error {
 		}
 	}
 	hasDict := e.o.dict != nil
+	if e.o.concurrentBlocks && hasDict {
+		e.o.concurrentBlocks = false
+	}
 	if hadDict != hasDict {
 		// Dict presence changed — encoder type must be recreated.
 		e.state.encoder = nil
@@ -176,6 +205,49 @@ func (e *Encoder) Write(p []byte) (n int, err error) {
 	if s.eofWritten {
 		return 0, ErrEncoderClosed
 	}
+	if e.o.concurrentBlocks {
+		return e.writeJobs(p)
+	}
+	return e.writeBlocks(p)
+}
+
+func (e *Encoder) writeJobs(p []byte) (n int, err error) {
+	s := &e.state
+	js := &s.jobs
+	jobSize := js.jobSize
+	if cap(js.filling) == 0 && len(p) > 0 {
+		js.filling = make([]byte, 0, jobSize)
+	}
+	for len(p) > 0 {
+		if len(p)+len(js.filling) < jobSize {
+			if e.o.crc {
+				_, _ = s.encoder.CRC().Write(p)
+			}
+			js.filling = append(js.filling, p...)
+			return n + len(p), nil
+		}
+		add := p
+		if len(p)+len(js.filling) > jobSize {
+			add = add[:jobSize-len(js.filling)]
+		}
+		if e.o.crc {
+			_, _ = s.encoder.CRC().Write(add)
+		}
+		js.filling = append(js.filling, add...)
+		p = p[len(add):]
+		n += len(add)
+		if len(js.filling) < jobSize {
+			return n, nil
+		}
+		if err := e.dispatchJob(false); err != nil {
+			return n, err
+		}
+	}
+	return n, nil
+}
+
+func (e *Encoder) writeBlocks(p []byte) (n int, err error) {
+	s := &e.state
 	for len(p) > 0 {
 		if len(p)+len(s.filling) < e.o.blockSize {
 			if e.o.crc {
@@ -374,6 +446,10 @@ func (e *Encoder) ReadFrom(r io.Reader) (n int64, err error) {
 		println("Using ReadFrom")
 	}
 
+	if e.o.concurrentBlocks {
+		return e.readFromJobs(r)
+	}
+
 	// Flush any current writes.
 	if len(e.state.filling) > 0 {
 		if err := e.nextBlock(false); err != nil {
@@ -387,7 +463,6 @@ func (e *Encoder) ReadFrom(r io.Reader) (n int64, err error) {
 		if e.o.crc {
 			_, _ = e.state.encoder.CRC().Write(src[:n2])
 		}
-		// src is now the unfilled part...
 		src = src[n2:]
 		n += int64(n2)
 		switch err {
@@ -420,15 +495,63 @@ func (e *Encoder) ReadFrom(r io.Reader) (n int64, err error) {
 	}
 }
 
+func (e *Encoder) readFromJobs(r io.Reader) (n int64, err error) {
+	js := &e.state.jobs
+	jobSize := js.jobSize
+
+	// Flush any current filling.
+	if len(js.filling) > 0 {
+		if err := e.dispatchJob(false); err != nil {
+			return 0, err
+		}
+	}
+
+	if cap(js.filling) < jobSize {
+		js.filling = make([]byte, 0, jobSize)
+	}
+	js.filling = js.filling[:jobSize]
+	src := js.filling
+	for {
+		n2, err := r.Read(src)
+		if e.o.crc {
+			_, _ = e.state.encoder.CRC().Write(src[:n2])
+		}
+		src = src[n2:]
+		n += int64(n2)
+		switch err {
+		case io.EOF:
+			js.filling = js.filling[:len(js.filling)-len(src)]
+			return n, nil
+		case nil:
+		default:
+			e.state.err = err
+			return n, err
+		}
+		if len(src) > 0 {
+			continue
+		}
+		if err = e.dispatchJob(false); err != nil {
+			return n, err
+		}
+		if cap(js.filling) < jobSize {
+			js.filling = make([]byte, 0, jobSize)
+		}
+		js.filling = js.filling[:jobSize]
+		src = js.filling
+	}
+}
+
 // Flush will send the currently written data to output
 // and block until everything has been written.
 // This should only be used on rare occasions where pushing the currently queued data is critical.
 func (e *Encoder) Flush() error {
 	s := &e.state
+	if e.o.concurrentBlocks {
+		return e.flushJobs()
+	}
 	if len(s.filling) > 0 {
 		err := e.nextBlock(false)
 		if err != nil {
-			// Ignore Flush after Close.
 			if errors.Is(s.err, ErrEncoderClosed) {
 				return nil
 			}
@@ -438,7 +561,6 @@ func (e *Encoder) Flush() error {
 	s.wg.Wait()
 	s.wWg.Wait()
 	if s.err != nil {
-		// Ignore Flush after Close.
 		if errors.Is(s.err, ErrEncoderClosed) {
 			return nil
 		}
@@ -447,6 +569,20 @@ func (e *Encoder) Flush() error {
 	return s.writeErr
 }
 
+func (e *Encoder) flushJobs() error {
+	js := &e.state.jobs
+	if len(js.filling) > 0 {
+		if err := e.dispatchJob(false); err != nil {
+			return err
+		}
+	}
+	e.waitAllJobs()
+	js.mu.Lock()
+	fErr := js.flusherErr
+	js.mu.Unlock()
+	return fErr
+}
+
 // Close will flush the final output and close the stream.
 // The function will block until everything has been written.
 // The Encoder can still be re-used after calling this.
@@ -455,12 +591,16 @@ func (e *Encoder) Close() error {
 	if s.encoder == nil {
 		return nil
 	}
+	if e.o.concurrentBlocks {
+		return e.closeJobs()
+	}
 	if s.w == nil {
 		if len(s.filling) == 0 && !s.headerWritten && !s.eofWritten && s.nInput == 0 {
 			return nil
 		}
 		return errors.New("zstd: encoder has no writer")
 	}
+
 	err := e.nextBlock(true)
 	if err != nil {
 		if errors.Is(s.err, ErrEncoderClosed) {
@@ -511,6 +651,68 @@ func (e *Encoder) Close() error {
 	return s.err
 }
 
+func (e *Encoder) closeJobs() error {
+	s := &e.state
+	js := &s.jobs
+
+	if errors.Is(s.err, ErrEncoderClosed) {
+		return nil
+	}
+
+	if s.w == nil {
+		if len(js.filling) == 0 && !s.headerWritten && !s.eofWritten && s.nInput == 0 {
+			return nil
+		}
+		return errors.New("zstd: encoder has no writer")
+	}
+
+	if err := e.dispatchJob(true); err != nil {
+		e.shutdownJobWorkers()
+		if errors.Is(s.err, ErrEncoderClosed) {
+			return nil
+		}
+		return err
+	}
+
+	if s.frameContentSize > 0 && s.nInput != s.frameContentSize {
+		e.shutdownJobWorkers()
+		return fmt.Errorf("frame content size %d given, but %d bytes was written", s.frameContentSize, s.nInput)
+	}
+
+	if s.fullFrameWritten {
+		e.shutdownJobWorkers()
+		s.err = ErrEncoderClosed
+		return nil
+	}
+
+	e.shutdownJobWorkers()
+	if js.flusherErr != nil {
+		return js.flusherErr
+	}
+
+	// Write CRC
+	if e.o.crc {
+		var tmp [4]byte
+		_, s.err = s.w.Write(s.encoder.AppendCRC(tmp[:0]))
+		s.nWritten += 4
+	}
+
+	// Add padding
+	if s.err == nil && e.o.pad > 0 {
+		add := calcSkippableFrame(s.nWritten, int64(e.o.pad))
+		frame, err := skippableFrame(js.filling[:0], add, rand.Reader)
+		if err != nil {
+			return err
+		}
+		_, s.err = s.w.Write(frame)
+	}
+	if s.err == nil {
+		s.err = ErrEncoderClosed
+		return nil
+	}
+	return s.err
+}
+
 // EncodeAll will encode all input in src and append it to dst.
 // This function can be called concurrently, but each call will only run on a single goroutine.
 // If empty input is given, nothing is returned, unless WithZeroFrames is specified.
diff --git a/vendor/github.com/klauspost/compress/zstd/encoder_options.go b/vendor/github.com/klauspost/compress/zstd/encoder_options.go
index e217be0a17..a808149673 100644
--- a/vendor/github.com/klauspost/compress/zstd/encoder_options.go
+++ b/vendor/github.com/klauspost/compress/zstd/encoder_options.go
@@ -14,22 +14,23 @@ type EOption func(*encoderOptions) error
 
 // options retains accumulated state of multiple options.
 type encoderOptions struct {
-	resetOpt        bool
-	concurrent      int
-	level           EncoderLevel
-	single          *bool
-	pad             int
-	blockSize       int
-	windowSize      int
-	crc             bool
-	fullZero        bool
-	noEntropy       bool
-	allLitEntropy   bool
-	customWindow    bool
-	customALEntropy bool
-	customBlockSize bool
-	lowMem          bool
-	dict            *dict
+	resetOpt         bool
+	concurrent       int
+	level            EncoderLevel
+	single           *bool
+	pad              int
+	blockSize        int
+	windowSize       int
+	crc              bool
+	fullZero         bool
+	noEntropy        bool
+	allLitEntropy    bool
+	customWindow     bool
+	customALEntropy  bool
+	customBlockSize  bool
+	lowMem           bool
+	dict             *dict
+	concurrentBlocks bool
 }
 
 func (o *encoderOptions) setDefault() {
@@ -333,6 +334,42 @@ func WithLowerEncoderMem(b bool) EOption {
 	}
 }
 
+// WithConcurrentBlocks enables job-based parallel compression for streams.
+// When enabled and concurrent > 1, input is split into large sections (jobs)
+// that are compressed simultaneously by multiple goroutines.
+// Each non-first job receives an overlap prefix from the previous job for match context.
+// Output is flushed in order, producing a valid single-frame zstd stream.
+//
+// Currently disabled when used with dictionary encoding.
+// Cannot be changed with ResetWithOptions.
+func WithConcurrentBlocks(b bool) EOption {
+	return func(o *encoderOptions) error {
+		if o.resetOpt && b != o.concurrentBlocks {
+			return errors.New("WithConcurrentBlocks cannot be changed on Reset")
+		}
+		o.concurrentBlocks = b
+		return nil
+	}
+}
+
+// jobSize returns the input section size per parallel job.
+func (o *encoderOptions) jobSize() int {
+	s := max(o.windowSize*4, 512<<10)
+	return s
+}
+
+// overlapSize returns the overlap prefix size for parallel jobs.
+func (o *encoderOptions) overlapSize() int {
+	switch o.level {
+	case SpeedBestCompression:
+		return o.windowSize / 2
+	case SpeedBetterCompression:
+		return o.windowSize / 4
+	default:
+		return o.windowSize / 8
+	}
+}
+
 // WithEncoderDict allows to register a dictionary that will be used for the encode.
 //
 // The slice dict must be in the [dictionary format] produced by
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
index bcde398695..deeadc49eb 100644
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.s
@@ -1,4 +1,4 @@
-// Code generated by command: go run gen_fse.go -out ../fse_decoder_amd64.s -pkg=zstd. DO NOT EDIT.
+// Code generated by command: go run gen_fse.go -out ../fse_decoder.s -arch amd64,arm64 -pkg=zstd. DO NOT EDIT.
 
 //go:build !appengine && !noasm && gc && !noasm
 
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_arm64.s b/vendor/github.com/klauspost/compress/zstd/fse_decoder_arm64.s
new file mode 100644
index 0000000000..661761fb21
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder_arm64.s
@@ -0,0 +1,146 @@
+// Code generated by command: go run gen_fse.go -out ../fse_decoder.s -arch amd64,arm64 -pkg=zstd. DO NOT EDIT.
+// EXPERIMENTAL arm64 output lowered from an amd64 avo program.
+
+//go:build arm64 && !appengine && !noasm && gc && !noasm
+
+// func buildDtable_asm(s *fseDecoder, ctx *buildDtableAsmContext) int
+TEXT ·buildDtable_asm(SB), $0-24
+	MOVD ctx+8(FP), R1
+	MOVD s+0(FP), R6
+
+	// Load values
+	MOVBU 4098(R6), R2
+	MOVD  $0, R0
+	MOVD  $1, R16
+	LSL   R2, R16, R16
+	ORR   R16, R0, R0
+	MOVD  (R1), R3
+	MOVD  16(R1), R5
+	SUB   $1, R0, R7
+	MOVD  8(R1), R1
+	MOVHU 4096(R6), R6
+
+	// End load values
+	// Init, lay down lowprob symbols
+	MOVD $0, R8
+	JMP  init_main_loop_condition
+
+init_main_loop:
+	ADD  R8<<1, R1, R15
+	MOVH (R15), R9
+	CMN  $1, R9
+	BNE  do_not_update_high_threshold
+	ADD  R7<<3, R5, R15
+	MOVB R8, 1(R15)
+	SUB  $1, R7, R7
+	MOVD $0x0000000000000001, R9
+
+do_not_update_high_threshold:
+	ADD  R8<<1, R3, R15
+	MOVH R9, (R15)
+	ADD  $1, R8, R8
+
+init_main_loop_condition:
+	CMP R6, R8
+	BLT init_main_loop
+
+	// Spread symbols
+	// Calculate table step
+	MOVD R0, R8
+	LSR  $0x01, R8, R8
+	MOVD R0, R9
+	LSR  $0x03, R9, R9
+	ADD  R9, R8, R8
+	ADD  $3, R8, R8
+
+	// Fill add bits values
+	SUB  $1, R0, R9
+	MOVD $0, R10
+	MOVD $0, R11
+	JMP  spread_main_loop_condition
+
+spread_main_loop:
+	MOVD $0, R12
+	ADD  R11<<1, R1, R15
+	MOVH (R15), R13
+	JMP  spread_inner_loop_condition
+
+spread_inner_loop:
+	ADD  R10<<3, R5, R15
+	MOVB R11, 1(R15)
+
+adjust_position:
+	ADD R8, R10, R10
+	AND R9, R10, R10
+	CMP R7, R10
+	BGT adjust_position
+	ADD $1, R12, R12
+
+spread_inner_loop_condition:
+	CMP R13, R12
+	BLT spread_inner_loop
+	ADD $1, R11, R11
+
+spread_main_loop_condition:
+	CMP  R6, R11
+	BLT  spread_main_loop
+	TST  R10, R10
+	BEQ  spread_check_ok
+	MOVD ctx+8(FP), R0
+	MOVD R10, 24(R0)
+	MOVD $+1, R16
+	MOVD R16, ret+16(FP)
+	RET
+
+spread_check_ok:
+	// Build Decoding table
+	MOVD $0, R6
+
+build_table_main_table:
+	ADD   R6<<3, R5, R15
+	MOVBU 1(R15), R1
+	ADD   R1<<1, R3, R15
+	MOVHU (R15), R7
+	ADD   $1, R7, R8
+	ADD   R1<<1, R3, R15
+	MOVH  R8, (R15)
+	MOVD  R7, R8
+	CLZ   R8, R16
+	MOVD  $63, R8
+	SUB   R16, R8, R8
+	MOVD  R2, R1
+	SUB   R8, R1, R1
+	LSL   R1, R7, R7
+	SUB   R0, R7, R7
+	ADD   R6<<3, R5, R15
+	MOVB  R1, (R15)
+	ADD   R6<<3, R5, R15
+	MOVH  R7, 2(R15)
+	CMP   R0, R7
+	BLE   build_table_check1_ok
+	MOVD  ctx+8(FP), R1
+	MOVD  R7, 24(R1)
+	MOVD  R0, 32(R1)
+	MOVD  $+2, R16
+	MOVD  R16, ret+16(FP)
+	RET
+
+build_table_check1_ok:
+	TST  R1, R1
+	BNE  build_table_check2_ok
+	CMP  R6, R7
+	BNE  build_table_check2_ok
+	MOVD ctx+8(FP), R0
+	MOVD R7, 24(R0)
+	MOVD R6, 32(R0)
+	MOVD $+3, R16
+	MOVD R16, ret+16(FP)
+	RET
+
+build_table_check2_ok:
+	ADD  $1, R6, R6
+	CMP  R0, R6
+	BLT  build_table_main_table
+	MOVD $+0, R16
+	MOVD R16, ret+16(FP)
+	RET
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder_asm.go
similarity index 81%
rename from vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
rename to vendor/github.com/klauspost/compress/zstd/fse_decoder_asm.go
index b8c8607b5d..4ffc7e3c9f 100644
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder_amd64.go
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder_asm.go
@@ -1,4 +1,4 @@
-//go:build amd64 && !appengine && !noasm && gc
+//go:build (amd64 || arm64) && !appengine && !noasm && gc
 
 package zstd
 
@@ -6,6 +6,10 @@ import (
 	"fmt"
 )
 
+// buildDtable_asm is generated by _generate/gen_fse.go and lowered to each
+// architecture (amd64 by goasm, arm64 by the avo arm64 lowering printer). The
+// Go side is identical across architectures, so it lives here.
+
 type buildDtableAsmContext struct {
 	// inputs
 	stateTable *uint16
@@ -18,7 +22,7 @@ type buildDtableAsmContext struct {
 	errParam2 uint64
 }
 
-// buildDtable_asm is an x86 assembly implementation of fseDecoder.buildDtable.
+// buildDtable_asm is an assembly implementation of fseDecoder.buildDtable.
 // Function returns non-zero exit code on error.
 //
 //go:noescape
diff --git a/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go b/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
index 2138f8091a..38fd2ccb2a 100644
--- a/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
+++ b/vendor/github.com/klauspost/compress/zstd/fse_decoder_generic.go
@@ -1,4 +1,4 @@
-//go:build !amd64 || appengine || !gc || noasm
+//go:build (!amd64 && !arm64) || appengine || !gc || noasm
 
 package zstd
 
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
index 18c3703ddc..1281da885c 100644
--- a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.go
@@ -3,321 +3,83 @@
 package zstd
 
 import (
-	"fmt"
-	"io"
-
 	"github.com/klauspost/compress/internal/cpuinfo"
 )
 
-type decodeSyncAsmContext struct {
-	llTable     []decSymbol
-	mlTable     []decSymbol
-	ofTable     []decSymbol
-	llState     uint64
-	mlState     uint64
-	ofState     uint64
-	iteration   int
-	litRemain   int
-	out         []byte
-	outPosition int
-	literals    []byte
-	litPosition int
-	history     []byte
-	windowSize  int
-	ll          int // set on error (not for all errors, please refer to _generate/gen.go)
-	ml          int // set on error (not for all errors, please refer to _generate/gen.go)
-	mo          int // set on error (not for all errors, please refer to _generate/gen.go)
-}
+// The shared decode/decodeSync/executeSimple wrappers and context structs live
+// in seqdec_asm.go; this file only declares the amd64 asm routines and the
+// dispatch helpers that pick the BMI2 / non-BMI2 (and 56-bit / safe) variant.
 
-// sequenceDecs_decodeSync_amd64 implements the main loop of sequenceDecs.decodeSync in x86 asm.
+// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm.
 //
 // Please refer to seqdec_generic.go for the reference implementation.
 //
 //go:noescape
-func sequenceDecs_decodeSync_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+func sequenceDecs_decode_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
 
-// sequenceDecs_decodeSync_bmi2 implements the main loop of sequenceDecs.decodeSync in x86 asm with BMI2 extensions.
+// sequenceDecs_decode_56_amd64 implements the main loop of sequenceDecs in x86 asm.
 //
 //go:noescape
-func sequenceDecs_decodeSync_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+func sequenceDecs_decode_56_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
 
-// sequenceDecs_decodeSync_safe_amd64 does the same as above, but does not write more than output buffer.
+// sequenceDecs_decode_bmi2 implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
 //
 //go:noescape
-func sequenceDecs_decodeSync_safe_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+func sequenceDecs_decode_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
 
-// sequenceDecs_decodeSync_safe_bmi2 does the same as above, but does not write more than output buffer.
+// sequenceDecs_decode_56_bmi2 implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
 //
 //go:noescape
-func sequenceDecs_decodeSync_safe_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
-
-// decode sequences from the stream with the provided history but without a dictionary.
-func (s *sequenceDecs) decodeSyncSimple(hist []byte) (bool, error) {
-	if len(s.dict) > 0 {
-		return false, nil
-	}
-	if s.maxSyncLen == 0 && cap(s.out)-len(s.out) < maxCompressedBlockSize {
-		return false, nil
-	}
-
-	// FIXME: Using unsafe memory copies leads to rare, random crashes
-	// with fuzz testing. It is therefore disabled for now.
-	const useSafe = true
-	/*
-		useSafe := false
-		if s.maxSyncLen == 0 && cap(s.out)-len(s.out) < maxCompressedBlockSizeAlloc {
-			useSafe = true
-		}
-		if s.maxSyncLen > 0 && cap(s.out)-len(s.out)-compressedBlockOverAlloc < int(s.maxSyncLen) {
-			useSafe = true
-		}
-		if cap(s.literals) < len(s.literals)+compressedBlockOverAlloc {
-			useSafe = true
-		}
-	*/
-
-	br := s.br
-
-	maxBlockSize := min(s.windowSize, maxCompressedBlockSize)
-
-	ctx := decodeSyncAsmContext{
-		llTable:     s.litLengths.fse.dt[:maxTablesize],
-		mlTable:     s.matchLengths.fse.dt[:maxTablesize],
-		ofTable:     s.offsets.fse.dt[:maxTablesize],
-		llState:     uint64(s.litLengths.state.state),
-		mlState:     uint64(s.matchLengths.state.state),
-		ofState:     uint64(s.offsets.state.state),
-		iteration:   s.nSeqs - 1,
-		litRemain:   len(s.literals),
-		out:         s.out,
-		outPosition: len(s.out),
-		literals:    s.literals,
-		windowSize:  s.windowSize,
-		history:     hist,
-	}
-
-	s.seqSize = 0
-	startSize := len(s.out)
+func sequenceDecs_decode_56_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
 
-	var errCode int
+// decodeAsm runs the sequenceDecs decode loop, choosing the BMI2 / 56-bit variant.
+func decodeAsm(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext, lte56bits bool) int {
 	if cpuinfo.HasBMI2() {
-		if useSafe {
-			errCode = sequenceDecs_decodeSync_safe_bmi2(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decodeSync_bmi2(s, br, &ctx)
-		}
-	} else {
-		if useSafe {
-			errCode = sequenceDecs_decodeSync_safe_amd64(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decodeSync_amd64(s, br, &ctx)
-		}
-	}
-	switch errCode {
-	case noError:
-		break
-
-	case errorMatchLenOfsMismatch:
-		return true, fmt.Errorf("zero matchoff and matchlen (%d) > 0", ctx.ml)
-
-	case errorMatchLenTooBig:
-		return true, fmt.Errorf("match len (%d) bigger than max allowed length", ctx.ml)
-
-	case errorMatchOffTooBig:
-		return true, fmt.Errorf("match offset (%d) bigger than current history (%d)",
-			ctx.mo, ctx.outPosition+len(hist)-startSize)
-
-	case errorNotEnoughLiterals:
-		return true, fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available",
-			ctx.ll, ctx.litRemain+ctx.ll)
-
-	case errorOverread:
-		return true, io.ErrUnexpectedEOF
-
-	case errorNotEnoughSpace:
-		size := ctx.outPosition + ctx.ll + ctx.ml
-		if debugDecoder {
-			println("msl:", s.maxSyncLen, "cap", cap(s.out), "bef:", startSize, "sz:", size-startSize, "mbs:", maxBlockSize, "outsz:", cap(s.out)-startSize)
+		if lte56bits {
+			return sequenceDecs_decode_56_bmi2(s, br, ctx)
 		}
-		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-
-	default:
-		return true, fmt.Errorf("sequenceDecs_decode returned erroneous code %d", errCode)
-	}
-
-	s.seqSize += ctx.litRemain
-	if s.seqSize > maxBlockSize {
-		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+		return sequenceDecs_decode_bmi2(s, br, ctx)
 	}
-	err := br.close()
-	if err != nil {
-		printf("Closing sequences: %v, %+v\n", err, *br)
-		return true, err
+	if lte56bits {
+		return sequenceDecs_decode_56_amd64(s, br, ctx)
 	}
-
-	s.literals = s.literals[ctx.litPosition:]
-	t := ctx.outPosition
-	s.out = s.out[:t]
-
-	// Add final literals
-	s.out = append(s.out, s.literals...)
-	if debugDecoder {
-		t += len(s.literals)
-		if t != len(s.out) {
-			panic(fmt.Errorf("length mismatch, want %d, got %d", len(s.out), t))
-		}
-	}
-
-	return true, nil
+	return sequenceDecs_decode_amd64(s, br, ctx)
 }
 
-// --------------------------------------------------------------------------------
-
-type decodeAsmContext struct {
-	llTable   []decSymbol
-	mlTable   []decSymbol
-	ofTable   []decSymbol
-	llState   uint64
-	mlState   uint64
-	ofState   uint64
-	iteration int
-	seqs      []seqVals
-	litRemain int
-}
-
-const noError = 0
-
-// error reported when mo == 0 && ml > 0
-const errorMatchLenOfsMismatch = 1
-
-// error reported when ml > maxMatchLen
-const errorMatchLenTooBig = 2
-
-// error reported when mo > available history or mo > s.windowSize
-const errorMatchOffTooBig = 3
-
-// error reported when the sum of literal lengths exeeceds the literal buffer size
-const errorNotEnoughLiterals = 4
-
-// error reported when capacity of `out` is too small
-const errorNotEnoughSpace = 5
-
-// error reported when bits are overread.
-const errorOverread = 6
-
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm.
+// sequenceDecs_decodeSync_amd64 implements the main loop of sequenceDecs.decodeSync in x86 asm.
 //
 // Please refer to seqdec_generic.go for the reference implementation.
 //
 //go:noescape
-func sequenceDecs_decode_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+func sequenceDecs_decodeSync_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
 
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm.
-//
-// Please refer to seqdec_generic.go for the reference implementation.
+// sequenceDecs_decodeSync_bmi2 implements the main loop of sequenceDecs.decodeSync in x86 asm with BMI2 extensions.
 //
 //go:noescape
-func sequenceDecs_decode_56_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+func sequenceDecs_decodeSync_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
 
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
+// sequenceDecs_decodeSync_safe_amd64 does the same as above, but does not write more than output buffer.
 //
 //go:noescape
-func sequenceDecs_decode_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+func sequenceDecs_decodeSync_safe_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
 
-// sequenceDecs_decode implements the main loop of sequenceDecs in x86 asm with BMI2 extensions.
+// sequenceDecs_decodeSync_safe_bmi2 does the same as above, but does not write more than output buffer.
 //
 //go:noescape
-func sequenceDecs_decode_56_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
-
-// decode sequences from the stream without the provided history.
-func (s *sequenceDecs) decode(seqs []seqVals) error {
-	br := s.br
-
-	maxBlockSize := min(s.windowSize, maxCompressedBlockSize)
-
-	ctx := decodeAsmContext{
-		llTable:   s.litLengths.fse.dt[:maxTablesize],
-		mlTable:   s.matchLengths.fse.dt[:maxTablesize],
-		ofTable:   s.offsets.fse.dt[:maxTablesize],
-		llState:   uint64(s.litLengths.state.state),
-		mlState:   uint64(s.matchLengths.state.state),
-		ofState:   uint64(s.offsets.state.state),
-		seqs:      seqs,
-		iteration: len(seqs) - 1,
-		litRemain: len(s.literals),
-	}
-
-	if debugDecoder {
-		println("decode: decoding", len(seqs), "sequences", br.remain(), "bits remain on stream")
-	}
+func sequenceDecs_decodeSync_safe_bmi2(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
 
-	s.seqSize = 0
-	lte56bits := s.maxBits+s.offsets.fse.actualTableLog+s.matchLengths.fse.actualTableLog+s.litLengths.fse.actualTableLog <= 56
-	var errCode int
+// decodeSyncAsm runs the decodeSync loop, choosing the BMI2 / safe variant.
+func decodeSyncAsm(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext, safe bool) int {
 	if cpuinfo.HasBMI2() {
-		if lte56bits {
-			errCode = sequenceDecs_decode_56_bmi2(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decode_bmi2(s, br, &ctx)
-		}
-	} else {
-		if lte56bits {
-			errCode = sequenceDecs_decode_56_amd64(s, br, &ctx)
-		} else {
-			errCode = sequenceDecs_decode_amd64(s, br, &ctx)
+		if safe {
+			return sequenceDecs_decodeSync_safe_bmi2(s, br, ctx)
 		}
+		return sequenceDecs_decodeSync_bmi2(s, br, ctx)
 	}
-	if errCode != 0 {
-		i := len(seqs) - ctx.iteration - 1
-		switch errCode {
-		case errorMatchLenOfsMismatch:
-			ml := ctx.seqs[i].ml
-			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
-
-		case errorMatchLenTooBig:
-			ml := ctx.seqs[i].ml
-			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
-
-		case errorNotEnoughLiterals:
-			ll := ctx.seqs[i].ll
-			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, ctx.litRemain+ll)
-		case errorOverread:
-			return io.ErrUnexpectedEOF
-		}
-
-		return fmt.Errorf("sequenceDecs_decode_amd64 returned erroneous code %d", errCode)
+	if safe {
+		return sequenceDecs_decodeSync_safe_amd64(s, br, ctx)
 	}
-
-	if ctx.litRemain < 0 {
-		return fmt.Errorf("literal count is too big: total available %d, total requested %d",
-			len(s.literals), len(s.literals)-ctx.litRemain)
-	}
-
-	s.seqSize += ctx.litRemain
-	if s.seqSize > maxBlockSize {
-		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
-	}
-	if debugDecoder {
-		println("decode: ", br.remain(), "bits remain on stream. code:", errCode)
-	}
-	err := br.close()
-	if err != nil {
-		printf("Closing sequences: %v, %+v\n", err, *br)
-	}
-	return err
-}
-
-// --------------------------------------------------------------------------------
-
-type executeAsmContext struct {
-	seqs        []seqVals
-	seqIndex    int
-	out         []byte
-	history     []byte
-	literals    []byte
-	outPosition int
-	litPosition int
-	windowSize  int
+	return sequenceDecs_decodeSync_amd64(s, br, ctx)
 }
 
 // sequenceDecs_executeSimple_amd64 implements the main loop of sequenceDecs.executeSimple in x86 asm.
@@ -334,54 +96,10 @@ func sequenceDecs_executeSimple_amd64(ctx *executeAsmContext) bool
 //go:noescape
 func sequenceDecs_executeSimple_safe_amd64(ctx *executeAsmContext) bool
 
-// executeSimple handles cases when dictionary is not used.
-func (s *sequenceDecs) executeSimple(seqs []seqVals, hist []byte) error {
-	// Ensure we have enough output size...
-	if len(s.out)+s.seqSize+compressedBlockOverAlloc > cap(s.out) {
-		addBytes := s.seqSize + len(s.out) + compressedBlockOverAlloc
-		s.out = append(s.out, make([]byte, addBytes)...)
-		s.out = s.out[:len(s.out)-addBytes]
-	}
-
-	if debugDecoder {
-		printf("Execute %d seqs with literals: %d into %d bytes\n", len(seqs), len(s.literals), s.seqSize)
-	}
-
-	var t = len(s.out)
-	out := s.out[:t+s.seqSize]
-
-	ctx := executeAsmContext{
-		seqs:        seqs,
-		seqIndex:    0,
-		out:         out,
-		history:     hist,
-		outPosition: t,
-		litPosition: 0,
-		literals:    s.literals,
-		windowSize:  s.windowSize,
+// executeSimpleAsm runs the executeSimple loop, choosing the safe variant.
+func executeSimpleAsm(ctx *executeAsmContext, safe bool) bool {
+	if safe {
+		return sequenceDecs_executeSimple_safe_amd64(ctx)
 	}
-	var ok bool
-	if cap(s.literals) < len(s.literals)+compressedBlockOverAlloc {
-		ok = sequenceDecs_executeSimple_safe_amd64(&ctx)
-	} else {
-		ok = sequenceDecs_executeSimple_amd64(&ctx)
-	}
-	if !ok {
-		return fmt.Errorf("match offset (%d) bigger than current history (%d)",
-			seqs[ctx.seqIndex].mo, ctx.outPosition+len(hist))
-	}
-	s.literals = s.literals[ctx.litPosition:]
-	t = ctx.outPosition
-
-	// Add final literals
-	copy(out[t:], s.literals)
-	if debugDecoder {
-		t += len(s.literals)
-		if t != len(out) {
-			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
-		}
-	}
-	s.out = out
-
-	return nil
+	return sequenceDecs_executeSimple_amd64(ctx)
 }
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
index a708ca6d3d..3fc381c7a7 100644
--- a/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_amd64.s
@@ -1,4 +1,4 @@
-// Code generated by command: go run gen.go -out ../seqdec_amd64.s -pkg=zstd. DO NOT EDIT.
+// Code generated by command: go run gen.go -out ../seqdec.s -arch amd64,arm64 -pkg=zstd. DO NOT EDIT.
 
 //go:build !appengine && !noasm && gc && !noasm
 
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_arm64.go b/vendor/github.com/klauspost/compress/zstd/seqdec_arm64.go
new file mode 100644
index 0000000000..5ad262acff
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_arm64.go
@@ -0,0 +1,70 @@
+//go:build arm64 && !appengine && !noasm && gc
+
+package zstd
+
+// The shared decode/decodeSync/executeSimple wrappers and context structs live
+// in seqdec_asm.go; this file only declares the arm64 asm routines (generated
+// by the avo arm64 lowering printer) and the dispatch helpers. arm64 has no
+// BMI2, so each helper selects only between the 56-bit / safe variants.
+
+// sequenceDecs_decode_arm64 implements the main loop of sequenceDecs in arm64 asm.
+//
+// Please refer to seqdec_generic.go for the reference implementation.
+//
+//go:noescape
+func sequenceDecs_decode_arm64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+
+// sequenceDecs_decode_56_arm64 implements the main loop of sequenceDecs in arm64 asm.
+//
+//go:noescape
+func sequenceDecs_decode_56_arm64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+
+// decodeAsm runs the sequenceDecs decode loop, choosing the 56-bit variant.
+func decodeAsm(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext, lte56bits bool) int {
+	if lte56bits {
+		return sequenceDecs_decode_56_arm64(s, br, ctx)
+	}
+	return sequenceDecs_decode_arm64(s, br, ctx)
+}
+
+// sequenceDecs_decodeSync_arm64 implements the main loop of sequenceDecs.decodeSync in arm64 asm.
+//
+// Please refer to seqdec_generic.go for the reference implementation.
+//
+//go:noescape
+func sequenceDecs_decodeSync_arm64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+
+// sequenceDecs_decodeSync_safe_arm64 does the same as above, but does not write more than output buffer.
+//
+//go:noescape
+func sequenceDecs_decodeSync_safe_arm64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+
+// decodeSyncAsm runs the decodeSync loop, choosing the safe variant.
+func decodeSyncAsm(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext, safe bool) int {
+	if safe {
+		return sequenceDecs_decodeSync_safe_arm64(s, br, ctx)
+	}
+	return sequenceDecs_decodeSync_arm64(s, br, ctx)
+}
+
+// sequenceDecs_executeSimple_arm64 implements the main loop of sequenceDecs.executeSimple in arm64 asm.
+//
+// Returns false if a match offset is too big.
+//
+// Please refer to seqdec_generic.go for the reference implementation.
+//
+//go:noescape
+func sequenceDecs_executeSimple_arm64(ctx *executeAsmContext) bool
+
+// Same as above, but with safe memcopies
+//
+//go:noescape
+func sequenceDecs_executeSimple_safe_arm64(ctx *executeAsmContext) bool
+
+// executeSimpleAsm runs the executeSimple loop, choosing the safe variant.
+func executeSimpleAsm(ctx *executeAsmContext, safe bool) bool {
+	if safe {
+		return sequenceDecs_executeSimple_safe_arm64(ctx)
+	}
+	return sequenceDecs_executeSimple_arm64(ctx)
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_arm64.s b/vendor/github.com/klauspost/compress/zstd/seqdec_arm64.s
new file mode 100644
index 0000000000..75b19d732a
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_arm64.s
@@ -0,0 +1,2705 @@
+// Code generated by command: go run gen.go -out ../seqdec.s -arch amd64,arm64 -pkg=zstd. DO NOT EDIT.
+// EXPERIMENTAL arm64 output lowered from an amd64 avo program.
+
+//go:build arm64 && !appengine && !noasm && gc && !noasm
+
+// func sequenceDecs_decode_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+// Requires: CMOV
+TEXT ·sequenceDecs_decode_arm64(SB), $8-32
+	MOVD  br+8(FP), R1
+	MOVD  24(R1), R2
+	MOVBU 40(R1), R3
+	MOVD  (R1), R0
+	MOVD  32(R1), R5
+	ADD   R5, R0, R0
+	MOVD  R0, (RSP)
+	MOVD  ctx+16(FP), R0
+	MOVD  72(R0), R6
+	MOVD  80(R0), R7
+	MOVD  88(R0), R8
+	MOVD  104(R0), R9
+	MOVD  s+0(FP), R0
+	MOVD  144(R0), R10
+	MOVD  152(R0), R11
+	MOVD  160(R0), R12
+
+sequenceDecs_decode_amd64_main_loop:
+	MOVD (RSP), R13
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMP  $0x08, R5
+	BLT  sequenceDecs_decode_amd64_fill_byte_by_byte
+	MOVD R3, R0
+	LSR  $0x03, R0, R0
+	SUB  R0, R13, R13
+	MOVD (R13), R2
+	SUB  R0, R5, R5
+	AND  $0x07, R3, R3
+	JMP  sequenceDecs_decode_amd64_fill_end
+
+sequenceDecs_decode_amd64_fill_byte_by_byte:
+	CMP   $0x00, R5
+	BLE   sequenceDecs_decode_amd64_fill_check_overread
+	CMP   $0x07, R3
+	BLE   sequenceDecs_decode_amd64_fill_end
+	LSL   $0x08, R2, R2
+	SUB   $0x01, R13, R13
+	SUB   $0x01, R5, R5
+	SUB   $0x08, R3, R3
+	MOVBU (R13), R0
+	ORR   R0, R2, R2
+	JMP   sequenceDecs_decode_amd64_fill_byte_by_byte
+
+sequenceDecs_decode_amd64_fill_check_overread:
+	CMP $0x40, R3
+	BHI error_overread
+
+sequenceDecs_decode_amd64_fill_end:
+	// Update offset
+	MOVD R8, R0
+	MOVD R3, R1
+	MOVD R2, R14
+	LSL  R1, R14, R14
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decode_amd64_of_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decode_amd64_of_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decode_amd64_of_update_zero
+	NEG  R1, R1
+	LSR  R1, R14, R14
+	ADD  R14, R0, R0
+
+sequenceDecs_decode_amd64_of_update_zero:
+	MOVD R0, 16(R9)
+
+	// Update match length
+	MOVD R7, R0
+	MOVD R3, R1
+	MOVD R2, R14
+	LSL  R1, R14, R14
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decode_amd64_ml_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decode_amd64_ml_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decode_amd64_ml_update_zero
+	NEG  R1, R1
+	LSR  R1, R14, R14
+	ADD  R14, R0, R0
+
+sequenceDecs_decode_amd64_ml_update_zero:
+	MOVD R0, 8(R9)
+
+	// Fill bitreader to have enough for the remaining
+	CMP  $0x08, R5
+	BLT  sequenceDecs_decode_amd64_fill_2_byte_by_byte
+	MOVD R3, R0
+	LSR  $0x03, R0, R0
+	SUB  R0, R13, R13
+	MOVD (R13), R2
+	SUB  R0, R5, R5
+	AND  $0x07, R3, R3
+	JMP  sequenceDecs_decode_amd64_fill_2_end
+
+sequenceDecs_decode_amd64_fill_2_byte_by_byte:
+	CMP   $0x00, R5
+	BLE   sequenceDecs_decode_amd64_fill_2_check_overread
+	CMP   $0x07, R3
+	BLE   sequenceDecs_decode_amd64_fill_2_end
+	LSL   $0x08, R2, R2
+	SUB   $0x01, R13, R13
+	SUB   $0x01, R5, R5
+	SUB   $0x08, R3, R3
+	MOVBU (R13), R0
+	ORR   R0, R2, R2
+	JMP   sequenceDecs_decode_amd64_fill_2_byte_by_byte
+
+sequenceDecs_decode_amd64_fill_2_check_overread:
+	CMP $0x40, R3
+	BHI error_overread
+
+sequenceDecs_decode_amd64_fill_2_end:
+	// Update literal length
+	MOVD R6, R0
+	MOVD R3, R1
+	MOVD R2, R14
+	LSL  R1, R14, R14
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decode_amd64_ll_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decode_amd64_ll_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decode_amd64_ll_update_zero
+	NEG  R1, R1
+	LSR  R1, R14, R14
+	ADD  R14, R0, R0
+
+sequenceDecs_decode_amd64_ll_update_zero:
+	MOVD R0, (R9)
+
+	// Fill bitreader for state updates
+	MOVD  R13, (RSP)
+	MOVD  R8, R0
+	LSR   $0x08, R0, R0
+	MOVBU R0, R0
+	MOVD  ctx+16(FP), R1
+	MOVD  96(R1), R16
+	CMP   $0x00, R16
+	BEQ   sequenceDecs_decode_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBU R6, R13
+	LSRW  $0x10, R6, R6
+	ADD   R13, R3, R1
+	MOVD  R2, R14
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R14, R14
+	MOVD  $0x00000001, R4
+	MOVB  R13, R1
+	LSLW  R1, R4, R4
+	SUBW  $1, R4, R4
+	AND   R4, R14, R14
+	ADD   R14, R6, R6
+
+	// Load ctx.llTable
+	MOVD ctx+16(FP), R1
+	MOVD (R1), R1
+	ADD  R6<<3, R1, R15
+	MOVD (R15), R6
+
+	// Update Match Length State
+	MOVBU R7, R13
+	LSRW  $0x10, R7, R7
+	ADD   R13, R3, R1
+	MOVD  R2, R14
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R14, R14
+	MOVD  $0x00000001, R4
+	MOVB  R13, R1
+	LSLW  R1, R4, R4
+	SUBW  $1, R4, R4
+	AND   R4, R14, R14
+	ADD   R14, R7, R7
+
+	// Load ctx.mlTable
+	MOVD ctx+16(FP), R1
+	MOVD 24(R1), R1
+	ADD  R7<<3, R1, R15
+	MOVD (R15), R7
+
+	// Update Offset State
+	MOVBU R8, R13
+	LSRW  $0x10, R8, R8
+	ADD   R13, R3, R1
+	MOVD  R2, R14
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R14, R14
+	MOVD  $0x00000001, R4
+	MOVB  R13, R1
+	LSLW  R1, R4, R4
+	SUBW  $1, R4, R4
+	AND   R4, R14, R14
+	ADD   R14, R8, R8
+
+	// Load ctx.ofTable
+	MOVD ctx+16(FP), R1
+	MOVD 48(R1), R1
+	ADD  R8<<3, R1, R15
+	MOVD (R15), R8
+
+sequenceDecs_decode_amd64_skip_update:
+	// Adjust offset
+	MOVD 16(R9), R1
+	CMP  $0x01, R0
+	BLS  sequenceDecs_decode_amd64_adjust_offsetB_1_or_0
+	MOVD R11, R12
+	MOVD R10, R11
+	MOVD R1, R10
+	JMP  sequenceDecs_decode_amd64_after_adjust
+
+sequenceDecs_decode_amd64_adjust_offsetB_1_or_0:
+	MOVD (R9), R16
+	CMP  $0x00000000, R16
+	BNE  sequenceDecs_decode_amd64_adjust_offset_maybezero
+	ADD  $1, R1, R1
+	JMP  sequenceDecs_decode_amd64_adjust_offset_nonzero
+
+sequenceDecs_decode_amd64_adjust_offset_maybezero:
+	TST  R1, R1
+	BNE  sequenceDecs_decode_amd64_adjust_offset_nonzero
+	MOVD R10, R1
+	JMP  sequenceDecs_decode_amd64_after_adjust
+
+sequenceDecs_decode_amd64_adjust_offset_nonzero:
+	CMP $0x01, R1
+	BLO sequenceDecs_decode_amd64_adjust_zero
+	BEQ sequenceDecs_decode_amd64_adjust_one
+	CMP $0x02, R1
+	BHI sequenceDecs_decode_amd64_adjust_three
+	JMP sequenceDecs_decode_amd64_adjust_two
+
+sequenceDecs_decode_amd64_adjust_zero:
+	MOVD R10, R0
+	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_amd64_adjust_one:
+	MOVD R11, R0
+	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_amd64_adjust_two:
+	MOVD R12, R0
+	JMP  sequenceDecs_decode_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_amd64_adjust_three:
+	SUB $1, R10, R0
+
+sequenceDecs_decode_amd64_adjust_test_temp_valid:
+	TST  R0, R0
+	BNE  sequenceDecs_decode_amd64_adjust_temp_valid
+	MOVD $0x00000001, R0
+
+sequenceDecs_decode_amd64_adjust_temp_valid:
+	CMP  $0x01, R1
+	CSEL NE, R11, R12, R12
+	MOVD R10, R11
+	MOVD R0, R10
+	MOVD R0, R1
+
+sequenceDecs_decode_amd64_after_adjust:
+	MOVD R1, 16(R9)
+
+	// Check values
+	MOVD 8(R9), R0
+	MOVD (R9), R13
+	ADD  R13, R0, R14
+	MOVD s+0(FP), R4
+	MOVD 256(R4), R16
+	ADD  R14, R16, R16
+	MOVD R16, 256(R4)
+	MOVD ctx+16(FP), R14
+	MOVD 128(R14), R16
+	SUBS R13, R16, R16
+	MOVD R16, 128(R14)
+	BMI  error_not_enough_literals
+	CMP  $0x00020002, R0
+	BHI  sequenceDecs_decode_amd64_error_match_len_too_big
+	TST  R1, R1
+	BNE  sequenceDecs_decode_amd64_match_len_ofs_ok
+	TST  R0, R0
+	BNE  sequenceDecs_decode_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decode_amd64_match_len_ofs_ok:
+	ADD  $0x18, R9, R9
+	MOVD ctx+16(FP), R0
+	MOVD 96(R0), R16
+	SUBS $1, R16, R16
+	MOVD R16, 96(R0)
+	BPL  sequenceDecs_decode_amd64_main_loop
+	MOVD s+0(FP), R0
+	MOVD R10, 144(R0)
+	MOVD R11, 152(R0)
+	MOVD R12, 160(R0)
+	MOVD br+8(FP), R0
+	MOVD R2, 24(R0)
+	MOVB R3, 40(R0)
+	MOVD R5, 32(R0)
+
+	// Return success
+	MOVD $0x00000000, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decode_amd64_error_match_len_ofs_mismatch:
+	MOVD $0x00000001, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decode_amd64_error_match_len_too_big:
+	MOVD $0x00000002, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+	MOVD $0x00000003, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVD $0x00000004, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVD $0x00000006, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+// func sequenceDecs_decode_56_amd64(s *sequenceDecs, br *bitReader, ctx *decodeAsmContext) int
+// Requires: CMOV
+TEXT ·sequenceDecs_decode_56_arm64(SB), $8-32
+	MOVD  br+8(FP), R1
+	MOVD  24(R1), R2
+	MOVBU 40(R1), R3
+	MOVD  (R1), R0
+	MOVD  32(R1), R5
+	ADD   R5, R0, R0
+	MOVD  R0, (RSP)
+	MOVD  ctx+16(FP), R0
+	MOVD  72(R0), R6
+	MOVD  80(R0), R7
+	MOVD  88(R0), R8
+	MOVD  104(R0), R9
+	MOVD  s+0(FP), R0
+	MOVD  144(R0), R10
+	MOVD  152(R0), R11
+	MOVD  160(R0), R12
+
+sequenceDecs_decode_56_amd64_main_loop:
+	MOVD (RSP), R13
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMP  $0x08, R5
+	BLT  sequenceDecs_decode_56_amd64_fill_byte_by_byte
+	MOVD R3, R0
+	LSR  $0x03, R0, R0
+	SUB  R0, R13, R13
+	MOVD (R13), R2
+	SUB  R0, R5, R5
+	AND  $0x07, R3, R3
+	JMP  sequenceDecs_decode_56_amd64_fill_end
+
+sequenceDecs_decode_56_amd64_fill_byte_by_byte:
+	CMP   $0x00, R5
+	BLE   sequenceDecs_decode_56_amd64_fill_check_overread
+	CMP   $0x07, R3
+	BLE   sequenceDecs_decode_56_amd64_fill_end
+	LSL   $0x08, R2, R2
+	SUB   $0x01, R13, R13
+	SUB   $0x01, R5, R5
+	SUB   $0x08, R3, R3
+	MOVBU (R13), R0
+	ORR   R0, R2, R2
+	JMP   sequenceDecs_decode_56_amd64_fill_byte_by_byte
+
+sequenceDecs_decode_56_amd64_fill_check_overread:
+	CMP $0x40, R3
+	BHI error_overread
+
+sequenceDecs_decode_56_amd64_fill_end:
+	// Update offset
+	MOVD R8, R0
+	MOVD R3, R1
+	MOVD R2, R14
+	LSL  R1, R14, R14
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decode_56_amd64_of_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decode_56_amd64_of_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decode_56_amd64_of_update_zero
+	NEG  R1, R1
+	LSR  R1, R14, R14
+	ADD  R14, R0, R0
+
+sequenceDecs_decode_56_amd64_of_update_zero:
+	MOVD R0, 16(R9)
+
+	// Update match length
+	MOVD R7, R0
+	MOVD R3, R1
+	MOVD R2, R14
+	LSL  R1, R14, R14
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decode_56_amd64_ml_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decode_56_amd64_ml_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decode_56_amd64_ml_update_zero
+	NEG  R1, R1
+	LSR  R1, R14, R14
+	ADD  R14, R0, R0
+
+sequenceDecs_decode_56_amd64_ml_update_zero:
+	MOVD R0, 8(R9)
+
+	// Update literal length
+	MOVD R6, R0
+	MOVD R3, R1
+	MOVD R2, R14
+	LSL  R1, R14, R14
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decode_56_amd64_ll_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decode_56_amd64_ll_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decode_56_amd64_ll_update_zero
+	NEG  R1, R1
+	LSR  R1, R14, R14
+	ADD  R14, R0, R0
+
+sequenceDecs_decode_56_amd64_ll_update_zero:
+	MOVD R0, (R9)
+
+	// Fill bitreader for state updates
+	MOVD  R13, (RSP)
+	MOVD  R8, R0
+	LSR   $0x08, R0, R0
+	MOVBU R0, R0
+	MOVD  ctx+16(FP), R1
+	MOVD  96(R1), R16
+	CMP   $0x00, R16
+	BEQ   sequenceDecs_decode_56_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBU R6, R13
+	LSRW  $0x10, R6, R6
+	ADD   R13, R3, R1
+	MOVD  R2, R14
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R14, R14
+	MOVD  $0x00000001, R4
+	MOVB  R13, R1
+	LSLW  R1, R4, R4
+	SUBW  $1, R4, R4
+	AND   R4, R14, R14
+	ADD   R14, R6, R6
+
+	// Load ctx.llTable
+	MOVD ctx+16(FP), R1
+	MOVD (R1), R1
+	ADD  R6<<3, R1, R15
+	MOVD (R15), R6
+
+	// Update Match Length State
+	MOVBU R7, R13
+	LSRW  $0x10, R7, R7
+	ADD   R13, R3, R1
+	MOVD  R2, R14
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R14, R14
+	MOVD  $0x00000001, R4
+	MOVB  R13, R1
+	LSLW  R1, R4, R4
+	SUBW  $1, R4, R4
+	AND   R4, R14, R14
+	ADD   R14, R7, R7
+
+	// Load ctx.mlTable
+	MOVD ctx+16(FP), R1
+	MOVD 24(R1), R1
+	ADD  R7<<3, R1, R15
+	MOVD (R15), R7
+
+	// Update Offset State
+	MOVBU R8, R13
+	LSRW  $0x10, R8, R8
+	ADD   R13, R3, R1
+	MOVD  R2, R14
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R14, R14
+	MOVD  $0x00000001, R4
+	MOVB  R13, R1
+	LSLW  R1, R4, R4
+	SUBW  $1, R4, R4
+	AND   R4, R14, R14
+	ADD   R14, R8, R8
+
+	// Load ctx.ofTable
+	MOVD ctx+16(FP), R1
+	MOVD 48(R1), R1
+	ADD  R8<<3, R1, R15
+	MOVD (R15), R8
+
+sequenceDecs_decode_56_amd64_skip_update:
+	// Adjust offset
+	MOVD 16(R9), R1
+	CMP  $0x01, R0
+	BLS  sequenceDecs_decode_56_amd64_adjust_offsetB_1_or_0
+	MOVD R11, R12
+	MOVD R10, R11
+	MOVD R1, R10
+	JMP  sequenceDecs_decode_56_amd64_after_adjust
+
+sequenceDecs_decode_56_amd64_adjust_offsetB_1_or_0:
+	MOVD (R9), R16
+	CMP  $0x00000000, R16
+	BNE  sequenceDecs_decode_56_amd64_adjust_offset_maybezero
+	ADD  $1, R1, R1
+	JMP  sequenceDecs_decode_56_amd64_adjust_offset_nonzero
+
+sequenceDecs_decode_56_amd64_adjust_offset_maybezero:
+	TST  R1, R1
+	BNE  sequenceDecs_decode_56_amd64_adjust_offset_nonzero
+	MOVD R10, R1
+	JMP  sequenceDecs_decode_56_amd64_after_adjust
+
+sequenceDecs_decode_56_amd64_adjust_offset_nonzero:
+	CMP $0x01, R1
+	BLO sequenceDecs_decode_56_amd64_adjust_zero
+	BEQ sequenceDecs_decode_56_amd64_adjust_one
+	CMP $0x02, R1
+	BHI sequenceDecs_decode_56_amd64_adjust_three
+	JMP sequenceDecs_decode_56_amd64_adjust_two
+
+sequenceDecs_decode_56_amd64_adjust_zero:
+	MOVD R10, R0
+	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_56_amd64_adjust_one:
+	MOVD R11, R0
+	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_56_amd64_adjust_two:
+	MOVD R12, R0
+	JMP  sequenceDecs_decode_56_amd64_adjust_test_temp_valid
+
+sequenceDecs_decode_56_amd64_adjust_three:
+	SUB $1, R10, R0
+
+sequenceDecs_decode_56_amd64_adjust_test_temp_valid:
+	TST  R0, R0
+	BNE  sequenceDecs_decode_56_amd64_adjust_temp_valid
+	MOVD $0x00000001, R0
+
+sequenceDecs_decode_56_amd64_adjust_temp_valid:
+	CMP  $0x01, R1
+	CSEL NE, R11, R12, R12
+	MOVD R10, R11
+	MOVD R0, R10
+	MOVD R0, R1
+
+sequenceDecs_decode_56_amd64_after_adjust:
+	MOVD R1, 16(R9)
+
+	// Check values
+	MOVD 8(R9), R0
+	MOVD (R9), R13
+	ADD  R13, R0, R14
+	MOVD s+0(FP), R4
+	MOVD 256(R4), R16
+	ADD  R14, R16, R16
+	MOVD R16, 256(R4)
+	MOVD ctx+16(FP), R14
+	MOVD 128(R14), R16
+	SUBS R13, R16, R16
+	MOVD R16, 128(R14)
+	BMI  error_not_enough_literals
+	CMP  $0x00020002, R0
+	BHI  sequenceDecs_decode_56_amd64_error_match_len_too_big
+	TST  R1, R1
+	BNE  sequenceDecs_decode_56_amd64_match_len_ofs_ok
+	TST  R0, R0
+	BNE  sequenceDecs_decode_56_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decode_56_amd64_match_len_ofs_ok:
+	ADD  $0x18, R9, R9
+	MOVD ctx+16(FP), R0
+	MOVD 96(R0), R16
+	SUBS $1, R16, R16
+	MOVD R16, 96(R0)
+	BPL  sequenceDecs_decode_56_amd64_main_loop
+	MOVD s+0(FP), R0
+	MOVD R10, 144(R0)
+	MOVD R11, 152(R0)
+	MOVD R12, 160(R0)
+	MOVD br+8(FP), R0
+	MOVD R2, 24(R0)
+	MOVB R3, 40(R0)
+	MOVD R5, 32(R0)
+
+	// Return success
+	MOVD $0x00000000, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decode_56_amd64_error_match_len_ofs_mismatch:
+	MOVD $0x00000001, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decode_56_amd64_error_match_len_too_big:
+	MOVD $0x00000002, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+	MOVD $0x00000003, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVD $0x00000004, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVD $0x00000006, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+// skipped sequenceDecs_decode_bmi2 (BMI2 not available on arm64)
+
+// skipped sequenceDecs_decode_56_bmi2 (BMI2 not available on arm64)
+
+// func sequenceDecs_executeSimple_amd64(ctx *executeAsmContext) bool
+// Requires: SSE
+TEXT ·sequenceDecs_executeSimple_arm64(SB), $8-9
+	MOVD ctx+0(FP), R9
+	MOVD 8(R9), R1
+	TST  R1, R1
+	BEQ  empty_seqs
+	MOVD (R9), R0
+	MOVD 24(R9), R2
+	MOVD 32(R9), R3
+	MOVD 80(R9), R5
+	MOVD 104(R9), R6
+	MOVD 120(R9), R7
+	MOVD 56(R9), R8
+	MOVD 64(R9), R9
+	ADD  R9, R8, R8
+
+	// seqsBase += 24 * seqIndex
+	ADD R2<<1, R2, R10
+	LSL $0x03, R10, R10
+	ADD R10, R0, R0
+
+	// outBase += outPosition
+	ADD R6, R3, R3
+
+main_loop:
+	MOVD (R0), R10
+	MOVD 16(R0), R11
+	MOVD 8(R0), R12
+
+	// Copy literals
+	TST  R10, R10
+	BEQ  check_offset
+	MOVD $0, R13
+
+copy_1:
+	ADD  R13, R5, R15
+	VLD1 (R15), [V0.B16]
+	ADD  R13, R3, R15
+	VST1 [V0.B16], (R15)
+	ADD  $0x10, R13, R13
+	CMP  R10, R13
+	BLO  copy_1
+	ADD  R10, R5, R5
+	ADD  R10, R3, R3
+	ADD  R10, R6, R6
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	ADD R9, R6, R10
+	CMP R10, R11
+	BGT error_match_off_too_big
+	CMP R7, R11
+	BGT error_match_off_too_big
+
+	// Copy match from history
+	MOVD R11, R10
+	SUBS R6, R10, R10
+	BLS  copy_match
+	MOVD R8, R13
+	SUB  R10, R13, R13
+	CMP  R10, R12
+	BGT  copy_all_from_history
+	MOVD R12, R10
+	SUBS $0x10, R10, R10
+	BLO  copy_4_small
+
+copy_4_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R3)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R3, R3
+	SUBS $0x10, R10, R10
+	BHS  copy_4_loop
+	ADD  R10, R13, R13
+	ADD  $16, R13, R13
+	ADD  R10, R3, R3
+	ADD  $16, R3, R3
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R3, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_4_end
+
+copy_4_small:
+	CMP $0x03, R12
+	BEQ copy_4_move_3
+	CMP $0x08, R12
+	BLO copy_4_move_4through7
+	JMP copy_4_move_8through16
+
+copy_4_move_3:
+	MOVH (R13), R10
+	MOVB 2(R13), R11
+	MOVH R10, (R3)
+	MOVB R11, 2(R3)
+	ADD  R12, R13, R13
+	ADD  R12, R3, R3
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVWU (R13), R10
+	ADD   R12, R13, R15
+	MOVWU -4(R15), R11
+	MOVW  R10, (R3)
+	ADD   R12, R3, R15
+	MOVW  R11, -4(R15)
+	ADD   R12, R13, R13
+	ADD   R12, R3, R3
+	JMP   copy_4_end
+
+copy_4_move_8through16:
+	MOVD (R13), R10
+	ADD  R12, R13, R15
+	MOVD -8(R15), R11
+	MOVD R10, (R3)
+	ADD  R12, R3, R15
+	MOVD R11, -8(R15)
+	ADD  R12, R13, R13
+	ADD  R12, R3, R3
+
+copy_4_end:
+	ADD R12, R6, R6
+	ADD $0x18, R0, R0
+	ADD $1, R2, R2
+	CMP R1, R2
+	BLO main_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVD R10, R14
+	SUBS $0x10, R14, R14
+	BLO  copy_5_small
+
+copy_5_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R3)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R3, R3
+	SUBS $0x10, R14, R14
+	BHS  copy_5_loop
+	ADD  R14, R13, R13
+	ADD  $16, R13, R13
+	ADD  R14, R3, R3
+	ADD  $16, R3, R3
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R3, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_5_end
+
+copy_5_small:
+	CMP $0x03, R10
+	BEQ copy_5_move_3
+	BLO copy_5_move_1or2
+	CMP $0x08, R10
+	BLO copy_5_move_4through7
+	JMP copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R13), R14
+	ADD  R10, R13, R15
+	MOVB -1(R15), R4
+	MOVB R14, (R3)
+	ADD  R10, R3, R15
+	MOVB R4, -1(R15)
+	ADD  R10, R13, R13
+	ADD  R10, R3, R3
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVH (R13), R14
+	MOVB 2(R13), R4
+	MOVH R14, (R3)
+	MOVB R4, 2(R3)
+	ADD  R10, R13, R13
+	ADD  R10, R3, R3
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVWU (R13), R14
+	ADD   R10, R13, R15
+	MOVWU -4(R15), R4
+	MOVW  R14, (R3)
+	ADD   R10, R3, R15
+	MOVW  R4, -4(R15)
+	ADD   R10, R13, R13
+	ADD   R10, R3, R3
+	JMP   copy_5_end
+
+copy_5_move_8through16:
+	MOVD (R13), R14
+	ADD  R10, R13, R15
+	MOVD -8(R15), R4
+	MOVD R14, (R3)
+	ADD  R10, R3, R15
+	MOVD R4, -8(R15)
+	ADD  R10, R13, R13
+	ADD  R10, R3, R3
+
+copy_5_end:
+	ADD R10, R6, R6
+	SUB R10, R12, R12
+
+	// Copy match from the current buffer
+copy_match:
+	MOVD R3, R10
+	SUB  R11, R10, R10
+
+	// ml <= mo
+	CMP R11, R12
+	BHI copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADD  R12, R6, R6
+	MOVD R3, R11
+	ADD  R12, R3, R3
+
+copy_2:
+	VLD1 (R10), [V0.B16]
+	VST1 [V0.B16], (R11)
+	ADD  $0x10, R10, R10
+	ADD  $0x10, R11, R11
+	SUBS $0x10, R12, R12
+	BHI  copy_2
+	JMP  handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADD R12, R6, R6
+
+copy_slow_3:
+	MOVB (R10), R11
+	MOVB R11, (R3)
+	ADD  $1, R10, R10
+	ADD  $1, R3, R3
+	SUBS $1, R12, R12
+	BNE  copy_slow_3
+
+handle_loop:
+	ADD $0x18, R0, R0
+	ADD $1, R2, R2
+	CMP R1, R2
+	BLO main_loop
+
+loop_finished:
+	// Return value
+	MOVD $0x01, R16
+	MOVB R16, ret+8(FP)
+
+	// Update the context
+	MOVD ctx+0(FP), R0
+	MOVD R2, 24(R0)
+	MOVD R6, 104(R0)
+	MOVD 80(R0), R16
+	SUB  R16, R5, R5
+	MOVD R5, 112(R0)
+	RET
+
+error_match_off_too_big:
+	// Return value
+	MOVD $0x00, R16
+	MOVB R16, ret+8(FP)
+
+	// Update the context
+	MOVD ctx+0(FP), R0
+	MOVD R2, 24(R0)
+	MOVD R6, 104(R0)
+	MOVD 80(R0), R16
+	SUB  R16, R5, R5
+	MOVD R5, 112(R0)
+	RET
+
+empty_seqs:
+	// Return value
+	MOVD $0x01, R16
+	MOVB R16, ret+8(FP)
+	RET
+
+// func sequenceDecs_executeSimple_safe_amd64(ctx *executeAsmContext) bool
+// Requires: SSE
+TEXT ·sequenceDecs_executeSimple_safe_arm64(SB), $8-9
+	MOVD ctx+0(FP), R9
+	MOVD 8(R9), R1
+	TST  R1, R1
+	BEQ  empty_seqs
+	MOVD (R9), R0
+	MOVD 24(R9), R2
+	MOVD 32(R9), R3
+	MOVD 80(R9), R5
+	MOVD 104(R9), R6
+	MOVD 120(R9), R7
+	MOVD 56(R9), R8
+	MOVD 64(R9), R9
+	ADD  R9, R8, R8
+
+	// seqsBase += 24 * seqIndex
+	ADD R2<<1, R2, R10
+	LSL $0x03, R10, R10
+	ADD R10, R0, R0
+
+	// outBase += outPosition
+	ADD R6, R3, R3
+
+main_loop:
+	MOVD (R0), R10
+	MOVD 16(R0), R11
+	MOVD 8(R0), R12
+
+	// Copy literals
+	TST  R10, R10
+	BEQ  check_offset
+	MOVD R10, R13
+	SUBS $0x10, R13, R13
+	BLO  copy_1_small
+
+copy_1_loop:
+	VLD1 (R5), [V0.B16]
+	VST1 [V0.B16], (R3)
+	ADD  $0x10, R5, R5
+	ADD  $0x10, R3, R3
+	SUBS $0x10, R13, R13
+	BHS  copy_1_loop
+	ADD  R13, R5, R5
+	ADD  $16, R5, R5
+	ADD  R13, R3, R3
+	ADD  $16, R3, R3
+	ADD  $-16, R5, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R3, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_1_end
+
+copy_1_small:
+	CMP $0x03, R10
+	BEQ copy_1_move_3
+	BLO copy_1_move_1or2
+	CMP $0x08, R10
+	BLO copy_1_move_4through7
+	JMP copy_1_move_8through16
+
+copy_1_move_1or2:
+	MOVB (R5), R13
+	ADD  R10, R5, R15
+	MOVB -1(R15), R14
+	MOVB R13, (R3)
+	ADD  R10, R3, R15
+	MOVB R14, -1(R15)
+	ADD  R10, R5, R5
+	ADD  R10, R3, R3
+	JMP  copy_1_end
+
+copy_1_move_3:
+	MOVH (R5), R13
+	MOVB 2(R5), R14
+	MOVH R13, (R3)
+	MOVB R14, 2(R3)
+	ADD  R10, R5, R5
+	ADD  R10, R3, R3
+	JMP  copy_1_end
+
+copy_1_move_4through7:
+	MOVWU (R5), R13
+	ADD   R10, R5, R15
+	MOVWU -4(R15), R14
+	MOVW  R13, (R3)
+	ADD   R10, R3, R15
+	MOVW  R14, -4(R15)
+	ADD   R10, R5, R5
+	ADD   R10, R3, R3
+	JMP   copy_1_end
+
+copy_1_move_8through16:
+	MOVD (R5), R13
+	ADD  R10, R5, R15
+	MOVD -8(R15), R14
+	MOVD R13, (R3)
+	ADD  R10, R3, R15
+	MOVD R14, -8(R15)
+	ADD  R10, R5, R5
+	ADD  R10, R3, R3
+
+copy_1_end:
+	ADD R10, R6, R6
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	ADD R9, R6, R10
+	CMP R10, R11
+	BGT error_match_off_too_big
+	CMP R7, R11
+	BGT error_match_off_too_big
+
+	// Copy match from history
+	MOVD R11, R10
+	SUBS R6, R10, R10
+	BLS  copy_match
+	MOVD R8, R13
+	SUB  R10, R13, R13
+	CMP  R10, R12
+	BGT  copy_all_from_history
+	MOVD R12, R10
+	SUBS $0x10, R10, R10
+	BLO  copy_4_small
+
+copy_4_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R3)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R3, R3
+	SUBS $0x10, R10, R10
+	BHS  copy_4_loop
+	ADD  R10, R13, R13
+	ADD  $16, R13, R13
+	ADD  R10, R3, R3
+	ADD  $16, R3, R3
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R3, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_4_end
+
+copy_4_small:
+	CMP $0x03, R12
+	BEQ copy_4_move_3
+	CMP $0x08, R12
+	BLO copy_4_move_4through7
+	JMP copy_4_move_8through16
+
+copy_4_move_3:
+	MOVH (R13), R10
+	MOVB 2(R13), R11
+	MOVH R10, (R3)
+	MOVB R11, 2(R3)
+	ADD  R12, R13, R13
+	ADD  R12, R3, R3
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVWU (R13), R10
+	ADD   R12, R13, R15
+	MOVWU -4(R15), R11
+	MOVW  R10, (R3)
+	ADD   R12, R3, R15
+	MOVW  R11, -4(R15)
+	ADD   R12, R13, R13
+	ADD   R12, R3, R3
+	JMP   copy_4_end
+
+copy_4_move_8through16:
+	MOVD (R13), R10
+	ADD  R12, R13, R15
+	MOVD -8(R15), R11
+	MOVD R10, (R3)
+	ADD  R12, R3, R15
+	MOVD R11, -8(R15)
+	ADD  R12, R13, R13
+	ADD  R12, R3, R3
+
+copy_4_end:
+	ADD R12, R6, R6
+	ADD $0x18, R0, R0
+	ADD $1, R2, R2
+	CMP R1, R2
+	BLO main_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVD R10, R14
+	SUBS $0x10, R14, R14
+	BLO  copy_5_small
+
+copy_5_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R3)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R3, R3
+	SUBS $0x10, R14, R14
+	BHS  copy_5_loop
+	ADD  R14, R13, R13
+	ADD  $16, R13, R13
+	ADD  R14, R3, R3
+	ADD  $16, R3, R3
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R3, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_5_end
+
+copy_5_small:
+	CMP $0x03, R10
+	BEQ copy_5_move_3
+	BLO copy_5_move_1or2
+	CMP $0x08, R10
+	BLO copy_5_move_4through7
+	JMP copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R13), R14
+	ADD  R10, R13, R15
+	MOVB -1(R15), R4
+	MOVB R14, (R3)
+	ADD  R10, R3, R15
+	MOVB R4, -1(R15)
+	ADD  R10, R13, R13
+	ADD  R10, R3, R3
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVH (R13), R14
+	MOVB 2(R13), R4
+	MOVH R14, (R3)
+	MOVB R4, 2(R3)
+	ADD  R10, R13, R13
+	ADD  R10, R3, R3
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVWU (R13), R14
+	ADD   R10, R13, R15
+	MOVWU -4(R15), R4
+	MOVW  R14, (R3)
+	ADD   R10, R3, R15
+	MOVW  R4, -4(R15)
+	ADD   R10, R13, R13
+	ADD   R10, R3, R3
+	JMP   copy_5_end
+
+copy_5_move_8through16:
+	MOVD (R13), R14
+	ADD  R10, R13, R15
+	MOVD -8(R15), R4
+	MOVD R14, (R3)
+	ADD  R10, R3, R15
+	MOVD R4, -8(R15)
+	ADD  R10, R13, R13
+	ADD  R10, R3, R3
+
+copy_5_end:
+	ADD R10, R6, R6
+	SUB R10, R12, R12
+
+	// Copy match from the current buffer
+copy_match:
+	MOVD R3, R10
+	SUB  R11, R10, R10
+
+	// ml <= mo
+	CMP R11, R12
+	BHI copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADD  R12, R6, R6
+	MOVD R12, R11
+	SUBS $0x10, R11, R11
+	BLO  copy_2_small
+
+copy_2_loop:
+	VLD1 (R10), [V0.B16]
+	VST1 [V0.B16], (R3)
+	ADD  $0x10, R10, R10
+	ADD  $0x10, R3, R3
+	SUBS $0x10, R11, R11
+	BHS  copy_2_loop
+	ADD  R11, R10, R10
+	ADD  $16, R10, R10
+	ADD  R11, R3, R3
+	ADD  $16, R3, R3
+	ADD  $-16, R10, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R3, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_2_end
+
+copy_2_small:
+	CMP $0x03, R12
+	BEQ copy_2_move_3
+	BLO copy_2_move_1or2
+	CMP $0x08, R12
+	BLO copy_2_move_4through7
+	JMP copy_2_move_8through16
+
+copy_2_move_1or2:
+	MOVB (R10), R11
+	ADD  R12, R10, R15
+	MOVB -1(R15), R13
+	MOVB R11, (R3)
+	ADD  R12, R3, R15
+	MOVB R13, -1(R15)
+	ADD  R12, R10, R10
+	ADD  R12, R3, R3
+	JMP  copy_2_end
+
+copy_2_move_3:
+	MOVH (R10), R11
+	MOVB 2(R10), R13
+	MOVH R11, (R3)
+	MOVB R13, 2(R3)
+	ADD  R12, R10, R10
+	ADD  R12, R3, R3
+	JMP  copy_2_end
+
+copy_2_move_4through7:
+	MOVWU (R10), R11
+	ADD   R12, R10, R15
+	MOVWU -4(R15), R13
+	MOVW  R11, (R3)
+	ADD   R12, R3, R15
+	MOVW  R13, -4(R15)
+	ADD   R12, R10, R10
+	ADD   R12, R3, R3
+	JMP   copy_2_end
+
+copy_2_move_8through16:
+	MOVD (R10), R11
+	ADD  R12, R10, R15
+	MOVD -8(R15), R13
+	MOVD R11, (R3)
+	ADD  R12, R3, R15
+	MOVD R13, -8(R15)
+	ADD  R12, R10, R10
+	ADD  R12, R3, R3
+
+copy_2_end:
+	JMP handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADD R12, R6, R6
+
+copy_slow_3:
+	MOVB (R10), R11
+	MOVB R11, (R3)
+	ADD  $1, R10, R10
+	ADD  $1, R3, R3
+	SUBS $1, R12, R12
+	BNE  copy_slow_3
+
+handle_loop:
+	ADD $0x18, R0, R0
+	ADD $1, R2, R2
+	CMP R1, R2
+	BLO main_loop
+
+loop_finished:
+	// Return value
+	MOVD $0x01, R16
+	MOVB R16, ret+8(FP)
+
+	// Update the context
+	MOVD ctx+0(FP), R0
+	MOVD R2, 24(R0)
+	MOVD R6, 104(R0)
+	MOVD 80(R0), R16
+	SUB  R16, R5, R5
+	MOVD R5, 112(R0)
+	RET
+
+error_match_off_too_big:
+	// Return value
+	MOVD $0x00, R16
+	MOVB R16, ret+8(FP)
+
+	// Update the context
+	MOVD ctx+0(FP), R0
+	MOVD R2, 24(R0)
+	MOVD R6, 104(R0)
+	MOVD 80(R0), R16
+	SUB  R16, R5, R5
+	MOVD R5, 112(R0)
+	RET
+
+empty_seqs:
+	// Return value
+	MOVD $0x01, R16
+	MOVB R16, ret+8(FP)
+	RET
+
+// func sequenceDecs_decodeSync_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+// Requires: CMOV, SSE
+TEXT ·sequenceDecs_decodeSync_arm64(SB), $64-32
+	MOVD  br+8(FP), R1
+	MOVD  24(R1), R2
+	MOVBU 40(R1), R3
+	MOVD  (R1), R0
+	MOVD  32(R1), R5
+	ADD   R5, R0, R0
+	MOVD  R0, (RSP)
+	MOVD  ctx+16(FP), R0
+	MOVD  72(R0), R6
+	MOVD  80(R0), R7
+	MOVD  88(R0), R8
+	MOVD  $0, R1
+	MOVD  R1, 8(RSP)
+	MOVD  R1, 16(RSP)
+	MOVD  R1, 24(RSP)
+	MOVD  112(R0), R9
+	MOVD  128(R0), R1
+	MOVD  R1, 32(RSP)
+	MOVD  144(R0), R10
+	MOVD  136(R0), R11
+	MOVD  200(R0), R1
+	MOVD  R1, 56(RSP)
+	MOVD  176(R0), R1
+	MOVD  R1, 48(RSP)
+	MOVD  184(R0), R0
+	MOVD  R0, 40(RSP)
+	MOVD  40(RSP), R0
+	MOVD  48(RSP), R16
+	ADD   R0, R16, R16
+	MOVD  R16, 48(RSP)
+
+	// Calculate pointer to s.out[cap(s.out)] (a past-end pointer)
+	MOVD 32(RSP), R16
+	ADD  R9, R16, R16
+	MOVD R16, 32(RSP)
+
+	// outBase += outPosition
+	ADD R11, R9, R9
+
+sequenceDecs_decodeSync_amd64_main_loop:
+	MOVD (RSP), R12
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMP  $0x08, R5
+	BLT  sequenceDecs_decodeSync_amd64_fill_byte_by_byte
+	MOVD R3, R0
+	LSR  $0x03, R0, R0
+	SUB  R0, R12, R12
+	MOVD (R12), R2
+	SUB  R0, R5, R5
+	AND  $0x07, R3, R3
+	JMP  sequenceDecs_decodeSync_amd64_fill_end
+
+sequenceDecs_decodeSync_amd64_fill_byte_by_byte:
+	CMP   $0x00, R5
+	BLE   sequenceDecs_decodeSync_amd64_fill_check_overread
+	CMP   $0x07, R3
+	BLE   sequenceDecs_decodeSync_amd64_fill_end
+	LSL   $0x08, R2, R2
+	SUB   $0x01, R12, R12
+	SUB   $0x01, R5, R5
+	SUB   $0x08, R3, R3
+	MOVBU (R12), R0
+	ORR   R0, R2, R2
+	JMP   sequenceDecs_decodeSync_amd64_fill_byte_by_byte
+
+sequenceDecs_decodeSync_amd64_fill_check_overread:
+	CMP $0x40, R3
+	BHI error_overread
+
+sequenceDecs_decodeSync_amd64_fill_end:
+	// Update offset
+	MOVD R8, R0
+	MOVD R3, R1
+	MOVD R2, R13
+	LSL  R1, R13, R13
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decodeSync_amd64_of_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decodeSync_amd64_of_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decodeSync_amd64_of_update_zero
+	NEG  R1, R1
+	LSR  R1, R13, R13
+	ADD  R13, R0, R0
+
+sequenceDecs_decodeSync_amd64_of_update_zero:
+	MOVD R0, 8(RSP)
+
+	// Update match length
+	MOVD R7, R0
+	MOVD R3, R1
+	MOVD R2, R13
+	LSL  R1, R13, R13
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decodeSync_amd64_ml_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decodeSync_amd64_ml_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decodeSync_amd64_ml_update_zero
+	NEG  R1, R1
+	LSR  R1, R13, R13
+	ADD  R13, R0, R0
+
+sequenceDecs_decodeSync_amd64_ml_update_zero:
+	MOVD R0, 16(RSP)
+
+	// Fill bitreader to have enough for the remaining
+	CMP  $0x08, R5
+	BLT  sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte
+	MOVD R3, R0
+	LSR  $0x03, R0, R0
+	SUB  R0, R12, R12
+	MOVD (R12), R2
+	SUB  R0, R5, R5
+	AND  $0x07, R3, R3
+	JMP  sequenceDecs_decodeSync_amd64_fill_2_end
+
+sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte:
+	CMP   $0x00, R5
+	BLE   sequenceDecs_decodeSync_amd64_fill_2_check_overread
+	CMP   $0x07, R3
+	BLE   sequenceDecs_decodeSync_amd64_fill_2_end
+	LSL   $0x08, R2, R2
+	SUB   $0x01, R12, R12
+	SUB   $0x01, R5, R5
+	SUB   $0x08, R3, R3
+	MOVBU (R12), R0
+	ORR   R0, R2, R2
+	JMP   sequenceDecs_decodeSync_amd64_fill_2_byte_by_byte
+
+sequenceDecs_decodeSync_amd64_fill_2_check_overread:
+	CMP $0x40, R3
+	BHI error_overread
+
+sequenceDecs_decodeSync_amd64_fill_2_end:
+	// Update literal length
+	MOVD R6, R0
+	MOVD R3, R1
+	MOVD R2, R13
+	LSL  R1, R13, R13
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decodeSync_amd64_ll_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decodeSync_amd64_ll_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decodeSync_amd64_ll_update_zero
+	NEG  R1, R1
+	LSR  R1, R13, R13
+	ADD  R13, R0, R0
+
+sequenceDecs_decodeSync_amd64_ll_update_zero:
+	MOVD R0, 24(RSP)
+
+	// Fill bitreader for state updates
+	MOVD  R12, (RSP)
+	MOVD  R8, R0
+	LSR   $0x08, R0, R0
+	MOVBU R0, R0
+	MOVD  ctx+16(FP), R1
+	MOVD  96(R1), R16
+	CMP   $0x00, R16
+	BEQ   sequenceDecs_decodeSync_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBU R6, R12
+	LSRW  $0x10, R6, R6
+	ADD   R12, R3, R1
+	MOVD  R2, R13
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R13, R13
+	MOVD  $0x00000001, R14
+	MOVB  R12, R1
+	LSLW  R1, R14, R14
+	SUBW  $1, R14, R14
+	AND   R14, R13, R13
+	ADD   R13, R6, R6
+
+	// Load ctx.llTable
+	MOVD ctx+16(FP), R1
+	MOVD (R1), R1
+	ADD  R6<<3, R1, R15
+	MOVD (R15), R6
+
+	// Update Match Length State
+	MOVBU R7, R12
+	LSRW  $0x10, R7, R7
+	ADD   R12, R3, R1
+	MOVD  R2, R13
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R13, R13
+	MOVD  $0x00000001, R14
+	MOVB  R12, R1
+	LSLW  R1, R14, R14
+	SUBW  $1, R14, R14
+	AND   R14, R13, R13
+	ADD   R13, R7, R7
+
+	// Load ctx.mlTable
+	MOVD ctx+16(FP), R1
+	MOVD 24(R1), R1
+	ADD  R7<<3, R1, R15
+	MOVD (R15), R7
+
+	// Update Offset State
+	MOVBU R8, R12
+	LSRW  $0x10, R8, R8
+	ADD   R12, R3, R1
+	MOVD  R2, R13
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R13, R13
+	MOVD  $0x00000001, R14
+	MOVB  R12, R1
+	LSLW  R1, R14, R14
+	SUBW  $1, R14, R14
+	AND   R14, R13, R13
+	ADD   R13, R8, R8
+
+	// Load ctx.ofTable
+	MOVD ctx+16(FP), R1
+	MOVD 48(R1), R1
+	ADD  R8<<3, R1, R15
+	MOVD (R15), R8
+
+sequenceDecs_decodeSync_amd64_skip_update:
+	// Adjust offset
+	MOVD s+0(FP), R1
+	MOVD 8(RSP), R12
+	CMP  $0x01, R0
+	BLS  sequenceDecs_decodeSync_amd64_adjust_offsetB_1_or_0
+	ADD  $144, R1, R15
+	VLD1 (R15), [V0.B16]
+	MOVD R12, 144(R1)
+	ADD  $152, R1, R15
+	VST1 [V0.B16], (R15)
+	JMP  sequenceDecs_decodeSync_amd64_after_adjust
+
+sequenceDecs_decodeSync_amd64_adjust_offsetB_1_or_0:
+	MOVD 24(RSP), R16
+	CMP  $0x00000000, R16
+	BNE  sequenceDecs_decodeSync_amd64_adjust_offset_maybezero
+	ADD  $1, R12, R12
+	JMP  sequenceDecs_decodeSync_amd64_adjust_offset_nonzero
+
+sequenceDecs_decodeSync_amd64_adjust_offset_maybezero:
+	TST  R12, R12
+	BNE  sequenceDecs_decodeSync_amd64_adjust_offset_nonzero
+	MOVD 144(R1), R12
+	JMP  sequenceDecs_decodeSync_amd64_after_adjust
+
+sequenceDecs_decodeSync_amd64_adjust_offset_nonzero:
+	MOVD R12, R0
+	MOVD $0, R13
+	MOVD $-1, R14
+	CMP  $0x03, R12
+	CSEL EQ, R13, R0, R0
+	CSEL EQ, R14, R13, R13
+	ADD  R0<<3, R1, R15
+	MOVD 144(R15), R16
+	ADDS R16, R13, R13
+	BNE  sequenceDecs_decodeSync_amd64_adjust_temp_valid
+	MOVD $0x00000001, R13
+
+sequenceDecs_decodeSync_amd64_adjust_temp_valid:
+	CMP  $0x01, R12
+	BEQ  sequenceDecs_decodeSync_amd64_adjust_skip
+	MOVD 152(R1), R0
+	MOVD R0, 160(R1)
+
+sequenceDecs_decodeSync_amd64_adjust_skip:
+	MOVD 144(R1), R0
+	MOVD R0, 152(R1)
+	MOVD R13, 144(R1)
+	MOVD R13, R12
+
+sequenceDecs_decodeSync_amd64_after_adjust:
+	MOVD R12, 8(RSP)
+
+	// Check values
+	MOVD 16(RSP), R0
+	MOVD 24(RSP), R1
+	ADD  R1, R0, R13
+	MOVD s+0(FP), R14
+	MOVD 256(R14), R16
+	ADD  R13, R16, R16
+	MOVD R16, 256(R14)
+	MOVD ctx+16(FP), R13
+	MOVD 104(R13), R16
+	SUBS R1, R16, R16
+	MOVD R16, 104(R13)
+	BMI  error_not_enough_literals
+	CMP  $0x00020002, R0
+	BHI  sequenceDecs_decodeSync_amd64_error_match_len_too_big
+	TST  R12, R12
+	BNE  sequenceDecs_decodeSync_amd64_match_len_ofs_ok
+	TST  R0, R0
+	BNE  sequenceDecs_decodeSync_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decodeSync_amd64_match_len_ofs_ok:
+	MOVD 24(RSP), R0
+	MOVD 8(RSP), R1
+	MOVD 16(RSP), R12
+
+	// Check if we have enough space in s.out
+	ADD  R12, R0, R13
+	ADD  R9, R13, R13
+	MOVD 32(RSP), R16
+	CMP  R16, R13
+	BHI  error_not_enough_space
+
+	// Copy literals
+	TST  R0, R0
+	BEQ  check_offset
+	MOVD $0, R13
+
+copy_1:
+	ADD  R13, R10, R15
+	VLD1 (R15), [V0.B16]
+	ADD  R13, R9, R15
+	VST1 [V0.B16], (R15)
+	ADD  $0x10, R13, R13
+	CMP  R0, R13
+	BLO  copy_1
+	ADD  R0, R10, R10
+	ADD  R0, R9, R9
+	ADD  R0, R11, R11
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	MOVD R11, R0
+	MOVD 40(RSP), R16
+	ADD  R16, R0, R0
+	CMP  R0, R1
+	BGT  error_match_off_too_big
+	MOVD 56(RSP), R16
+	CMP  R16, R1
+	BGT  error_match_off_too_big
+
+	// Copy match from history
+	MOVD R1, R0
+	SUBS R11, R0, R0
+	BLS  copy_match
+	MOVD 48(RSP), R13
+	SUB  R0, R13, R13
+	CMP  R0, R12
+	BGT  copy_all_from_history
+	MOVD R12, R0
+	SUBS $0x10, R0, R0
+	BLO  copy_4_small
+
+copy_4_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R9)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R9, R9
+	SUBS $0x10, R0, R0
+	BHS  copy_4_loop
+	ADD  R0, R13, R13
+	ADD  $16, R13, R13
+	ADD  R0, R9, R9
+	ADD  $16, R9, R9
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R9, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_4_end
+
+copy_4_small:
+	CMP $0x03, R12
+	BEQ copy_4_move_3
+	CMP $0x08, R12
+	BLO copy_4_move_4through7
+	JMP copy_4_move_8through16
+
+copy_4_move_3:
+	MOVH (R13), R0
+	MOVB 2(R13), R1
+	MOVH R0, (R9)
+	MOVB R1, 2(R9)
+	ADD  R12, R13, R13
+	ADD  R12, R9, R9
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVWU (R13), R0
+	ADD   R12, R13, R15
+	MOVWU -4(R15), R1
+	MOVW  R0, (R9)
+	ADD   R12, R9, R15
+	MOVW  R1, -4(R15)
+	ADD   R12, R13, R13
+	ADD   R12, R9, R9
+	JMP   copy_4_end
+
+copy_4_move_8through16:
+	MOVD (R13), R0
+	ADD  R12, R13, R15
+	MOVD -8(R15), R1
+	MOVD R0, (R9)
+	ADD  R12, R9, R15
+	MOVD R1, -8(R15)
+	ADD  R12, R13, R13
+	ADD  R12, R9, R9
+
+copy_4_end:
+	ADD R12, R11, R11
+	JMP handle_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVD R0, R14
+	SUBS $0x10, R14, R14
+	BLO  copy_5_small
+
+copy_5_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R9)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R9, R9
+	SUBS $0x10, R14, R14
+	BHS  copy_5_loop
+	ADD  R14, R13, R13
+	ADD  $16, R13, R13
+	ADD  R14, R9, R9
+	ADD  $16, R9, R9
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R9, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_5_end
+
+copy_5_small:
+	CMP $0x03, R0
+	BEQ copy_5_move_3
+	BLO copy_5_move_1or2
+	CMP $0x08, R0
+	BLO copy_5_move_4through7
+	JMP copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R13), R14
+	ADD  R0, R13, R15
+	MOVB -1(R15), R4
+	MOVB R14, (R9)
+	ADD  R0, R9, R15
+	MOVB R4, -1(R15)
+	ADD  R0, R13, R13
+	ADD  R0, R9, R9
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVH (R13), R14
+	MOVB 2(R13), R4
+	MOVH R14, (R9)
+	MOVB R4, 2(R9)
+	ADD  R0, R13, R13
+	ADD  R0, R9, R9
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVWU (R13), R14
+	ADD   R0, R13, R15
+	MOVWU -4(R15), R4
+	MOVW  R14, (R9)
+	ADD   R0, R9, R15
+	MOVW  R4, -4(R15)
+	ADD   R0, R13, R13
+	ADD   R0, R9, R9
+	JMP   copy_5_end
+
+copy_5_move_8through16:
+	MOVD (R13), R14
+	ADD  R0, R13, R15
+	MOVD -8(R15), R4
+	MOVD R14, (R9)
+	ADD  R0, R9, R15
+	MOVD R4, -8(R15)
+	ADD  R0, R13, R13
+	ADD  R0, R9, R9
+
+copy_5_end:
+	ADD R0, R11, R11
+	SUB R0, R12, R12
+
+	// Copy match from the current buffer
+copy_match:
+	MOVD R9, R0
+	SUB  R1, R0, R0
+
+	// ml <= mo
+	CMP R1, R12
+	BHI copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADD  R12, R11, R11
+	MOVD R9, R1
+	ADD  R12, R9, R9
+
+copy_2:
+	VLD1 (R0), [V0.B16]
+	VST1 [V0.B16], (R1)
+	ADD  $0x10, R0, R0
+	ADD  $0x10, R1, R1
+	SUBS $0x10, R12, R12
+	BHI  copy_2
+	JMP  handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADD R12, R11, R11
+
+copy_slow_3:
+	MOVB (R0), R1
+	MOVB R1, (R9)
+	ADD  $1, R0, R0
+	ADD  $1, R9, R9
+	SUBS $1, R12, R12
+	BNE  copy_slow_3
+
+handle_loop:
+	MOVD ctx+16(FP), R0
+	MOVD 96(R0), R16
+	SUBS $1, R16, R16
+	MOVD R16, 96(R0)
+	BPL  sequenceDecs_decodeSync_amd64_main_loop
+
+loop_finished:
+	MOVD br+8(FP), R0
+	MOVD R2, 24(R0)
+	MOVB R3, 40(R0)
+	MOVD R5, 32(R0)
+
+	// Update the context
+	MOVD ctx+16(FP), R0
+	MOVD R11, 136(R0)
+	MOVD 144(R0), R1
+	SUB  R1, R10, R10
+	MOVD R10, 168(R0)
+
+	// Return success
+	MOVD $0x00000000, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decodeSync_amd64_error_match_len_ofs_mismatch:
+	MOVD 16(RSP), R0
+	MOVD ctx+16(FP), R1
+	MOVD R0, 216(R1)
+	MOVD $0x00000001, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decodeSync_amd64_error_match_len_too_big:
+	MOVD ctx+16(FP), R0
+	MOVD 16(RSP), R1
+	MOVD R1, 216(R0)
+	MOVD $0x00000002, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+error_match_off_too_big:
+	MOVD ctx+16(FP), R0
+	MOVD 8(RSP), R1
+	MOVD R1, 224(R0)
+	MOVD R11, 136(R0)
+	MOVD $0x00000003, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVD ctx+16(FP), R0
+	MOVD 24(RSP), R1
+	MOVD R1, 208(R0)
+	MOVD $0x00000004, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVD $0x00000006, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with not enough output space error
+error_not_enough_space:
+	MOVD ctx+16(FP), R0
+	MOVD 24(RSP), R1
+	MOVD R1, 208(R0)
+	MOVD 16(RSP), R1
+	MOVD R1, 216(R0)
+	MOVD R11, 136(R0)
+	MOVD $0x00000005, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+// skipped sequenceDecs_decodeSync_bmi2 (BMI2 not available on arm64)
+
+// func sequenceDecs_decodeSync_safe_amd64(s *sequenceDecs, br *bitReader, ctx *decodeSyncAsmContext) int
+// Requires: CMOV, SSE
+TEXT ·sequenceDecs_decodeSync_safe_arm64(SB), $64-32
+	MOVD  br+8(FP), R1
+	MOVD  24(R1), R2
+	MOVBU 40(R1), R3
+	MOVD  (R1), R0
+	MOVD  32(R1), R5
+	ADD   R5, R0, R0
+	MOVD  R0, (RSP)
+	MOVD  ctx+16(FP), R0
+	MOVD  72(R0), R6
+	MOVD  80(R0), R7
+	MOVD  88(R0), R8
+	MOVD  $0, R1
+	MOVD  R1, 8(RSP)
+	MOVD  R1, 16(RSP)
+	MOVD  R1, 24(RSP)
+	MOVD  112(R0), R9
+	MOVD  128(R0), R1
+	MOVD  R1, 32(RSP)
+	MOVD  144(R0), R10
+	MOVD  136(R0), R11
+	MOVD  200(R0), R1
+	MOVD  R1, 56(RSP)
+	MOVD  176(R0), R1
+	MOVD  R1, 48(RSP)
+	MOVD  184(R0), R0
+	MOVD  R0, 40(RSP)
+	MOVD  40(RSP), R0
+	MOVD  48(RSP), R16
+	ADD   R0, R16, R16
+	MOVD  R16, 48(RSP)
+
+	// Calculate pointer to s.out[cap(s.out)] (a past-end pointer)
+	MOVD 32(RSP), R16
+	ADD  R9, R16, R16
+	MOVD R16, 32(RSP)
+
+	// outBase += outPosition
+	ADD R11, R9, R9
+
+sequenceDecs_decodeSync_safe_amd64_main_loop:
+	MOVD (RSP), R12
+
+	// Fill bitreader to have enough for the offset and match length.
+	CMP  $0x08, R5
+	BLT  sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte
+	MOVD R3, R0
+	LSR  $0x03, R0, R0
+	SUB  R0, R12, R12
+	MOVD (R12), R2
+	SUB  R0, R5, R5
+	AND  $0x07, R3, R3
+	JMP  sequenceDecs_decodeSync_safe_amd64_fill_end
+
+sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte:
+	CMP   $0x00, R5
+	BLE   sequenceDecs_decodeSync_safe_amd64_fill_check_overread
+	CMP   $0x07, R3
+	BLE   sequenceDecs_decodeSync_safe_amd64_fill_end
+	LSL   $0x08, R2, R2
+	SUB   $0x01, R12, R12
+	SUB   $0x01, R5, R5
+	SUB   $0x08, R3, R3
+	MOVBU (R12), R0
+	ORR   R0, R2, R2
+	JMP   sequenceDecs_decodeSync_safe_amd64_fill_byte_by_byte
+
+sequenceDecs_decodeSync_safe_amd64_fill_check_overread:
+	CMP $0x40, R3
+	BHI error_overread
+
+sequenceDecs_decodeSync_safe_amd64_fill_end:
+	// Update offset
+	MOVD R8, R0
+	MOVD R3, R1
+	MOVD R2, R13
+	LSL  R1, R13, R13
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decodeSync_safe_amd64_of_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decodeSync_safe_amd64_of_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decodeSync_safe_amd64_of_update_zero
+	NEG  R1, R1
+	LSR  R1, R13, R13
+	ADD  R13, R0, R0
+
+sequenceDecs_decodeSync_safe_amd64_of_update_zero:
+	MOVD R0, 8(RSP)
+
+	// Update match length
+	MOVD R7, R0
+	MOVD R3, R1
+	MOVD R2, R13
+	LSL  R1, R13, R13
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decodeSync_safe_amd64_ml_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decodeSync_safe_amd64_ml_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decodeSync_safe_amd64_ml_update_zero
+	NEG  R1, R1
+	LSR  R1, R13, R13
+	ADD  R13, R0, R0
+
+sequenceDecs_decodeSync_safe_amd64_ml_update_zero:
+	MOVD R0, 16(RSP)
+
+	// Fill bitreader to have enough for the remaining
+	CMP  $0x08, R5
+	BLT  sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte
+	MOVD R3, R0
+	LSR  $0x03, R0, R0
+	SUB  R0, R12, R12
+	MOVD (R12), R2
+	SUB  R0, R5, R5
+	AND  $0x07, R3, R3
+	JMP  sequenceDecs_decodeSync_safe_amd64_fill_2_end
+
+sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte:
+	CMP   $0x00, R5
+	BLE   sequenceDecs_decodeSync_safe_amd64_fill_2_check_overread
+	CMP   $0x07, R3
+	BLE   sequenceDecs_decodeSync_safe_amd64_fill_2_end
+	LSL   $0x08, R2, R2
+	SUB   $0x01, R12, R12
+	SUB   $0x01, R5, R5
+	SUB   $0x08, R3, R3
+	MOVBU (R12), R0
+	ORR   R0, R2, R2
+	JMP   sequenceDecs_decodeSync_safe_amd64_fill_2_byte_by_byte
+
+sequenceDecs_decodeSync_safe_amd64_fill_2_check_overread:
+	CMP $0x40, R3
+	BHI error_overread
+
+sequenceDecs_decodeSync_safe_amd64_fill_2_end:
+	// Update literal length
+	MOVD R6, R0
+	MOVD R3, R1
+	MOVD R2, R13
+	LSL  R1, R13, R13
+	UBFX $8, R0, $8, R1
+	LSR  $0x20, R0, R0
+	TST  R1, R1
+	BEQ  sequenceDecs_decodeSync_safe_amd64_ll_update_zero
+	ADD  R1, R3, R3
+	CMP  $0x40, R3
+	BHI  sequenceDecs_decodeSync_safe_amd64_ll_update_zero
+	CMP  $0x40, R1
+	BHS  sequenceDecs_decodeSync_safe_amd64_ll_update_zero
+	NEG  R1, R1
+	LSR  R1, R13, R13
+	ADD  R13, R0, R0
+
+sequenceDecs_decodeSync_safe_amd64_ll_update_zero:
+	MOVD R0, 24(RSP)
+
+	// Fill bitreader for state updates
+	MOVD  R12, (RSP)
+	MOVD  R8, R0
+	LSR   $0x08, R0, R0
+	MOVBU R0, R0
+	MOVD  ctx+16(FP), R1
+	MOVD  96(R1), R16
+	CMP   $0x00, R16
+	BEQ   sequenceDecs_decodeSync_safe_amd64_skip_update
+
+	// Update Literal Length State
+	MOVBU R6, R12
+	LSRW  $0x10, R6, R6
+	ADD   R12, R3, R1
+	MOVD  R2, R13
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R13, R13
+	MOVD  $0x00000001, R14
+	MOVB  R12, R1
+	LSLW  R1, R14, R14
+	SUBW  $1, R14, R14
+	AND   R14, R13, R13
+	ADD   R13, R6, R6
+
+	// Load ctx.llTable
+	MOVD ctx+16(FP), R1
+	MOVD (R1), R1
+	ADD  R6<<3, R1, R15
+	MOVD (R15), R6
+
+	// Update Match Length State
+	MOVBU R7, R12
+	LSRW  $0x10, R7, R7
+	ADD   R12, R3, R1
+	MOVD  R2, R13
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R13, R13
+	MOVD  $0x00000001, R14
+	MOVB  R12, R1
+	LSLW  R1, R14, R14
+	SUBW  $1, R14, R14
+	AND   R14, R13, R13
+	ADD   R13, R7, R7
+
+	// Load ctx.mlTable
+	MOVD ctx+16(FP), R1
+	MOVD 24(R1), R1
+	ADD  R7<<3, R1, R15
+	MOVD (R15), R7
+
+	// Update Offset State
+	MOVBU R8, R12
+	LSRW  $0x10, R8, R8
+	ADD   R12, R3, R1
+	MOVD  R2, R13
+	MOVD  R1, R3
+	NEG   R1, R16
+	ROR   R16, R13, R13
+	MOVD  $0x00000001, R14
+	MOVB  R12, R1
+	LSLW  R1, R14, R14
+	SUBW  $1, R14, R14
+	AND   R14, R13, R13
+	ADD   R13, R8, R8
+
+	// Load ctx.ofTable
+	MOVD ctx+16(FP), R1
+	MOVD 48(R1), R1
+	ADD  R8<<3, R1, R15
+	MOVD (R15), R8
+
+sequenceDecs_decodeSync_safe_amd64_skip_update:
+	// Adjust offset
+	MOVD s+0(FP), R1
+	MOVD 8(RSP), R12
+	CMP  $0x01, R0
+	BLS  sequenceDecs_decodeSync_safe_amd64_adjust_offsetB_1_or_0
+	ADD  $144, R1, R15
+	VLD1 (R15), [V0.B16]
+	MOVD R12, 144(R1)
+	ADD  $152, R1, R15
+	VST1 [V0.B16], (R15)
+	JMP  sequenceDecs_decodeSync_safe_amd64_after_adjust
+
+sequenceDecs_decodeSync_safe_amd64_adjust_offsetB_1_or_0:
+	MOVD 24(RSP), R16
+	CMP  $0x00000000, R16
+	BNE  sequenceDecs_decodeSync_safe_amd64_adjust_offset_maybezero
+	ADD  $1, R12, R12
+	JMP  sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero
+
+sequenceDecs_decodeSync_safe_amd64_adjust_offset_maybezero:
+	TST  R12, R12
+	BNE  sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero
+	MOVD 144(R1), R12
+	JMP  sequenceDecs_decodeSync_safe_amd64_after_adjust
+
+sequenceDecs_decodeSync_safe_amd64_adjust_offset_nonzero:
+	MOVD R12, R0
+	MOVD $0, R13
+	MOVD $-1, R14
+	CMP  $0x03, R12
+	CSEL EQ, R13, R0, R0
+	CSEL EQ, R14, R13, R13
+	ADD  R0<<3, R1, R15
+	MOVD 144(R15), R16
+	ADDS R16, R13, R13
+	BNE  sequenceDecs_decodeSync_safe_amd64_adjust_temp_valid
+	MOVD $0x00000001, R13
+
+sequenceDecs_decodeSync_safe_amd64_adjust_temp_valid:
+	CMP  $0x01, R12
+	BEQ  sequenceDecs_decodeSync_safe_amd64_adjust_skip
+	MOVD 152(R1), R0
+	MOVD R0, 160(R1)
+
+sequenceDecs_decodeSync_safe_amd64_adjust_skip:
+	MOVD 144(R1), R0
+	MOVD R0, 152(R1)
+	MOVD R13, 144(R1)
+	MOVD R13, R12
+
+sequenceDecs_decodeSync_safe_amd64_after_adjust:
+	MOVD R12, 8(RSP)
+
+	// Check values
+	MOVD 16(RSP), R0
+	MOVD 24(RSP), R1
+	ADD  R1, R0, R13
+	MOVD s+0(FP), R14
+	MOVD 256(R14), R16
+	ADD  R13, R16, R16
+	MOVD R16, 256(R14)
+	MOVD ctx+16(FP), R13
+	MOVD 104(R13), R16
+	SUBS R1, R16, R16
+	MOVD R16, 104(R13)
+	BMI  error_not_enough_literals
+	CMP  $0x00020002, R0
+	BHI  sequenceDecs_decodeSync_safe_amd64_error_match_len_too_big
+	TST  R12, R12
+	BNE  sequenceDecs_decodeSync_safe_amd64_match_len_ofs_ok
+	TST  R0, R0
+	BNE  sequenceDecs_decodeSync_safe_amd64_error_match_len_ofs_mismatch
+
+sequenceDecs_decodeSync_safe_amd64_match_len_ofs_ok:
+	MOVD 24(RSP), R0
+	MOVD 8(RSP), R1
+	MOVD 16(RSP), R12
+
+	// Check if we have enough space in s.out
+	ADD  R12, R0, R13
+	ADD  R9, R13, R13
+	MOVD 32(RSP), R16
+	CMP  R16, R13
+	BHI  error_not_enough_space
+
+	// Copy literals
+	TST  R0, R0
+	BEQ  check_offset
+	MOVD R0, R13
+	SUBS $0x10, R13, R13
+	BLO  copy_1_small
+
+copy_1_loop:
+	VLD1 (R10), [V0.B16]
+	VST1 [V0.B16], (R9)
+	ADD  $0x10, R10, R10
+	ADD  $0x10, R9, R9
+	SUBS $0x10, R13, R13
+	BHS  copy_1_loop
+	ADD  R13, R10, R10
+	ADD  $16, R10, R10
+	ADD  R13, R9, R9
+	ADD  $16, R9, R9
+	ADD  $-16, R10, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R9, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_1_end
+
+copy_1_small:
+	CMP $0x03, R0
+	BEQ copy_1_move_3
+	BLO copy_1_move_1or2
+	CMP $0x08, R0
+	BLO copy_1_move_4through7
+	JMP copy_1_move_8through16
+
+copy_1_move_1or2:
+	MOVB (R10), R13
+	ADD  R0, R10, R15
+	MOVB -1(R15), R14
+	MOVB R13, (R9)
+	ADD  R0, R9, R15
+	MOVB R14, -1(R15)
+	ADD  R0, R10, R10
+	ADD  R0, R9, R9
+	JMP  copy_1_end
+
+copy_1_move_3:
+	MOVH (R10), R13
+	MOVB 2(R10), R14
+	MOVH R13, (R9)
+	MOVB R14, 2(R9)
+	ADD  R0, R10, R10
+	ADD  R0, R9, R9
+	JMP  copy_1_end
+
+copy_1_move_4through7:
+	MOVWU (R10), R13
+	ADD   R0, R10, R15
+	MOVWU -4(R15), R14
+	MOVW  R13, (R9)
+	ADD   R0, R9, R15
+	MOVW  R14, -4(R15)
+	ADD   R0, R10, R10
+	ADD   R0, R9, R9
+	JMP   copy_1_end
+
+copy_1_move_8through16:
+	MOVD (R10), R13
+	ADD  R0, R10, R15
+	MOVD -8(R15), R14
+	MOVD R13, (R9)
+	ADD  R0, R9, R15
+	MOVD R14, -8(R15)
+	ADD  R0, R10, R10
+	ADD  R0, R9, R9
+
+copy_1_end:
+	ADD R0, R11, R11
+
+	// Malformed input if seq.mo > t+len(hist) || seq.mo > s.windowSize)
+check_offset:
+	MOVD R11, R0
+	MOVD 40(RSP), R16
+	ADD  R16, R0, R0
+	CMP  R0, R1
+	BGT  error_match_off_too_big
+	MOVD 56(RSP), R16
+	CMP  R16, R1
+	BGT  error_match_off_too_big
+
+	// Copy match from history
+	MOVD R1, R0
+	SUBS R11, R0, R0
+	BLS  copy_match
+	MOVD 48(RSP), R13
+	SUB  R0, R13, R13
+	CMP  R0, R12
+	BGT  copy_all_from_history
+	MOVD R12, R0
+	SUBS $0x10, R0, R0
+	BLO  copy_4_small
+
+copy_4_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R9)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R9, R9
+	SUBS $0x10, R0, R0
+	BHS  copy_4_loop
+	ADD  R0, R13, R13
+	ADD  $16, R13, R13
+	ADD  R0, R9, R9
+	ADD  $16, R9, R9
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R9, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_4_end
+
+copy_4_small:
+	CMP $0x03, R12
+	BEQ copy_4_move_3
+	CMP $0x08, R12
+	BLO copy_4_move_4through7
+	JMP copy_4_move_8through16
+
+copy_4_move_3:
+	MOVH (R13), R0
+	MOVB 2(R13), R1
+	MOVH R0, (R9)
+	MOVB R1, 2(R9)
+	ADD  R12, R13, R13
+	ADD  R12, R9, R9
+	JMP  copy_4_end
+
+copy_4_move_4through7:
+	MOVWU (R13), R0
+	ADD   R12, R13, R15
+	MOVWU -4(R15), R1
+	MOVW  R0, (R9)
+	ADD   R12, R9, R15
+	MOVW  R1, -4(R15)
+	ADD   R12, R13, R13
+	ADD   R12, R9, R9
+	JMP   copy_4_end
+
+copy_4_move_8through16:
+	MOVD (R13), R0
+	ADD  R12, R13, R15
+	MOVD -8(R15), R1
+	MOVD R0, (R9)
+	ADD  R12, R9, R15
+	MOVD R1, -8(R15)
+	ADD  R12, R13, R13
+	ADD  R12, R9, R9
+
+copy_4_end:
+	ADD R12, R11, R11
+	JMP handle_loop
+	JMP loop_finished
+
+copy_all_from_history:
+	MOVD R0, R14
+	SUBS $0x10, R14, R14
+	BLO  copy_5_small
+
+copy_5_loop:
+	VLD1 (R13), [V0.B16]
+	VST1 [V0.B16], (R9)
+	ADD  $0x10, R13, R13
+	ADD  $0x10, R9, R9
+	SUBS $0x10, R14, R14
+	BHS  copy_5_loop
+	ADD  R14, R13, R13
+	ADD  $16, R13, R13
+	ADD  R14, R9, R9
+	ADD  $16, R9, R9
+	ADD  $-16, R13, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R9, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_5_end
+
+copy_5_small:
+	CMP $0x03, R0
+	BEQ copy_5_move_3
+	BLO copy_5_move_1or2
+	CMP $0x08, R0
+	BLO copy_5_move_4through7
+	JMP copy_5_move_8through16
+
+copy_5_move_1or2:
+	MOVB (R13), R14
+	ADD  R0, R13, R15
+	MOVB -1(R15), R4
+	MOVB R14, (R9)
+	ADD  R0, R9, R15
+	MOVB R4, -1(R15)
+	ADD  R0, R13, R13
+	ADD  R0, R9, R9
+	JMP  copy_5_end
+
+copy_5_move_3:
+	MOVH (R13), R14
+	MOVB 2(R13), R4
+	MOVH R14, (R9)
+	MOVB R4, 2(R9)
+	ADD  R0, R13, R13
+	ADD  R0, R9, R9
+	JMP  copy_5_end
+
+copy_5_move_4through7:
+	MOVWU (R13), R14
+	ADD   R0, R13, R15
+	MOVWU -4(R15), R4
+	MOVW  R14, (R9)
+	ADD   R0, R9, R15
+	MOVW  R4, -4(R15)
+	ADD   R0, R13, R13
+	ADD   R0, R9, R9
+	JMP   copy_5_end
+
+copy_5_move_8through16:
+	MOVD (R13), R14
+	ADD  R0, R13, R15
+	MOVD -8(R15), R4
+	MOVD R14, (R9)
+	ADD  R0, R9, R15
+	MOVD R4, -8(R15)
+	ADD  R0, R13, R13
+	ADD  R0, R9, R9
+
+copy_5_end:
+	ADD R0, R11, R11
+	SUB R0, R12, R12
+
+	// Copy match from the current buffer
+copy_match:
+	MOVD R9, R0
+	SUB  R1, R0, R0
+
+	// ml <= mo
+	CMP R1, R12
+	BHI copy_overlapping_match
+
+	// Copy non-overlapping match
+	ADD  R12, R11, R11
+	MOVD R12, R1
+	SUBS $0x10, R1, R1
+	BLO  copy_2_small
+
+copy_2_loop:
+	VLD1 (R0), [V0.B16]
+	VST1 [V0.B16], (R9)
+	ADD  $0x10, R0, R0
+	ADD  $0x10, R9, R9
+	SUBS $0x10, R1, R1
+	BHS  copy_2_loop
+	ADD  R1, R0, R0
+	ADD  $16, R0, R0
+	ADD  R1, R9, R9
+	ADD  $16, R9, R9
+	ADD  $-16, R0, R15
+	VLD1 (R15), [V0.B16]
+	ADD  $-16, R9, R15
+	VST1 [V0.B16], (R15)
+	JMP  copy_2_end
+
+copy_2_small:
+	CMP $0x03, R12
+	BEQ copy_2_move_3
+	BLO copy_2_move_1or2
+	CMP $0x08, R12
+	BLO copy_2_move_4through7
+	JMP copy_2_move_8through16
+
+copy_2_move_1or2:
+	MOVB (R0), R1
+	ADD  R12, R0, R15
+	MOVB -1(R15), R13
+	MOVB R1, (R9)
+	ADD  R12, R9, R15
+	MOVB R13, -1(R15)
+	ADD  R12, R0, R0
+	ADD  R12, R9, R9
+	JMP  copy_2_end
+
+copy_2_move_3:
+	MOVH (R0), R1
+	MOVB 2(R0), R13
+	MOVH R1, (R9)
+	MOVB R13, 2(R9)
+	ADD  R12, R0, R0
+	ADD  R12, R9, R9
+	JMP  copy_2_end
+
+copy_2_move_4through7:
+	MOVWU (R0), R1
+	ADD   R12, R0, R15
+	MOVWU -4(R15), R13
+	MOVW  R1, (R9)
+	ADD   R12, R9, R15
+	MOVW  R13, -4(R15)
+	ADD   R12, R0, R0
+	ADD   R12, R9, R9
+	JMP   copy_2_end
+
+copy_2_move_8through16:
+	MOVD (R0), R1
+	ADD  R12, R0, R15
+	MOVD -8(R15), R13
+	MOVD R1, (R9)
+	ADD  R12, R9, R15
+	MOVD R13, -8(R15)
+	ADD  R12, R0, R0
+	ADD  R12, R9, R9
+
+copy_2_end:
+	JMP handle_loop
+
+	// Copy overlapping match
+copy_overlapping_match:
+	ADD R12, R11, R11
+
+copy_slow_3:
+	MOVB (R0), R1
+	MOVB R1, (R9)
+	ADD  $1, R0, R0
+	ADD  $1, R9, R9
+	SUBS $1, R12, R12
+	BNE  copy_slow_3
+
+handle_loop:
+	MOVD ctx+16(FP), R0
+	MOVD 96(R0), R16
+	SUBS $1, R16, R16
+	MOVD R16, 96(R0)
+	BPL  sequenceDecs_decodeSync_safe_amd64_main_loop
+
+loop_finished:
+	MOVD br+8(FP), R0
+	MOVD R2, 24(R0)
+	MOVB R3, 40(R0)
+	MOVD R5, 32(R0)
+
+	// Update the context
+	MOVD ctx+16(FP), R0
+	MOVD R11, 136(R0)
+	MOVD 144(R0), R1
+	SUB  R1, R10, R10
+	MOVD R10, 168(R0)
+
+	// Return success
+	MOVD $0x00000000, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match length error
+sequenceDecs_decodeSync_safe_amd64_error_match_len_ofs_mismatch:
+	MOVD 16(RSP), R0
+	MOVD ctx+16(FP), R1
+	MOVD R0, 216(R1)
+	MOVD $0x00000001, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match too long error
+sequenceDecs_decodeSync_safe_amd64_error_match_len_too_big:
+	MOVD ctx+16(FP), R0
+	MOVD 16(RSP), R1
+	MOVD R1, 216(R0)
+	MOVD $0x00000002, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with match offset too long error
+error_match_off_too_big:
+	MOVD ctx+16(FP), R0
+	MOVD 8(RSP), R1
+	MOVD R1, 224(R0)
+	MOVD R11, 136(R0)
+	MOVD $0x00000003, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with not enough literals error
+error_not_enough_literals:
+	MOVD ctx+16(FP), R0
+	MOVD 24(RSP), R1
+	MOVD R1, 208(R0)
+	MOVD $0x00000004, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with overread error
+error_overread:
+	MOVD $0x00000006, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+	// Return with not enough output space error
+error_not_enough_space:
+	MOVD ctx+16(FP), R0
+	MOVD 24(RSP), R1
+	MOVD R1, 208(R0)
+	MOVD 16(RSP), R1
+	MOVD R1, 216(R0)
+	MOVD R11, 136(R0)
+	MOVD $0x00000005, R16
+	MOVD R16, ret+24(FP)
+	RET
+
+// skipped sequenceDecs_decodeSync_safe_bmi2 (BMI2 not available on arm64)
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_asm.go b/vendor/github.com/klauspost/compress/zstd/seqdec_asm.go
new file mode 100644
index 0000000000..55405f3914
--- /dev/null
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_asm.go
@@ -0,0 +1,289 @@
+//go:build (amd64 || arm64) && !appengine && !noasm && gc
+
+package zstd
+
+import (
+	"fmt"
+	"io"
+)
+
+// This file holds the parts of the assembly sequence decoder that are identical
+// across architectures: the context structs exchanged with the asm, the error
+// codes, and the decode/decodeSync/executeSimple wrappers. Each architecture
+// supplies the small dispatch helpers (decodeAsm, decodeSyncAsm,
+// executeSimpleAsm) that select the concrete asm routine — amd64 also chooses a
+// BMI2 variant, arm64 has a single implementation.
+
+type decodeSyncAsmContext struct {
+	llTable     []decSymbol
+	mlTable     []decSymbol
+	ofTable     []decSymbol
+	llState     uint64
+	mlState     uint64
+	ofState     uint64
+	iteration   int
+	litRemain   int
+	out         []byte
+	outPosition int
+	literals    []byte
+	litPosition int
+	history     []byte
+	windowSize  int
+	ll          int // set on error (not for all errors, please refer to _generate/gen.go)
+	ml          int // set on error (not for all errors, please refer to _generate/gen.go)
+	mo          int // set on error (not for all errors, please refer to _generate/gen.go)
+}
+
+type decodeAsmContext struct {
+	llTable   []decSymbol
+	mlTable   []decSymbol
+	ofTable   []decSymbol
+	llState   uint64
+	mlState   uint64
+	ofState   uint64
+	iteration int
+	seqs      []seqVals
+	litRemain int
+}
+
+type executeAsmContext struct {
+	seqs        []seqVals
+	seqIndex    int
+	out         []byte
+	history     []byte
+	literals    []byte
+	outPosition int
+	litPosition int
+	windowSize  int
+}
+
+const noError = 0
+
+// error reported when mo == 0 && ml > 0
+const errorMatchLenOfsMismatch = 1
+
+// error reported when ml > maxMatchLen
+const errorMatchLenTooBig = 2
+
+// error reported when mo > available history or mo > s.windowSize
+const errorMatchOffTooBig = 3
+
+// error reported when the sum of literal lengths exeeceds the literal buffer size
+const errorNotEnoughLiterals = 4
+
+// error reported when capacity of `out` is too small
+const errorNotEnoughSpace = 5
+
+// error reported when bits are overread.
+const errorOverread = 6
+
+// decode sequences from the stream with the provided history but without a dictionary.
+func (s *sequenceDecs) decodeSyncSimple(hist []byte) (bool, error) {
+	if len(s.dict) > 0 {
+		return false, nil
+	}
+	if s.maxSyncLen == 0 && cap(s.out)-len(s.out) < maxCompressedBlockSize {
+		return false, nil
+	}
+
+	// FIXME: Using unsafe memory copies leads to rare, random crashes
+	// with fuzz testing. It is therefore disabled for now.
+	const useSafe = true
+
+	br := s.br
+
+	maxBlockSize := min(s.windowSize, maxCompressedBlockSize)
+
+	ctx := decodeSyncAsmContext{
+		llTable:     s.litLengths.fse.dt[:maxTablesize],
+		mlTable:     s.matchLengths.fse.dt[:maxTablesize],
+		ofTable:     s.offsets.fse.dt[:maxTablesize],
+		llState:     uint64(s.litLengths.state.state),
+		mlState:     uint64(s.matchLengths.state.state),
+		ofState:     uint64(s.offsets.state.state),
+		iteration:   s.nSeqs - 1,
+		litRemain:   len(s.literals),
+		out:         s.out,
+		outPosition: len(s.out),
+		literals:    s.literals,
+		windowSize:  s.windowSize,
+		history:     hist,
+	}
+
+	s.seqSize = 0
+	startSize := len(s.out)
+
+	errCode := decodeSyncAsm(s, br, &ctx, useSafe)
+	switch errCode {
+	case noError:
+		break
+
+	case errorMatchLenOfsMismatch:
+		return true, fmt.Errorf("zero matchoff and matchlen (%d) > 0", ctx.ml)
+
+	case errorMatchLenTooBig:
+		return true, fmt.Errorf("match len (%d) bigger than max allowed length", ctx.ml)
+
+	case errorMatchOffTooBig:
+		return true, fmt.Errorf("match offset (%d) bigger than current history (%d)",
+			ctx.mo, ctx.outPosition+len(hist)-startSize)
+
+	case errorNotEnoughLiterals:
+		return true, fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available",
+			ctx.ll, ctx.litRemain+ctx.ll)
+
+	case errorOverread:
+		return true, io.ErrUnexpectedEOF
+
+	case errorNotEnoughSpace:
+		size := ctx.outPosition + ctx.ll + ctx.ml
+		if debugDecoder {
+			println("msl:", s.maxSyncLen, "cap", cap(s.out), "bef:", startSize, "sz:", size-startSize, "mbs:", maxBlockSize, "outsz:", cap(s.out)-startSize)
+		}
+		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+
+	default:
+		return true, fmt.Errorf("sequenceDecs_decode returned erroneous code %d", errCode)
+	}
+
+	s.seqSize += ctx.litRemain
+	if s.seqSize > maxBlockSize {
+		return true, fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+	}
+	err := br.close()
+	if err != nil {
+		printf("Closing sequences: %v, %+v\n", err, *br)
+		return true, err
+	}
+
+	s.literals = s.literals[ctx.litPosition:]
+	t := ctx.outPosition
+	s.out = s.out[:t]
+
+	// Add final literals
+	s.out = append(s.out, s.literals...)
+	if debugDecoder {
+		t += len(s.literals)
+		if t != len(s.out) {
+			panic(fmt.Errorf("length mismatch, want %d, got %d", len(s.out), t))
+		}
+	}
+
+	return true, nil
+}
+
+// decode sequences from the stream without the provided history.
+func (s *sequenceDecs) decode(seqs []seqVals) error {
+	br := s.br
+
+	maxBlockSize := min(s.windowSize, maxCompressedBlockSize)
+
+	ctx := decodeAsmContext{
+		llTable:   s.litLengths.fse.dt[:maxTablesize],
+		mlTable:   s.matchLengths.fse.dt[:maxTablesize],
+		ofTable:   s.offsets.fse.dt[:maxTablesize],
+		llState:   uint64(s.litLengths.state.state),
+		mlState:   uint64(s.matchLengths.state.state),
+		ofState:   uint64(s.offsets.state.state),
+		seqs:      seqs,
+		iteration: len(seqs) - 1,
+		litRemain: len(s.literals),
+	}
+
+	if debugDecoder {
+		println("decode: decoding", len(seqs), "sequences", br.remain(), "bits remain on stream")
+	}
+
+	s.seqSize = 0
+	lte56bits := s.maxBits+s.offsets.fse.actualTableLog+s.matchLengths.fse.actualTableLog+s.litLengths.fse.actualTableLog <= 56
+	errCode := decodeAsm(s, br, &ctx, lte56bits)
+	if errCode != 0 {
+		i := len(seqs) - ctx.iteration - 1
+		switch errCode {
+		case errorMatchLenOfsMismatch:
+			ml := ctx.seqs[i].ml
+			return fmt.Errorf("zero matchoff and matchlen (%d) > 0", ml)
+
+		case errorMatchLenTooBig:
+			ml := ctx.seqs[i].ml
+			return fmt.Errorf("match len (%d) bigger than max allowed length", ml)
+
+		case errorNotEnoughLiterals:
+			ll := ctx.seqs[i].ll
+			return fmt.Errorf("unexpected literal count, want %d bytes, but only %d is available", ll, ctx.litRemain+ll)
+		case errorOverread:
+			return io.ErrUnexpectedEOF
+		}
+
+		return fmt.Errorf("sequenceDecs_decode_amd64 returned erroneous code %d", errCode)
+	}
+
+	if ctx.litRemain < 0 {
+		return fmt.Errorf("literal count is too big: total available %d, total requested %d",
+			len(s.literals), len(s.literals)-ctx.litRemain)
+	}
+
+	s.seqSize += ctx.litRemain
+	if s.seqSize > maxBlockSize {
+		return fmt.Errorf("output bigger than max block size (%d)", maxBlockSize)
+	}
+	if debugDecoder {
+		println("decode: ", br.remain(), "bits remain on stream. code:", errCode)
+	}
+	err := br.close()
+	if err != nil {
+		printf("Closing sequences: %v, %+v\n", err, *br)
+	}
+	return err
+}
+
+// executeSimple handles cases when dictionary is not used.
+func (s *sequenceDecs) executeSimple(seqs []seqVals, hist []byte) error {
+	// Ensure we have enough output size...
+	if len(s.out)+s.seqSize+compressedBlockOverAlloc > cap(s.out) {
+		addBytes := s.seqSize + len(s.out) + compressedBlockOverAlloc
+		s.out = append(s.out, make([]byte, addBytes)...)
+		s.out = s.out[:len(s.out)-addBytes]
+	}
+
+	if debugDecoder {
+		printf("Execute %d seqs with literals: %d into %d bytes\n", len(seqs), len(s.literals), s.seqSize)
+	}
+
+	var t = len(s.out)
+	out := s.out[:t+s.seqSize]
+
+	ctx := executeAsmContext{
+		seqs:        seqs,
+		seqIndex:    0,
+		out:         out,
+		history:     hist,
+		outPosition: t,
+		litPosition: 0,
+		literals:    s.literals,
+		windowSize:  s.windowSize,
+	}
+	// useSafe avoids overwriting the output buffer when the literals slice has
+	// not been allocated with the required over-allocation slack.
+	useSafe := cap(s.literals) < len(s.literals)+compressedBlockOverAlloc
+
+	ok := executeSimpleAsm(&ctx, useSafe)
+	if !ok {
+		return fmt.Errorf("match offset (%d) bigger than current history (%d)",
+			seqs[ctx.seqIndex].mo, ctx.outPosition+len(hist))
+	}
+	s.literals = s.literals[ctx.litPosition:]
+	t = ctx.outPosition
+
+	// Add final literals
+	copy(out[t:], s.literals)
+	if debugDecoder {
+		t += len(s.literals)
+		if t != len(out) {
+			panic(fmt.Errorf("length mismatch, want %d, got %d, ss: %d", len(out), t, s.seqSize))
+		}
+	}
+	s.out = out
+
+	return nil
+}
diff --git a/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go b/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
index 516cd9b070..8a3db6ba22 100644
--- a/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
+++ b/vendor/github.com/klauspost/compress/zstd/seqdec_generic.go
@@ -1,4 +1,4 @@
-//go:build !amd64 || appengine || !gc || noasm
+//go:build (!amd64 && !arm64) || appengine || !gc || noasm
 
 package zstd
 
diff --git a/vendor/github.com/prometheus/client_golang/api/client.go b/vendor/github.com/prometheus/client_golang/api/client.go
index 0e647b6756..66844900d0 100644
--- a/vendor/github.com/prometheus/client_golang/api/client.go
+++ b/vendor/github.com/prometheus/client_golang/api/client.go
@@ -27,13 +27,18 @@ import (
 )
 
 // DefaultRoundTripper is used if no RoundTripper is set in Config.
+// refer https://github.com/golang/go/blob/master/src/net/http/transport.go#L46
 var DefaultRoundTripper http.RoundTripper = &http.Transport{
 	Proxy: http.ProxyFromEnvironment,
 	DialContext: (&net.Dialer{
 		Timeout:   30 * time.Second,
 		KeepAlive: 30 * time.Second,
 	}).DialContext,
-	TLSHandshakeTimeout: 10 * time.Second,
+	ForceAttemptHTTP2:     true,
+	MaxIdleConns:          100,
+	IdleConnTimeout:       90 * time.Second,
+	TLSHandshakeTimeout:   10 * time.Second,
+	ExpectContinueTimeout: 1 * time.Second,
 }
 
 // Config defines configuration parameters for a new client.
@@ -136,21 +141,21 @@ func (c *httpClient) Do(ctx context.Context, req *http.Request) (*http.Response,
 	}
 
 	var body []byte
-	done := make(chan error, 1)
+	done := make(chan struct{})
+	var readErr error
 	go func() {
+		defer close(done)
 		var buf bytes.Buffer
-		_, err := buf.ReadFrom(resp.Body)
+		_, readErr = buf.ReadFrom(resp.Body)
 		body = buf.Bytes()
-		done <- err
 	}()
 
 	select {
 	case <-ctx.Done():
 		resp.Body.Close()
-		<-done
 		return resp, nil, ctx.Err()
-	case err = <-done:
+	case <-done:
 		resp.Body.Close()
-		return resp, body, err
+		return resp, body, readErr
 	}
 }
diff --git a/vendor/github.com/prometheus/client_golang/api/prometheus/v1/api.go b/vendor/github.com/prometheus/client_golang/api/prometheus/v1/api.go
index 8a72f9bfc7..61094cb1ae 100644
--- a/vendor/github.com/prometheus/client_golang/api/prometheus/v1/api.go
+++ b/vendor/github.com/prometheus/client_golang/api/prometheus/v1/api.go
@@ -380,7 +380,9 @@ const (
 	epBuildinfo       = apiPrefix + "/status/buildinfo"
 	epRuntimeinfo     = apiPrefix + "/status/runtimeinfo"
 	epTSDB            = apiPrefix + "/status/tsdb"
+	epTSDBBlocks      = apiPrefix + "/status/tsdb/blocks"
 	epWalReplay       = apiPrefix + "/status/walreplay"
+	epFormatQuery     = apiPrefix + "/format_query"
 )
 
 // AlertState models the state of an alert.
@@ -475,7 +477,7 @@ type API interface {
 	// Flags returns the flag values that Prometheus was launched with.
 	Flags(ctx context.Context) (FlagsResult, error)
 	// LabelNames returns the unique label names present in the block in sorted order by given time range and matchers.
-	LabelNames(ctx context.Context, matches []string, startTime, endTime time.Time, opts ...Option) ([]string, Warnings, error)
+	LabelNames(ctx context.Context, matches []string, startTime, endTime time.Time, opts ...Option) (model.LabelNames, Warnings, error)
 	// LabelValues performs a query for the values of the given label, time range and matchers.
 	LabelValues(ctx context.Context, label string, matches []string, startTime, endTime time.Time, opts ...Option) (model.LabelValues, Warnings, error)
 	// Query performs a query for the given time.
@@ -494,7 +496,7 @@ type API interface {
 	// under the TSDB's data directory and returns the directory as response.
 	Snapshot(ctx context.Context, skipHead bool) (SnapshotResult, error)
 	// Rules returns a list of alerting and recording rules that are currently loaded.
-	Rules(ctx context.Context) (RulesResult, error)
+	Rules(ctx context.Context, matches []string) (RulesResult, error)
 	// Targets returns an overview of the current state of the Prometheus target discovery.
 	Targets(ctx context.Context) (TargetsResult, error)
 	// TargetsMetadata returns metadata about metrics currently scraped by the target.
@@ -503,8 +505,12 @@ type API interface {
 	Metadata(ctx context.Context, metric, limit string) (map[string][]Metadata, error)
 	// TSDB returns the cardinality statistics.
 	TSDB(ctx context.Context, opts ...Option) (TSDBResult, error)
+	// TSDBBlocks returns the list of currently loaded TSDB blocks and their metadata.
+	TSDBBlocks(ctx context.Context) (TSDBBlocksResult, error)
 	// WalReplay returns the current replay status of the wal.
 	WalReplay(ctx context.Context) (WalReplayStatus, error)
+	// FormatQuery formats a PromQL expression in a prettified way.
+	FormatQuery(ctx context.Context, query string) (string, error)
 }
 
 // AlertsResult contains the result from querying the alerts endpoint.
@@ -586,7 +592,7 @@ type RuleGroup struct {
 //	default:
 //		fmt.Printf("unknown rule type %s", v)
 //	}
-type Rules []interface{}
+type Rules []any
 
 // AlertingRule models a alerting rule.
 type AlertingRule struct {
@@ -666,7 +672,7 @@ type Metadata struct {
 // queryResult contains result data for a query.
 type queryResult struct {
 	Type   model.ValueType `json:"resultType"`
-	Result interface{}     `json:"result"`
+	Result any             `json:"result"`
 
 	// The decoded value.
 	v model.Value
@@ -690,6 +696,40 @@ type TSDBHeadStats struct {
 	MaxTime       int `json:"maxTime"`
 }
 
+// TSDBBlocksResult contains the results from querying the tsdb blocks endpoint.
+type TSDBBlocksResult struct {
+	Status string         `json:"status"`
+	Data   TSDBBlocksData `json:"data"`
+}
+
+// TSDBBlocksData contains the metadata for the tsdb blocks.
+type TSDBBlocksData struct {
+	Blocks []TSDBBlocksBlockMetadata `json:"blocks"`
+}
+
+// TSDBBlocksBlockMetadata contains the metadata for a single tsdb block.
+type TSDBBlocksBlockMetadata struct {
+	Ulid       string               `json:"ulid"`
+	MinTime    int64                `json:"minTime"`
+	MaxTime    int64                `json:"maxTime"`
+	Stats      TSDBBlocksStats      `json:"stats"`
+	Compaction TSDBBlocksCompaction `json:"compaction"`
+	Version    int                  `json:"version"`
+}
+
+// TSDBBlocksStats contains block stats for a single tsdb block.
+type TSDBBlocksStats struct {
+	NumSamples int `json:"numSamples"`
+	NumSeries  int `json:"numSeries"`
+	NumChunks  int `json:"numChunks"`
+}
+
+// TSDBBlocksCompaction contains block compaction details for a single block.
+type TSDBBlocksCompaction struct {
+	Level   int      `json:"level"`
+	Sources []string `json:"sources"`
+}
+
 // WalReplayStatus represents the wal replay status.
 type WalReplayStatus struct {
 	Min     int `json:"min"`
@@ -1024,7 +1064,7 @@ func (h *httpAPI) Runtimeinfo(ctx context.Context) (RuntimeinfoResult, error) {
 	return res, err
 }
 
-func (h *httpAPI) LabelNames(ctx context.Context, matches []string, startTime, endTime time.Time, opts ...Option) ([]string, Warnings, error) {
+func (h *httpAPI) LabelNames(ctx context.Context, matches []string, startTime, endTime time.Time, opts ...Option) (model.LabelNames, Warnings, error) {
 	u := h.client.URL(epLabels, nil)
 	q := addOptionalURLParams(u.Query(), opts)
 
@@ -1042,7 +1082,7 @@ func (h *httpAPI) LabelNames(ctx context.Context, matches []string, startTime, e
 	if err != nil {
 		return nil, w, err
 	}
-	var labelNames []string
+	var labelNames model.LabelNames
 	err = json.Unmarshal(body, &labelNames)
 	return labelNames, w, err
 }
@@ -1235,8 +1275,15 @@ func (h *httpAPI) Snapshot(ctx context.Context, skipHead bool) (SnapshotResult,
 	return res, err
 }
 
-func (h *httpAPI) Rules(ctx context.Context) (RulesResult, error) {
+func (h *httpAPI) Rules(ctx context.Context, matches []string) (RulesResult, error) {
 	u := h.client.URL(epRules, nil)
+	q := u.Query()
+
+	for _, m := range matches {
+		q.Add("match[]", m)
+	}
+
+	u.RawQuery = q.Encode()
 
 	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
 	if err != nil {
@@ -1340,6 +1387,24 @@ func (h *httpAPI) TSDB(ctx context.Context, opts ...Option) (TSDBResult, error)
 	return res, err
 }
 
+func (h *httpAPI) TSDBBlocks(ctx context.Context) (TSDBBlocksResult, error) {
+	u := h.client.URL(epTSDBBlocks, nil)
+
+	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+	if err != nil {
+		return TSDBBlocksResult{}, err
+	}
+
+	_, body, _, err := h.client.Do(ctx, req)
+	if err != nil {
+		return TSDBBlocksResult{}, err
+	}
+
+	var res TSDBBlocksResult
+	err = json.Unmarshal(body, &res)
+	return res, err
+}
+
 func (h *httpAPI) WalReplay(ctx context.Context) (WalReplayStatus, error) {
 	u := h.client.URL(epWalReplay, nil)
 
@@ -1380,6 +1445,19 @@ func (h *httpAPI) QueryExemplars(ctx context.Context, query string, startTime, e
 	return res, err
 }
 
+func (h *httpAPI) FormatQuery(ctx context.Context, query string) (string, error) {
+	u := h.client.URL(epFormatQuery, nil)
+	q := u.Query()
+	q.Set("query", query)
+
+	_, body, _, err := h.client.DoGetFallback(ctx, u, q)
+	if err != nil {
+		return "", err
+	}
+
+	return string(body), nil
+}
+
 // Warnings is an array of non critical errors
 type Warnings []string
 
@@ -1467,8 +1545,8 @@ func (h *apiClientImpl) Do(ctx context.Context, req *http.Request) (*http.Respon
 	return resp, []byte(result.Data), result.Warnings, err
 }
 
-// DoGetFallback will attempt to do the request as-is, and on a 405 or 501 it
-// will fallback to a GET request.
+// DoGetFallback will attempt to do the request as-is, and on a 403, 405, or
+// 501 it will fallback to a GET request.
 func (h *apiClientImpl) DoGetFallback(ctx context.Context, u *url.URL, args url.Values) (*http.Response, []byte, Warnings, error) {
 	encodedArgs := args.Encode()
 	req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(encodedArgs))
@@ -1486,7 +1564,7 @@ func (h *apiClientImpl) DoGetFallback(ctx context.Context, u *url.URL, args url.
 	req.Header["Idempotency-Key"] = nil
 
 	resp, body, warnings, err := h.Do(ctx, req)
-	if resp != nil && (resp.StatusCode == http.StatusMethodNotAllowed || resp.StatusCode == http.StatusNotImplemented) {
+	if resp != nil && (resp.StatusCode == http.StatusForbidden || resp.StatusCode == http.StatusMethodNotAllowed || resp.StatusCode == http.StatusNotImplemented) {
 		u.RawQuery = encodedArgs
 		req, err = http.NewRequest(http.MethodGet, u.String(), nil)
 		if err != nil {
diff --git a/vendor/github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil/header/header.go b/vendor/github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil/header/header.go
index 8547c8dfd1..820bf436ab 100644
--- a/vendor/github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil/header/header.go
+++ b/vendor/github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil/header/header.go
@@ -90,7 +90,7 @@ loop:
 			s = skipSpace(s[1:])
 		}
 	}
-	return
+	return specs
 }
 
 func skipSpace(s string) (rest string) {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_go116.go b/vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_go116.go
deleted file mode 100644
index effc57840a..0000000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_go116.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2021 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build !go1.17
-// +build !go1.17
-
-package collectors
-
-import "github.com/prometheus/client_golang/prometheus"
-
-// NewGoCollector returns a collector that exports metrics about the current Go
-// process. This includes memory stats. To collect those, runtime.ReadMemStats
-// is called. This requires to “stop the world”, which usually only happens for
-// garbage collection (GC). Take the following implications into account when
-// deciding whether to use the Go collector:
-//
-// 1. The performance impact of stopping the world is the more relevant the more
-// frequently metrics are collected. However, with Go1.9 or later the
-// stop-the-world time per metrics collection is very short (~25µs) so that the
-// performance impact will only matter in rare cases. However, with older Go
-// versions, the stop-the-world duration depends on the heap size and can be
-// quite significant (~1.7 ms/GiB as per
-// https://go-review.googlesource.com/c/go/+/34937).
-//
-// 2. During an ongoing GC, nothing else can stop the world. Therefore, if the
-// metrics collection happens to coincide with GC, it will only complete after
-// GC has finished. Usually, GC is fast enough to not cause problems. However,
-// with a very large heap, GC might take multiple seconds, which is enough to
-// cause scrape timeouts in common setups. To avoid this problem, the Go
-// collector will use the memstats from a previous collection if
-// runtime.ReadMemStats takes more than 1s. However, if there are no previously
-// collected memstats, or their collection is more than 5m ago, the collection
-// will block until runtime.ReadMemStats succeeds.
-//
-// NOTE: The problem is solved in Go 1.15, see
-// https://github.com/golang/go/issues/19812 for the related Go issue.
-func NewGoCollector() prometheus.Collector {
-	return prometheus.NewGoCollector()
-}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_latest.go b/vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_latest.go
index cc4ef1077e..d29ade654f 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_latest.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/collectors/go_collector_latest.go
@@ -90,13 +90,13 @@ func WithGoCollectorMemStatsMetricsDisabled() func(options *internal.GoCollector
 // GoRuntimeMetricsRule allow enabling and configuring particular group of runtime/metrics.
 // TODO(bwplotka): Consider adding ability to adjust buckets.
 type GoRuntimeMetricsRule struct {
-	// Matcher represents RE2 expression will match the runtime/metrics from https://golang.bg/src/runtime/metrics/description.go
+	// Matcher represents RE2 expression will match the runtime/metrics from https://pkg.go.dev/runtime/metrics
 	// Use `regexp.MustCompile` or `regexp.Compile` to create this field.
 	Matcher *regexp.Regexp
 }
 
 // WithGoCollectorRuntimeMetrics allows enabling and configuring particular group of runtime/metrics.
-// See the list of metrics https://golang.bg/src/runtime/metrics/description.go (pick the Go version you use there!).
+// See the list of metrics https://pkg.go.dev/runtime/metrics (pick the Go version you use there!).
 // You can use this option in repeated manner, which will add new rules. The order of rules is important, the last rule
 // that matches particular metrics is applied.
 func WithGoCollectorRuntimeMetrics(rules ...GoRuntimeMetricsRule) func(options *internal.GoCollectorOptions) {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/counter.go b/vendor/github.com/prometheus/client_golang/prometheus/counter.go
index 4ce84e7a80..7d963d3afb 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/counter.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/counter.go
@@ -85,11 +85,12 @@ type CounterVecOpts struct {
 // Both internal tracking values are added up in the Write method. This has to
 // be taken into account when it comes to precision and overflow behavior.
 func NewCounter(opts CounterOpts) Counter {
-	desc := NewDesc(
+	desc := V2.NewDesc(
 		BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
 		opts.Help,
-		nil,
+		UnconstrainedLabels(nil),
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	)
 	if opts.now == nil {
 		opts.now = time.Now
@@ -205,6 +206,7 @@ func (v2) NewCounterVec(opts CounterVecOpts) *CounterVec {
 		opts.Help,
 		opts.VariableLabels,
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	)
 	if opts.now == nil {
 		opts.now = time.Now
@@ -349,10 +351,11 @@ type CounterFunc interface {
 //
 // Check out the ExampleGaugeFunc examples for the similar GaugeFunc.
 func NewCounterFunc(opts CounterOpts, function func() float64) CounterFunc {
-	return newValueFunc(NewDesc(
+	return newValueFunc(V2.NewDesc(
 		BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
 		opts.Help,
-		nil,
+		UnconstrainedLabels(nil),
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	), CounterValue, function)
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/desc.go b/vendor/github.com/prometheus/client_golang/prometheus/desc.go
index 2331b8b4f3..a3c92e7a4c 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/desc.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/desc.go
@@ -47,6 +47,8 @@ type Desc struct {
 	fqName string
 	// help provides some helpful information about this metric.
 	help string
+	// unit provides the unit of this metric.
+	unit string
 	// constLabelPairs contains precalculated DTO label pairs based on
 	// the constant labels.
 	constLabelPairs []*dto.LabelPair
@@ -66,6 +68,16 @@ type Desc struct {
 	err error
 }
 
+// DescOpt allows setting optional fields for NewDesc.
+type DescOpt func(*Desc)
+
+// WithUnit sets the unit for a Desc.
+func WithUnit(unit string) DescOpt {
+	return func(d *Desc) {
+		d.unit = unit
+	}
+}
+
 // NewDesc allocates and initializes a new Desc. Errors are recorded in the Desc
 // and will be reported on registration time. variableLabels and constLabels can
 // be nil if no such labels should be set. fqName must not be empty.
@@ -89,14 +101,17 @@ func NewDesc(fqName, help string, variableLabels []string, constLabels Labels) *
 //
 // For constLabels, the label values are constant. Therefore, they are fully
 // specified in the Desc. See the Collector example for a usage pattern.
-func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, constLabels Labels) *Desc {
+func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, constLabels Labels, opts ...DescOpt) *Desc {
 	d := &Desc{
 		fqName:         fqName,
 		help:           help,
 		variableLabels: variableLabels.compile(),
 	}
-	//nolint:staticcheck // TODO: Don't use deprecated model.NameValidationScheme.
-	if !model.NameValidationScheme.IsValidMetricName(fqName) {
+
+	for _, opt := range opts {
+		opt(d)
+	}
+	if !model.UTF8Validation.IsValidMetricName(fqName) {
 		d.err = fmt.Errorf("%q is not a valid metric name", fqName)
 		return d
 	}
@@ -150,11 +165,13 @@ func (v2) NewDesc(fqName, help string, variableLabels ConstrainableLabels, const
 	d.id = xxh.Sum64()
 	// Sort labelNames so that order doesn't matter for the hash.
 	sort.Strings(labelNames)
-	// Now hash together (in this order) the help string and the sorted
+	// Now hash together (in this order) the help string, the unit string and the sorted
 	// label names.
 	xxh.Reset()
 	xxh.WriteString(help)
 	xxh.Write(separatorByteSlice)
+	xxh.WriteString(d.unit)
+	xxh.Write(separatorByteSlice)
 	for _, labelName := range labelNames {
 		xxh.WriteString(labelName)
 		xxh.Write(separatorByteSlice)
@@ -182,6 +199,15 @@ func NewInvalidDesc(err error) *Desc {
 	}
 }
 
+// Err returns an error that occurred during construction, if any.
+//
+// Calling this method is optional. It can be used to detect construction
+// errors early, before invoking other methods on the Desc. If an error is
+// present, later operations may not behave as expected.
+func (d *Desc) Err() error {
+	return d.err
+}
+
 func (d *Desc) String() string {
 	lpStrings := make([]string, 0, len(d.constLabelPairs))
 	for _, lp := range d.constLabelPairs {
@@ -202,9 +228,10 @@ func (d *Desc) String() string {
 		}
 	}
 	return fmt.Sprintf(
-		"Desc{fqName: %q, help: %q, constLabels: {%s}, variableLabels: {%s}}",
+		"Desc{fqName: %q, help: %q, unit: %q, constLabels: {%s}, variableLabels: {%s}}",
 		d.fqName,
 		d.help,
+		d.unit,
 		strings.Join(lpStrings, ","),
 		strings.Join(vlStrings, ","),
 	)
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go b/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
index de5a856293..327746f433 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/expvar_collector.go
@@ -47,14 +47,14 @@ func (e *expvarCollector) Collect(ch chan<- Metric) {
 		if expVar == nil {
 			continue
 		}
-		var v interface{}
+		var v any
 		labels := make([]string, len(desc.variableLabels.names))
 		if err := json.Unmarshal([]byte(expVar.String()), &v); err != nil {
 			ch <- NewInvalidMetric(desc, err)
 			continue
 		}
-		var processValue func(v interface{}, i int)
-		processValue = func(v interface{}, i int) {
+		var processValue func(v any, i int)
+		processValue = func(v any, i int) {
 			if i >= len(labels) {
 				copiedLabels := append(make([]string, 0, len(labels)), labels...)
 				switch v := v.(type) {
@@ -72,7 +72,7 @@ func (e *expvarCollector) Collect(ch chan<- Metric) {
 				ch <- m
 				return
 			}
-			vm, ok := v.(map[string]interface{})
+			vm, ok := v.(map[string]any)
 			if !ok {
 				return
 			}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/gauge.go b/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
index dd2eac9406..41e54bf270 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/gauge.go
@@ -76,11 +76,12 @@ type GaugeVecOpts struct {
 // scenarios for Gauges and Counters, where the former tends to be Set-heavy and
 // the latter Inc-heavy.
 func NewGauge(opts GaugeOpts) Gauge {
-	desc := NewDesc(
+	desc := V2.NewDesc(
 		BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
 		opts.Help,
-		nil,
+		UnconstrainedLabels(nil),
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	)
 	result := &gauge{desc: desc, labelPairs: desc.constLabelPairs}
 	result.init(result) // Init self-collection.
@@ -163,6 +164,7 @@ func (v2) NewGaugeVec(opts GaugeVecOpts) *GaugeVec {
 		opts.Help,
 		opts.VariableLabels,
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	)
 	return &GaugeVec{
 		MetricVec: NewMetricVec(desc, func(lvs ...string) Metric {
@@ -302,10 +304,11 @@ type GaugeFunc interface {
 // value of 1. Example:
 // https://github.com/prometheus/common/blob/8558a5b7db3c84fa38b4766966059a7bd5bfa2ee/version/info.go#L36-L56
 func NewGaugeFunc(opts GaugeOpts, function func() float64) GaugeFunc {
-	return newValueFunc(NewDesc(
+	return newValueFunc(V2.NewDesc(
 		BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
 		opts.Help,
-		nil,
+		UnconstrainedLabels(nil),
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	), GaugeValue, function)
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/go_collector_go116.go b/vendor/github.com/prometheus/client_golang/prometheus/go_collector_go116.go
deleted file mode 100644
index 897a6e906b..0000000000
--- a/vendor/github.com/prometheus/client_golang/prometheus/go_collector_go116.go
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2021 The Prometheus Authors
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//go:build !go1.17
-// +build !go1.17
-
-package prometheus
-
-import (
-	"runtime"
-	"sync"
-	"time"
-)
-
-type goCollector struct {
-	base baseGoCollector
-
-	// ms... are memstats related.
-	msLast          *runtime.MemStats // Previously collected memstats.
-	msLastTimestamp time.Time
-	msMtx           sync.Mutex // Protects msLast and msLastTimestamp.
-	msMetrics       memStatsMetrics
-	msRead          func(*runtime.MemStats) // For mocking in tests.
-	msMaxWait       time.Duration           // Wait time for fresh memstats.
-	msMaxAge        time.Duration           // Maximum allowed age of old memstats.
-}
-
-// NewGoCollector is the obsolete version of collectors.NewGoCollector.
-// See there for documentation.
-//
-// Deprecated: Use collectors.NewGoCollector instead.
-func NewGoCollector() Collector {
-	msMetrics := goRuntimeMemStats()
-	msMetrics = append(msMetrics, struct {
-		desc    *Desc
-		eval    func(*runtime.MemStats) float64
-		valType ValueType
-	}{
-		// This metric is omitted in Go1.17+, see https://github.com/prometheus/client_golang/issues/842#issuecomment-861812034
-		desc: NewDesc(
-			memstatNamespace("gc_cpu_fraction"),
-			"The fraction of this program's available CPU time used by the GC since the program started.",
-			nil, nil,
-		),
-		eval:    func(ms *runtime.MemStats) float64 { return ms.GCCPUFraction },
-		valType: GaugeValue,
-	})
-	return &goCollector{
-		base:      newBaseGoCollector(),
-		msLast:    &runtime.MemStats{},
-		msRead:    runtime.ReadMemStats,
-		msMaxWait: time.Second,
-		msMaxAge:  5 * time.Minute,
-		msMetrics: msMetrics,
-	}
-}
-
-// Describe returns all descriptions of the collector.
-func (c *goCollector) Describe(ch chan<- *Desc) {
-	c.base.Describe(ch)
-	for _, i := range c.msMetrics {
-		ch <- i.desc
-	}
-}
-
-// Collect returns the current state of all metrics of the collector.
-func (c *goCollector) Collect(ch chan<- Metric) {
-	var (
-		ms   = &runtime.MemStats{}
-		done = make(chan struct{})
-	)
-	// Start reading memstats first as it might take a while.
-	go func() {
-		c.msRead(ms)
-		c.msMtx.Lock()
-		c.msLast = ms
-		c.msLastTimestamp = time.Now()
-		c.msMtx.Unlock()
-		close(done)
-	}()
-
-	// Collect base non-memory metrics.
-	c.base.Collect(ch)
-
-	timer := time.NewTimer(c.msMaxWait)
-	select {
-	case <-done: // Our own ReadMemStats succeeded in time. Use it.
-		timer.Stop() // Important for high collection frequencies to not pile up timers.
-		c.msCollect(ch, ms)
-		return
-	case <-timer.C: // Time out, use last memstats if possible. Continue below.
-	}
-	c.msMtx.Lock()
-	if time.Since(c.msLastTimestamp) < c.msMaxAge {
-		// Last memstats are recent enough. Collect from them under the lock.
-		c.msCollect(ch, c.msLast)
-		c.msMtx.Unlock()
-		return
-	}
-	// If we are here, the last memstats are too old or don't exist. We have
-	// to wait until our own ReadMemStats finally completes. For that to
-	// happen, we have to release the lock.
-	c.msMtx.Unlock()
-	<-done
-	c.msCollect(ch, ms)
-}
-
-func (c *goCollector) msCollect(ch chan<- Metric, ms *runtime.MemStats) {
-	for _, i := range c.msMetrics {
-		ch <- MustNewConstMetric(i.desc, i.valType, i.eval(ms))
-	}
-}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/go_collector_latest.go b/vendor/github.com/prometheus/client_golang/prometheus/go_collector_latest.go
index 6b8684731c..1db1c4be09 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/go_collector_latest.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/go_collector_latest.go
@@ -98,7 +98,7 @@ type goCollector struct {
 	// snapshot is always produced by Collect.
 	mu sync.Mutex
 
-	// Contains all samples that has to retrieved from runtime/metrics (not all of them will be exposed).
+	// Contains all samples that have to be retrieved from runtime/metrics (not all of them will be exposed).
 	sampleBuf []metrics.Sample
 	// sampleMap allows lookup for MemStats metrics and runtime/metrics histograms for exact sums.
 	sampleMap map[string]*metrics.Sample
@@ -210,16 +210,26 @@ func NewGoCollector(opts ...func(o *internal.GoCollectorOptions)) Collector {
 		sampleBuf = append(sampleBuf, metrics.Sample{Name: d.Name})
 		sampleMap[d.Name] = &sampleBuf[len(sampleBuf)-1]
 
+		// Extract unit from the runtime/metrics name (e.g., "/gc/heap/allocs:bytes" -> "bytes")
+		// and sanitize to match Prometheus naming conventions (e.g., "cpu-seconds" -> "cpu_seconds")
+		var unit string
+		if idx := strings.IndexRune(d.Name, ':'); idx >= 0 {
+			unit = d.Name[idx+1:]
+			unit = strings.ReplaceAll(unit, "-", "_")
+			unit = strings.ReplaceAll(unit, "*", "_")
+			unit = strings.ReplaceAll(unit, "/", "_per_")
+		}
+
 		var m collectorMetric
 		if d.Kind == metrics.KindFloat64Histogram {
 			_, hasSum := opt.RuntimeMetricSumForHist[d.Name]
-			unit := d.Name[strings.IndexRune(d.Name, ':')+1:]
 			m = newBatchHistogram(
-				NewDesc(
+				V2.NewDesc(
 					BuildFQName(namespace, subsystem, name),
 					help,
+					UnconstrainedLabels(nil),
 					nil,
-					nil,
+					WithUnit(unit),
 				),
 				internal.RuntimeMetricsBucketsForUnit(bucketsMap[d.Name], unit),
 				hasSum,
@@ -230,6 +240,7 @@ func NewGoCollector(opts ...func(o *internal.GoCollectorOptions)) Collector {
 				Subsystem: subsystem,
 				Name:      name,
 				Help:      help,
+				Unit:      unit,
 			},
 			)
 		} else {
@@ -238,6 +249,7 @@ func NewGoCollector(opts ...func(o *internal.GoCollectorOptions)) Collector {
 				Subsystem: subsystem,
 				Name:      name,
 				Help:      help,
+				Unit:      unit,
 			})
 		}
 		metricSet = append(metricSet, m)
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
index c453b754a7..88bae3b32c 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/histogram.go
@@ -378,6 +378,9 @@ type HistogramOpts struct {
 	// string.
 	Help string
 
+	// Unit provides the unit of this Histogram.
+	Unit string
+
 	// ConstLabels are used to attach fixed labels to this metric. Metrics
 	// with the same fully-qualified name must have the same label names in
 	// their ConstLabels.
@@ -522,11 +525,12 @@ type HistogramVecOpts struct {
 // for each bucket.
 func NewHistogram(opts HistogramOpts) Histogram {
 	return newHistogram(
-		NewDesc(
+		V2.NewDesc(
 			BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
 			opts.Help,
-			nil,
+			UnconstrainedLabels(nil),
 			opts.ConstLabels,
+			WithUnit(opts.Unit),
 		),
 		opts,
 	)
@@ -966,7 +970,7 @@ func (h *histogram) maybeReset(
 	// We are using the possibly mocked h.now() rather than
 	// time.Since(h.lastResetTime) to enable testing.
 	if h.nativeHistogramMinResetDuration == 0 || // No reset configured.
-		h.resetScheduled || // Do not interefere if a reset is already scheduled.
+		h.resetScheduled || // Do not interfere if a reset is already scheduled.
 		h.now().Sub(h.lastResetTime) < h.nativeHistogramMinResetDuration {
 		return false
 	}
@@ -1053,8 +1057,8 @@ func (h *histogram) maybeWidenZeroBucket(hot, cold *histogramCounts) bool {
 	atomic.StoreUint64(&cold.nativeHistogramZeroThresholdBits, math.Float64bits(newZeroThreshold))
 	// ...and then merge the newly deleted buckets into the wider zero
 	// bucket.
-	mergeAndDeleteOrAddAndReset := func(hotBuckets, coldBuckets *sync.Map) func(k, v interface{}) bool {
-		return func(k, v interface{}) bool {
+	mergeAndDeleteOrAddAndReset := func(hotBuckets, coldBuckets *sync.Map) func(k, v any) bool {
+		return func(k, v any) bool {
 			key := k.(int)
 			bucket := v.(*int64)
 			if key == smallestKey {
@@ -1107,8 +1111,8 @@ func (h *histogram) doubleBucketWidth(hot, cold *histogramCounts) {
 	// ...adjust the schema in the cold counts, too...
 	atomic.StoreInt32(&cold.nativeHistogramSchema, coldSchema)
 	// ...and then merge the cold buckets into the wider hot buckets.
-	merge := func(hotBuckets *sync.Map) func(k, v interface{}) bool {
-		return func(k, v interface{}) bool {
+	merge := func(hotBuckets *sync.Map) func(k, v any) bool {
+		return func(k, v any) bool {
 			key := k.(int)
 			bucket := v.(*int64)
 			// Adjust key to match the bucket to merge into.
@@ -1190,6 +1194,7 @@ func (v2) NewHistogramVec(opts HistogramVecOpts) *HistogramVec {
 		opts.Help,
 		opts.VariableLabels,
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	)
 	return &HistogramVec{
 		MetricVec: NewMetricVec(desc, func(lvs ...string) Metric {
@@ -1476,7 +1481,7 @@ func pickSchema(bucketFactor float64) int32 {
 
 func makeBuckets(buckets *sync.Map) ([]*dto.BucketSpan, []int64) {
 	var ii []int
-	buckets.Range(func(k, v interface{}) bool {
+	buckets.Range(func(k, v any) bool {
 		ii = append(ii, k.(int))
 		return true
 	})
@@ -1553,8 +1558,8 @@ func addToBucket(buckets *sync.Map, key int, increment int64) bool {
 // according to the buckets ranged through. It then resets all buckets ranged
 // through to 0 (but leaves them in place so that they don't need to get
 // recreated on the next scrape).
-func addAndReset(hotBuckets *sync.Map, bucketNumber *uint32) func(k, v interface{}) bool {
-	return func(k, v interface{}) bool {
+func addAndReset(hotBuckets *sync.Map, bucketNumber *uint32) func(k, v any) bool {
+	return func(k, v any) bool {
 		bucket := v.(*int64)
 		if addToBucket(hotBuckets, k.(int), atomic.LoadInt64(bucket)) {
 			atomic.AddUint32(bucketNumber, 1)
@@ -1565,7 +1570,7 @@ func addAndReset(hotBuckets *sync.Map, bucketNumber *uint32) func(k, v interface
 }
 
 func deleteSyncMap(m *sync.Map) {
-	m.Range(func(k, v interface{}) bool {
+	m.Range(func(k, v any) bool {
 		m.Delete(k)
 		return true
 	})
@@ -1573,7 +1578,7 @@ func deleteSyncMap(m *sync.Map) {
 
 func findSmallestKey(m *sync.Map) int {
 	result := math.MaxInt32
-	m.Range(func(k, v interface{}) bool {
+	m.Range(func(k, v any) bool {
 		key := k.(int)
 		if key < result {
 			result = key
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/internal/difflib.go b/vendor/github.com/prometheus/client_golang/prometheus/internal/difflib.go
index 7bac0da33d..2db270f216 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/internal/difflib.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/internal/difflib.go
@@ -78,7 +78,7 @@ type OpCode struct {
 // notion, pairing up elements that appear uniquely in each sequence.
 // That, and the method here, appear to yield more intuitive difference
 // reports than does diff.  This method appears to be the least vulnerable
-// to synching up on blocks of "junk lines", though (like blank lines in
+// to syncing up on blocks of "junk lines", though (like blank lines in
 // ordinary text files, or maybe "<P>" lines in HTML files).  That may be
 // because this is the only method of the 3 that has a *concept* of
 // "junk" <wink>.
@@ -567,7 +567,7 @@ type UnifiedDiff struct {
 func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error {
 	buf := bufio.NewWriter(writer)
 	defer buf.Flush()
-	wf := func(format string, args ...interface{}) error {
+	wf := func(format string, args ...any) error {
 		_, err := fmt.Fprintf(buf, format, args...)
 		return err
 	}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/labels.go b/vendor/github.com/prometheus/client_golang/prometheus/labels.go
index 5fe8d3b4d2..a0285489a0 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/labels.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/labels.go
@@ -184,6 +184,5 @@ func validateLabelValues(vals []string, expectedNumberOfValues int) error {
 }
 
 func checkLabelName(l string) bool {
-	//nolint:staticcheck // TODO: Don't use deprecated model.NameValidationScheme.
-	return model.NameValidationScheme.IsValidLabelName(l) && !strings.HasPrefix(l, reservedLabelPrefix)
+	return model.UTF8Validation.IsValidLabelName(l) && !strings.HasPrefix(l, reservedLabelPrefix)
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/metric.go b/vendor/github.com/prometheus/client_golang/prometheus/metric.go
index 76e59f1288..c5cb90adf8 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/metric.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/metric.go
@@ -81,6 +81,9 @@ type Opts struct {
 	// string.
 	Help string
 
+	// Unit provides the unit of this metric as per https://prometheus.io/docs/specs/om
+	Unit string
+
 	// ConstLabels are used to attach fixed labels to this metric. Metrics
 	// with the same fully-qualified name must have the same label names in
 	// their ConstLabels.
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go
index b32c95fa3f..2b16298f40 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_darwin.go
@@ -72,7 +72,13 @@ func getOpenFileCount() (float64, error) {
 }
 
 func (c *processCollector) processCollect(ch chan<- Metric) {
-	if procs, err := unix.SysctlKinfoProcSlice("kern.proc.pid", os.Getpid()); err == nil {
+	pid, err := c.pidFn()
+	if err != nil {
+		c.reportError(ch, nil, err)
+		return
+	}
+
+	if procs, err := unix.SysctlKinfoProcSlice("kern.proc.pid", pid); err == nil {
 		if len(procs) == 1 {
 			startTime := float64(procs[0].Proc.P_starttime.Nano() / 1e9)
 			ch <- MustNewConstMetric(c.startTime, GaugeValue, startTime)
@@ -84,6 +90,11 @@ func (c *processCollector) processCollect(ch chan<- Metric) {
 		c.reportError(ch, c.startTime, err)
 	}
 
+	if pid != os.Getpid() {
+		c.reportError(ch, nil, fmt.Errorf("collecting metrics for pid %d is not supported on darwin: process metrics collection is limited to the current process (pid %d)", pid, os.Getpid()))
+		return
+	}
+
 	// The proc structure returned by kern.proc.pid above has an Rusage member,
 	// but it is not filled in, so it needs to be fetched by getrusage(2).  For
 	// that call, the UTime, STime, and Maxrss members are filled out, but not
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go
index fa474289ef..c08dd05f03 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/process_collector_windows.go
@@ -30,6 +30,10 @@ var (
 
 	procGetProcessMemoryInfo  = modpsapi.NewProc("GetProcessMemoryInfo")
 	procGetProcessHandleCount = modkernel32.NewProc("GetProcessHandleCount")
+
+	openProcess     = windows.OpenProcess
+	closeHandle     = windows.CloseHandle
+	getProcessTimes = windows.GetProcessTimes
 )
 
 type processMemoryCounters struct {
@@ -79,10 +83,21 @@ func getProcessHandleCount(handle windows.Handle) (uint32, error) {
 }
 
 func (c *processCollector) processCollect(ch chan<- Metric) {
-	h := windows.CurrentProcess()
+	pid, err := c.pidFn()
+	if err != nil {
+		c.reportError(ch, nil, err)
+		return
+	}
+
+	h, err := openProcess(windows.PROCESS_QUERY_INFORMATION|windows.PROCESS_VM_READ, false, uint32(pid))
+	if err != nil {
+		c.reportError(ch, nil, err)
+		return
+	}
+	defer closeHandle(h)
 
 	var startTime, exitTime, kernelTime, userTime windows.Filetime
-	err := windows.GetProcessTimes(h, &startTime, &exitTime, &kernelTime, &userTime)
+	err = getProcessTimes(h, &startTime, &exitTime, &kernelTime, &userTime)
 	if err != nil {
 		c.reportError(ch, nil, err)
 		return
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
index 763d99e362..368625c6a8 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/http.go
@@ -37,10 +37,12 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"slices"
 	"strconv"
 	"sync"
 	"time"
 
+	dto "github.com/prometheus/client_model/go"
 	"github.com/prometheus/common/expfmt"
 
 	"github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil"
@@ -74,11 +76,118 @@ func defaultCompressionFormats() []Compression {
 }
 
 var gzipPool = sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return gzip.NewWriter(nil)
 	},
 }
 
+// coalescingGatherer wraps a TransactionalGatherer to deduplicate concurrent
+// Gather calls. When a Gather is already in flight, new callers join the
+// existing cycle and receive the same result once it completes. The underlying
+// done function is called exactly once, when the last joined caller releases.
+//
+// This prevents goroutine pile-up when the scrape rate is faster than the
+// time collectors need to produce metrics.
+type coalescingGatherer struct {
+	g     prometheus.TransactionalGatherer
+	mu    sync.Mutex
+	cycle *gatherCycle
+}
+
+// gatherCycle tracks a single in-flight Gather and all HTTP handlers sharing it.
+type gatherCycle struct {
+	ready chan struct{}       // closed when Gather completes; happens-before reads of mfs/err/done
+	mfs   []*dto.MetricFamily // canonical result, set before ready is closed; callers get a slices.Clone, the element values stay shared and must not be mutated
+	err   error               // set before ready is closed
+	done  func()              // underlying done callback; set before ready is closed
+	refs  int                 // number of handlers using this cycle; protected by coalescingGatherer.mu
+}
+
+var _ prometheus.TransactionalGatherer = (*coalescingGatherer)(nil) // compile-time interface check
+
+// errGatherPanicked is returned to callers that joined an in-flight coalesced
+// Gather whose underlying gatherer panicked. See the panic guard in Gather for
+// why joiners receive this error instead of the panic itself.
+var errGatherPanicked = errors.New("coalesced gather panicked")
+
+func (c *coalescingGatherer) Gather() ([]*dto.MetricFamily, func(), error) {
+	c.mu.Lock()
+	if cy := c.cycle; cy != nil {
+		// c.cycle is non-nil while Gather runs or handlers are still consuming its results.
+		cy.refs++
+		c.mu.Unlock()
+		<-cy.ready
+		// Each caller gets its own slice header so it can filter or reorder
+		// without racing other callers sharing this cycle. The *dto.MetricFamily
+		// values remain shared and must not be mutated in place.
+		return slices.Clone(cy.mfs), c.releaseFunc(cy), cy.err
+	}
+	cy := &gatherCycle{
+		ready: make(chan struct{}),
+		done:  func() {},
+		refs:  1,
+	}
+	c.cycle = cy
+	c.mu.Unlock()
+
+	// Guard against a panic in c.g.Gather. The common case, a panicking
+	// Collector, never reaches here: Registry.Gather recovers Collector panics
+	// and returns them as an error. This guard only covers the rare case where
+	// the wrapped gatherer itself panics.
+	//
+	// We deliberately do not recover: the leader's panic propagates and is
+	// handled by net/http exactly as it would be without coalescing. We only
+	// set cy.err before closing cy.ready so joiners waiting on <-cy.ready fail
+	// with that error instead of silently returning an empty, successful
+	// response, and we clear c.cycle so the next Gather starts a fresh cycle.
+	//
+	// The leader never runs its own releaseFunc on this path, so its ref is
+	// not decremented; that is harmless because the cycle is detached (c.cycle
+	// = nil) and cy.done is still the no-op set at construction (c.g.Gather
+	// panicked before assigning a real done). If cy.done is ever made non-nil
+	// before c.g.Gather runs, this path would need to release it.
+	panicked := true
+	defer func() {
+		if panicked {
+			c.mu.Lock()
+			if c.cycle == cy {
+				c.cycle = nil
+			}
+			c.mu.Unlock()
+			cy.err = errGatherPanicked // set before close: happens-before joiners' reads
+			close(cy.ready)
+		}
+	}()
+	cy.mfs, cy.done, cy.err = c.g.Gather()
+	panicked = false
+	close(cy.ready) // happens-before joiners' reads of cy.mfs/err/done
+
+	// Clone here too so cy.mfs stays the write-once canonical slice: joiners
+	// read it concurrently via slices.Clone, so the leader must not hand out
+	// (and potentially reorder) the same backing array.
+	return slices.Clone(cy.mfs), c.releaseFunc(cy), cy.err
+}
+
+// releaseFunc returns the done callback for one caller sharing cy.
+// When the last caller releases, the underlying done is invoked and the
+// cycle is cleared so the next Gather starts fresh.
+func (c *coalescingGatherer) releaseFunc(cy *gatherCycle) func() {
+	return func() {
+		c.mu.Lock()
+		cy.refs--
+		if cy.refs > 0 {
+			c.mu.Unlock()
+			return
+		}
+		// Last caller.
+		if c.cycle == cy {
+			c.cycle = nil
+		}
+		c.mu.Unlock()
+		cy.done() // called outside the lock to avoid holding it during done
+	}
+}
+
 // Handler returns an http.Handler for the prometheus.DefaultGatherer, using
 // default HandlerOpts, i.e. it reports the first error as an HTTP error, it has
 // no error logging, and it applies compression if requested by the client.
@@ -89,6 +198,10 @@ var gzipPool = sync.Pool{
 // metrics used for instrumentation will be shared between them, providing
 // global scrape counts.
 //
+// The handler supports filtering metrics by name using the `name[]` query parameter.
+// Multiple metric names can be specified by providing the parameter multiple times.
+// When no name[] parameters are provided, all metrics are returned.
+//
 // This function is meant to cover the bulk of basic use cases. If you are doing
 // anything that requires more customization (including using a non-default
 // Gatherer, different instrumentation, and non-default HandlerOpts), use the
@@ -105,6 +218,10 @@ func Handler() http.Handler {
 // Gatherers, with non-default HandlerOpts, and/or with custom (or no)
 // instrumentation. Use the InstrumentMetricHandler function to apply the same
 // kind of instrumentation as it is used by the Handler function.
+//
+// The handler supports filtering metrics by name using the `name[]` query parameter.
+// Multiple metric names can be specified by providing the parameter multiple times.
+// When no name[] parameters are provided, all metrics are returned.
 func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {
 	return HandlerForTransactional(prometheus.ToTransactionalGatherer(reg), opts)
 }
@@ -112,7 +229,15 @@ func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {
 // HandlerForTransactional is like HandlerFor, but it uses transactional gather, which
 // can safely change in-place returned *dto.MetricFamily before call to `Gather` and after
 // call to `done` of that `Gather`.
+//
+// The handler supports filtering metrics by name using the `name[]` query parameter.
+// Multiple metric names can be specified by providing the parameter multiple times.
+// When no name[] parameters are provided, all metrics are returned.
 func HandlerForTransactional(reg prometheus.TransactionalGatherer, opts HandlerOpts) http.Handler {
+	if opts.CoalesceGather {
+		reg = &coalescingGatherer{g: reg}
+	}
+
 	var (
 		inFlightSem chan struct{}
 		errCnt      = prometheus.NewCounterVec(
@@ -214,12 +339,14 @@ func HandlerForTransactional(reg prometheus.TransactionalGatherer, opts HandlerO
 			rsp.Header().Set(contentEncodingHeader, encodingHeader)
 		}
 
-		var enc expfmt.Encoder
+		var (
+			enc     expfmt.Encoder
+			encOpts []expfmt.EncoderOption
+		)
 		if opts.EnableOpenMetricsTextCreatedSamples {
-			enc = expfmt.NewEncoder(w, contentType, expfmt.WithCreatedLines())
-		} else {
-			enc = expfmt.NewEncoder(w, contentType)
+			encOpts = append(encOpts, expfmt.WithCreatedLines())
 		}
+		enc = expfmt.NewEncoder(w, contentType, encOpts...)
 
 		// handleError handles the error according to opts.ErrorHandling
 		// and returns true if we have to abort after the handling.
@@ -245,7 +372,21 @@ func HandlerForTransactional(reg prometheus.TransactionalGatherer, opts HandlerO
 			return false
 		}
 
+		// Build metric name filter set from query params (if any)
+		var metricFilter map[string]struct{}
+		if metricNames := req.URL.Query()["name[]"]; len(metricNames) > 0 {
+			metricFilter = make(map[string]struct{}, len(metricNames))
+			for _, name := range metricNames {
+				metricFilter[name] = struct{}{}
+			}
+		}
+
 		for _, mf := range mfs {
+			if metricFilter != nil {
+				if _, ok := metricFilter[mf.GetName()]; !ok {
+					continue
+				}
+			}
 			if handleError(enc.Encode(mf)) {
 				return
 			}
@@ -353,7 +494,7 @@ const (
 // log.Logger from the standard library implements this interface, and it is
 // easy to implement by custom loggers, if they don't do so already anyway.
 type Logger interface {
-	Println(v ...interface{})
+	Println(v ...any)
 }
 
 // HandlerOpts specifies options how to serve metrics via an http.Handler. The
@@ -400,6 +541,40 @@ type HandlerOpts struct {
 	// Service Unavailable and a suitable message in the body. If
 	// MaxRequestsInFlight is 0 or negative, no limit is applied.
 	MaxRequestsInFlight int
+	// CoalesceGather, if true, deduplicates concurrent Gather calls so that
+	// only one collection runs at a time. Additional requests that arrive
+	// while a Gather is in flight will receive the same result once it
+	// completes. This prevents goroutine pile-up when the scrape rate is
+	// faster than the time collectors need to produce metrics.
+	//
+	// When enabled, concurrent scrapers share a single metric snapshot per
+	// collection cycle. Each request receives its own copy of the returned
+	// slice, so filtering or reordering it (for example via name[] query
+	// parameters) is safe. The pointed-to MetricFamily values are still
+	// shared: the built-in handler only reads them, so this is safe in
+	// practice, but a custom TransactionalGatherer that mutates the returned
+	// families in place after Gather returns must not use this option.
+	//
+	// Because the snapshot is shared, a request that arrives while a cycle is
+	// in flight receives that cycle's result even though collection began
+	// before the request; two scrapers joined to one cycle observe the same
+	// timestamps rather than independently gathered data.
+	//
+	// Consider using CoalesceGather together with Timeout. Timeout bounds the
+	// client-facing response time and keeps at most one collection running at
+	// a time, but it does not cancel the underlying Gather: a joined request
+	// that times out still holds a MaxRequestsInFlight slot until the shared
+	// collection completes.
+	//
+	// Panic handling: a panicking Collector is already turned into an error by
+	// the registry, so joiners receive that error like any other. In the rare
+	// case where the wrapped gatherer itself panics, the panicking request's
+	// panic propagates as usual (handled by net/http), while requests that
+	// joined the same cycle receive an error rather than an empty response.
+	//
+	// NOTE: This option is experimental and may change or be removed in a
+	// future release.
+	CoalesceGather bool
 	// If handling a request takes longer than Timeout, it is responded to
 	// with 503 ServiceUnavailable and a suitable Message. No timeout is
 	// applied if Timeout is 0 or negative. Note that with the current
@@ -407,8 +582,9 @@ type HandlerOpts struct {
 	// described above (and even that only if sending of the body hasn't
 	// started yet), while the bulk work of gathering all the metrics keeps
 	// running in the background (with the eventual result to be thrown
-	// away). Until the implementation is improved, it is recommended to
-	// implement a separate timeout in potentially slow Collectors.
+	// away). When CoalesceGather is enabled, only one such background Gather
+	// can be in flight at a time. It is also recommended to implement a
+	// separate timeout in potentially slow Collectors.
 	Timeout time.Duration
 	// If true, the experimental OpenMetrics encoding is added to the
 	// possible options during content negotiation. Note that Prometheus
@@ -460,7 +636,7 @@ func httpError(rsp http.ResponseWriter, err error) {
 
 // negotiateEncodingWriter reads the Accept-Encoding header from a request and
 // selects the right compression based on an allow-list of supported
-// compressions. It returns a writer implementing the compression and an the
+// compressions. It returns a writer implementing the compression and the
 // correct value that the caller can set in the response header.
 func negotiateEncodingWriter(r *http.Request, rw io.Writer, compressions []string) (_ io.Writer, encodingHeaderValue string, closeWriter func(), _ error) {
 	if len(compressions) == 0 {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go
index d3482c40ca..0248579742 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_client.go
@@ -75,10 +75,10 @@ func InstrumentRoundTripperCounter(counter *prometheus.CounterVec, next http.Rou
 		resp, err := next.RoundTrip(r)
 		if err == nil {
 			l := labels(code, method, r.Method, resp.StatusCode, rtOpts.extraMethods...)
-			for label, resolve := range rtOpts.extraLabelsFromCtx {
-				l[label] = resolve(resp.Request.Context())
+			for label, resolve := range rtOpts.extraLabelsFromRequest {
+				l[label] = resolve(resp.Request)
 			}
-			addWithExemplar(counter.With(l), 1, rtOpts.getExemplarFn(r.Context()))
+			addWithExemplar(counter.With(l), 1, rtOpts.getExemplarFn(r))
 		}
 		return resp, err
 	}
@@ -119,10 +119,10 @@ func InstrumentRoundTripperDuration(obs prometheus.ObserverVec, next http.RoundT
 		resp, err := next.RoundTrip(r)
 		if err == nil {
 			l := labels(code, method, r.Method, resp.StatusCode, rtOpts.extraMethods...)
-			for label, resolve := range rtOpts.extraLabelsFromCtx {
-				l[label] = resolve(resp.Request.Context())
+			for label, resolve := range rtOpts.extraLabelsFromRequest {
+				l[label] = resolve(resp.Request)
 			}
-			observeWithExemplar(obs.With(l), time.Since(start).Seconds(), rtOpts.getExemplarFn(r.Context()))
+			observeWithExemplar(obs.With(l), time.Since(start).Seconds(), rtOpts.getExemplarFn(r))
 		}
 		return resp, err
 	}
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_server.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_server.go
index 9332b0249a..9dec091ac7 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_server.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/instrument_server.go
@@ -28,24 +28,36 @@ import (
 // magicString is used for the hacky label test in checkLabels. Remove once fixed.
 const magicString = "zZgWfBxLqvG8kc8IMv3POi2Bb0tZI3vAnBx+gBaFi9FyPzB/CzKUer1yufDa"
 
-// observeWithExemplar is a wrapper for [prometheus.ExemplarAdder.ExemplarObserver],
-// which falls back to [prometheus.Observer.Observe] if no labels are provided.
+// observeWithExemplar records val on obs. If labels is non-nil and obs
+// implements [prometheus.ExemplarObserver], the exemplar is attached via
+// ObserveWithExemplar; otherwise the exemplar is dropped and the value is
+// recorded with a plain [prometheus.Observer.Observe]. This mirrors the
+// safe-cast pattern in [prometheus.Timer.ObserveDurationWithExemplar] and
+// ensures we never panic when callers pass an ObserverVec backed by a
+// summary, which cannot carry exemplars in the Prometheus exposition format.
 func observeWithExemplar(obs prometheus.Observer, val float64, labels map[string]string) {
-	if labels == nil {
-		obs.Observe(val)
-		return
+	if labels != nil {
+		if eo, ok := obs.(prometheus.ExemplarObserver); ok {
+			eo.ObserveWithExemplar(val, labels)
+			return
+		}
 	}
-	obs.(prometheus.ExemplarObserver).ObserveWithExemplar(val, labels)
+	obs.Observe(val)
 }
 
-// addWithExemplar is a wrapper for [prometheus.ExemplarAdder.AddWithExemplar],
-// which falls back to [prometheus.Counter.Add] if no labels are provided.
-func addWithExemplar(obs prometheus.Counter, val float64, labels map[string]string) {
-	if labels == nil {
-		obs.Add(val)
-		return
+// addWithExemplar records val on c. If labels is non-nil and c implements
+// [prometheus.ExemplarAdder], the exemplar is attached via AddWithExemplar;
+// otherwise the exemplar is dropped and the value is recorded with a plain
+// [prometheus.Counter.Add]. The safe-cast keeps the helper robust against
+// custom Counter implementations that do not advertise exemplar support.
+func addWithExemplar(c prometheus.Counter, val float64, labels map[string]string) {
+	if labels != nil {
+		if ea, ok := c.(prometheus.ExemplarAdder); ok {
+			ea.AddWithExemplar(val, labels)
+			return
+		}
 	}
-	obs.(prometheus.ExemplarAdder).AddWithExemplar(val, labels)
+	c.Add(val)
 }
 
 // InstrumentHandlerInFlight is a middleware that wraps the provided
@@ -97,10 +109,10 @@ func InstrumentHandlerDuration(obs prometheus.ObserverVec, next http.Handler, op
 			next.ServeHTTP(d, r)
 
 			l := labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)
-			for label, resolve := range hOpts.extraLabelsFromCtx {
-				l[label] = resolve(r.Context())
+			for label, resolve := range hOpts.extraLabelsFromRequest {
+				l[label] = resolve(r)
 			}
-			observeWithExemplar(obs.With(l), time.Since(now).Seconds(), hOpts.getExemplarFn(r.Context()))
+			observeWithExemplar(obs.With(l), time.Since(now).Seconds(), hOpts.getExemplarFn(r))
 		}
 	}
 
@@ -108,10 +120,10 @@ func InstrumentHandlerDuration(obs prometheus.ObserverVec, next http.Handler, op
 		now := time.Now()
 		next.ServeHTTP(w, r)
 		l := labels(code, method, r.Method, 0, hOpts.extraMethods...)
-		for label, resolve := range hOpts.extraLabelsFromCtx {
-			l[label] = resolve(r.Context())
+		for label, resolve := range hOpts.extraLabelsFromRequest {
+			l[label] = resolve(r)
 		}
-		observeWithExemplar(obs.With(l), time.Since(now).Seconds(), hOpts.getExemplarFn(r.Context()))
+		observeWithExemplar(obs.With(l), time.Since(now).Seconds(), hOpts.getExemplarFn(r))
 	}
 }
 
@@ -147,10 +159,10 @@ func InstrumentHandlerCounter(counter *prometheus.CounterVec, next http.Handler,
 			next.ServeHTTP(d, r)
 
 			l := labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)
-			for label, resolve := range hOpts.extraLabelsFromCtx {
-				l[label] = resolve(r.Context())
+			for label, resolve := range hOpts.extraLabelsFromRequest {
+				l[label] = resolve(r)
 			}
-			addWithExemplar(counter.With(l), 1, hOpts.getExemplarFn(r.Context()))
+			addWithExemplar(counter.With(l), 1, hOpts.getExemplarFn(r))
 		}
 	}
 
@@ -158,10 +170,10 @@ func InstrumentHandlerCounter(counter *prometheus.CounterVec, next http.Handler,
 		next.ServeHTTP(w, r)
 
 		l := labels(code, method, r.Method, 0, hOpts.extraMethods...)
-		for label, resolve := range hOpts.extraLabelsFromCtx {
-			l[label] = resolve(r.Context())
+		for label, resolve := range hOpts.extraLabelsFromRequest {
+			l[label] = resolve(r)
 		}
-		addWithExemplar(counter.With(l), 1, hOpts.getExemplarFn(r.Context()))
+		addWithExemplar(counter.With(l), 1, hOpts.getExemplarFn(r))
 	}
 }
 
@@ -200,10 +212,10 @@ func InstrumentHandlerTimeToWriteHeader(obs prometheus.ObserverVec, next http.Ha
 		now := time.Now()
 		d := newDelegator(w, func(status int) {
 			l := labels(code, method, r.Method, status, hOpts.extraMethods...)
-			for label, resolve := range hOpts.extraLabelsFromCtx {
-				l[label] = resolve(r.Context())
+			for label, resolve := range hOpts.extraLabelsFromRequest {
+				l[label] = resolve(r)
 			}
-			observeWithExemplar(obs.With(l), time.Since(now).Seconds(), hOpts.getExemplarFn(r.Context()))
+			observeWithExemplar(obs.With(l), time.Since(now).Seconds(), hOpts.getExemplarFn(r))
 		})
 		next.ServeHTTP(d, r)
 	}
@@ -244,10 +256,10 @@ func InstrumentHandlerRequestSize(obs prometheus.ObserverVec, next http.Handler,
 			size := computeApproximateRequestSize(r)
 
 			l := labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)
-			for label, resolve := range hOpts.extraLabelsFromCtx {
-				l[label] = resolve(r.Context())
+			for label, resolve := range hOpts.extraLabelsFromRequest {
+				l[label] = resolve(r)
 			}
-			observeWithExemplar(obs.With(l), float64(size), hOpts.getExemplarFn(r.Context()))
+			observeWithExemplar(obs.With(l), float64(size), hOpts.getExemplarFn(r))
 		}
 	}
 
@@ -256,10 +268,10 @@ func InstrumentHandlerRequestSize(obs prometheus.ObserverVec, next http.Handler,
 		size := computeApproximateRequestSize(r)
 
 		l := labels(code, method, r.Method, 0, hOpts.extraMethods...)
-		for label, resolve := range hOpts.extraLabelsFromCtx {
-			l[label] = resolve(r.Context())
+		for label, resolve := range hOpts.extraLabelsFromRequest {
+			l[label] = resolve(r)
 		}
-		observeWithExemplar(obs.With(l), float64(size), hOpts.getExemplarFn(r.Context()))
+		observeWithExemplar(obs.With(l), float64(size), hOpts.getExemplarFn(r))
 	}
 }
 
@@ -296,10 +308,10 @@ func InstrumentHandlerResponseSize(obs prometheus.ObserverVec, next http.Handler
 		next.ServeHTTP(d, r)
 
 		l := labels(code, method, r.Method, d.Status(), hOpts.extraMethods...)
-		for label, resolve := range hOpts.extraLabelsFromCtx {
-			l[label] = resolve(r.Context())
+		for label, resolve := range hOpts.extraLabelsFromRequest {
+			l[label] = resolve(r)
 		}
-		observeWithExemplar(obs.With(l), float64(d.Written()), hOpts.getExemplarFn(r.Context()))
+		observeWithExemplar(obs.With(l), float64(d.Written()), hOpts.getExemplarFn(r))
 	})
 }
 
@@ -366,7 +378,7 @@ func checkLabels(c prometheus.Collector) (code, method bool) {
 			panic("metric partitioned with non-supported labels")
 		}
 	}
-	return
+	return code, method
 }
 
 func isLabelCurried(c prometheus.Collector, label string) bool {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/option.go b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/option.go
index 5d4383aa14..d4c0954f36 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/promhttp/option.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/promhttp/option.go
@@ -15,6 +15,7 @@ package promhttp
 
 import (
 	"context"
+	"net/http"
 
 	"github.com/prometheus/client_golang/prometheus"
 )
@@ -24,28 +25,31 @@ type Option interface {
 	apply(*options)
 }
 
+// LabelValueFromRequest is used to compute the label value from request.
+type LabelValueFromRequest func(request *http.Request) string
+
 // LabelValueFromCtx are used to compute the label value from request context.
 // Context can be filled with values from request through middleware.
 type LabelValueFromCtx func(ctx context.Context) string
 
 // options store options for both a handler or round tripper.
 type options struct {
-	extraMethods       []string
-	getExemplarFn      func(requestCtx context.Context) prometheus.Labels
-	extraLabelsFromCtx map[string]LabelValueFromCtx
+	extraMethods           []string
+	getExemplarFn          func(req *http.Request) prometheus.Labels
+	extraLabelsFromRequest map[string]LabelValueFromRequest
 }
 
 func defaultOptions() *options {
 	return &options{
-		getExemplarFn:      func(ctx context.Context) prometheus.Labels { return nil },
-		extraLabelsFromCtx: map[string]LabelValueFromCtx{},
+		getExemplarFn:          func(req *http.Request) prometheus.Labels { return nil },
+		extraLabelsFromRequest: map[string]LabelValueFromRequest{},
 	}
 }
 
 func (o *options) emptyDynamicLabels() prometheus.Labels {
 	labels := prometheus.Labels{}
 
-	for label := range o.extraLabelsFromCtx {
+	for label := range o.extraLabelsFromRequest {
 		labels[label] = ""
 	}
 
@@ -66,19 +70,39 @@ func WithExtraMethods(methods ...string) Option {
 	})
 }
 
-// WithExemplarFromContext allows to inject function that will get exemplar from context that will be put to counter and histogram metrics.
+// WithExemplarFromRequest allows you to inject a function that will get exemplar from request that will be put to counter and histogram metrics.
 // If the function returns nil labels or the metric does not support exemplars, no exemplar will be added (noop), but
 // metric will continue to observe/increment.
-func WithExemplarFromContext(getExemplarFn func(requestCtx context.Context) prometheus.Labels) Option {
+func WithExemplarFromRequest(getExemplarFn func(req *http.Request) prometheus.Labels) Option {
 	return optionApplyFunc(func(o *options) {
 		o.getExemplarFn = getExemplarFn
 	})
 }
 
+// WithExemplarFromContext allows you to inject a function that will get exemplar from context that will be put to counter and histogram metrics.
+// If the function returns nil labels or the metric does not support exemplars, no exemplar will be added (noop), but
+// metric will continue to observe/increment.
+func WithExemplarFromContext(getExemplarFn func(requestCtx context.Context) prometheus.Labels) Option {
+	return optionApplyFunc(func(o *options) {
+		o.getExemplarFn = func(req *http.Request) prometheus.Labels {
+			return getExemplarFn(req.Context())
+		}
+	})
+}
+
+// WithLabelFromRequest registers a label for dynamic resolution with access to the request.
+func WithLabelFromRequest(name string, valueFn LabelValueFromRequest) Option {
+	return optionApplyFunc(func(o *options) {
+		o.extraLabelsFromRequest[name] = valueFn
+	})
+}
+
 // WithLabelFromCtx registers a label for dynamic resolution with access to context.
 // See the example for ExampleInstrumentHandlerWithLabelResolver for example usage
 func WithLabelFromCtx(name string, valueFn LabelValueFromCtx) Option {
 	return optionApplyFunc(func(o *options) {
-		o.extraLabelsFromCtx[name] = valueFn
+		o.extraLabelsFromRequest[name] = func(req *http.Request) string {
+			return valueFn(req.Context())
+		}
 	})
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/registry.go b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
index c6fd2f58b7..ed0681c8b4 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/registry.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/registry.go
@@ -214,6 +214,19 @@ func (err AlreadyRegisteredError) Error() string {
 // by a Gatherer to report multiple errors during MetricFamily gathering.
 type MultiError []error
 
+// SafeMultiError is a thread-safe wrapper around MultiError using a mutex.
+type SafeMultiError struct {
+	mu   sync.Mutex
+	errs MultiError
+}
+
+// Appends the provided error to the contained MultiError in a thread-safe way.
+func (s *SafeMultiError) Append(err error) {
+	s.mu.Lock()
+	s.errs.Append(err)
+	s.mu.Unlock()
+}
+
 // Error formats the contained errors as a bullet point list, preceded by the
 // total number of errors. Note that this results in a multi-line string.
 func (errs MultiError) Error() string {
@@ -408,6 +421,16 @@ func (r *Registry) MustRegister(cs ...Collector) {
 	}
 }
 
+// MustGather implements Gatherer.
+// Wraps around Gather and panics if Gather fails for any reason.
+func (r *Registry) MustGather() []*dto.MetricFamily {
+	mfs, err := r.Gather()
+	if err != nil {
+		panic(err)
+	}
+	return mfs
+}
+
 // Gather implements Gatherer.
 func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 	r.mtx.RLock()
@@ -423,7 +446,7 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 		uncheckedMetricChan = make(chan Metric, capMetricChan)
 		metricHashes        = map[uint64]struct{}{}
 		wg                  sync.WaitGroup
-		errs                MultiError          // The collected errors to return in the end.
+		safeErrs            = &SafeMultiError{} // To collect errors in a threadsafe way
 		registeredDescIDs   map[uint64]struct{} // Only used for pedantic checks
 	)
 
@@ -453,9 +476,9 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 		for {
 			select {
 			case collector := <-checkedCollectors:
-				collector.Collect(checkedMetricChan)
+				safeErrs.Append((safeCollect(collector, checkedMetricChan)))
 			case collector := <-uncheckedCollectors:
-				collector.Collect(uncheckedMetricChan)
+				safeErrs.Append(safeCollect(collector, uncheckedMetricChan))
 			default:
 				return
 			}
@@ -499,7 +522,7 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 				cmc = nil
 				break
 			}
-			errs.Append(processMetric(
+			safeErrs.Append(processMetric(
 				metric, metricFamiliesByName,
 				metricHashes,
 				registeredDescIDs,
@@ -509,7 +532,7 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 				umc = nil
 				break
 			}
-			errs.Append(processMetric(
+			safeErrs.Append(processMetric(
 				metric, metricFamiliesByName,
 				metricHashes,
 				nil,
@@ -526,7 +549,7 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 						cmc = nil
 						break
 					}
-					errs.Append(processMetric(
+					safeErrs.Append(processMetric(
 						metric, metricFamiliesByName,
 						metricHashes,
 						registeredDescIDs,
@@ -536,7 +559,7 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 						umc = nil
 						break
 					}
-					errs.Append(processMetric(
+					safeErrs.Append(processMetric(
 						metric, metricFamiliesByName,
 						metricHashes,
 						nil,
@@ -556,7 +579,8 @@ func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
 			break
 		}
 	}
-	return internal.NormalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
+
+	return internal.NormalizeMetricFamilies(metricFamiliesByName), safeErrs.errs.MaybeUnwrap()
 }
 
 // Describe implements Collector.
@@ -571,6 +595,24 @@ func (r *Registry) Describe(ch chan<- *Desc) {
 	}
 }
 
+// Helper wrapper around Collector.Collect.
+// It tries to collect from the channel, recovers on panic and
+// if it has recovered from a panic, then it sends an InvalidMetric into
+// the channel with an InvalidDesc, and an error that includes a stack trace.
+func safeCollect(c Collector, ch chan<- Metric) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			buf := make([]byte, 64<<10) //	64 KB
+			n := runtime.Stack(buf, false)
+			err = fmt.Errorf("prometheus collector panic recovered: type=%T: error=%v\nstack trace=%s", c, r, buf[:n])
+			ch <- NewInvalidMetric(NewInvalidDesc(err), err)
+		}
+	}()
+	c.Collect(ch)
+
+	return err
+}
+
 // Collect implements Collector.
 func (r *Registry) Collect(ch chan<- Metric) {
 	r.mtx.RLock()
@@ -599,10 +641,12 @@ func WriteToTextfile(filename string, g Gatherer) error {
 
 	mfs, err := g.Gather()
 	if err != nil {
+		tmp.Close()
 		return err
 	}
 	for _, mf := range mfs {
 		if _, err := expfmt.MetricFamilyToText(tmp, mf); err != nil {
+			tmp.Close()
 			return err
 		}
 	}
@@ -685,6 +729,9 @@ func processMetric(
 		metricFamily = &dto.MetricFamily{}
 		metricFamily.Name = proto.String(desc.fqName)
 		metricFamily.Help = proto.String(desc.help)
+		if desc.unit != "" {
+			metricFamily.Unit = proto.String(desc.unit)
+		}
 		// TODO(beorn7): Simplify switch once Desc has type.
 		switch {
 		case dtoMetric.Gauge != nil:
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/summary.go b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
index ac5203c6fa..c12b8d13d4 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/summary.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/summary.go
@@ -101,6 +101,9 @@ type SummaryOpts struct {
 	// string.
 	Help string
 
+	// Unit provides the unit of this Summary.
+	Unit string
+
 	// ConstLabels are used to attach fixed labels to this metric. Metrics
 	// with the same fully-qualified name must have the same label names in
 	// their ConstLabels.
@@ -181,11 +184,12 @@ type SummaryVecOpts struct {
 // NewSummary creates a new Summary based on the provided SummaryOpts.
 func NewSummary(opts SummaryOpts) Summary {
 	return newSummary(
-		NewDesc(
+		V2.NewDesc(
 			BuildFQName(opts.Namespace, opts.Subsystem, opts.Name),
 			opts.Help,
-			nil,
+			UnconstrainedLabels(nil),
 			opts.ConstLabels,
+			WithUnit(opts.Unit),
 		),
 		opts,
 	)
@@ -578,6 +582,7 @@ func (v2) NewSummaryVec(opts SummaryVecOpts) *SummaryVec {
 		opts.Help,
 		opts.VariableLabels,
 		opts.ConstLabels,
+		WithUnit(opts.Unit),
 	)
 	return &SummaryVec{
 		MetricVec: NewMetricVec(desc, func(lvs ...string) Metric {
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/timer.go b/vendor/github.com/prometheus/client_golang/prometheus/timer.go
index 52344fef53..c1318ffb51 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/timer.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/timer.go
@@ -37,10 +37,10 @@ type Timer struct {
 // or
 //
 //	func TimeMeWithExemplar() {
-//		    timer := NewTimer(myHistogram)
-//		    defer timer.ObserveDurationWithExemplar(exemplar)
-//		    // Do actual work.
-//		}
+//	    timer := NewTimer(myHistogram)
+//	    defer timer.ObserveDurationWithExemplar(exemplar)
+//	    // Do actual work.
+//	}
 func NewTimer(o Observer) *Timer {
 	return &Timer{
 		begin:    time.Now(),
@@ -66,7 +66,7 @@ func (t *Timer) ObserveDuration() time.Duration {
 
 // ObserveDurationWithExemplar is like ObserveDuration, but it will also
 // observe exemplar with the duration unless exemplar is nil or provided Observer can't
-// be casted to ExemplarObserver.
+// be cast to ExemplarObserver.
 func (t *Timer) ObserveDurationWithExemplar(exemplar Labels) time.Duration {
 	d := time.Since(t.begin)
 	eo, ok := t.observer.(ExemplarObserver)
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/vec.go b/vendor/github.com/prometheus/client_golang/prometheus/vec.go
index 487b466563..121d2a9639 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/vec.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/vec.go
@@ -193,9 +193,11 @@ func (m *MetricVec) CurryWith(labels Labels) (*MetricVec, error) {
 //
 // Keeping the Metric for later use is possible (and should be considered if
 // performance is critical), but keep in mind that Reset, DeleteLabelValues and
-// Delete can be used to delete the Metric from the MetricVec. In that case, the
-// Metric will still exist, but it will not be exported anymore, even if a
-// Metric with the same label values is created later.
+// Delete can be used to delete the Metric from the MetricVec. In that case, if
+// you have previously kept a reference to that Metric, the Metric object still
+// exists and can be used, but it will not be exported anymore. If a Metric with
+// the same label values is created later, updates to the old Metric reference
+// will not be exported.
 //
 // An error is returned if the number of label values is not the same as the
 // number of variable labels in Desc (minus any curried labels).
@@ -657,7 +659,7 @@ func inlineLabelValues(lvs []string, curry []curriedLabelValue) []string {
 }
 
 var labelsPool = &sync.Pool{
-	New: func() interface{} {
+	New: func() any {
 		return make(Labels)
 	},
 }
diff --git a/vendor/github.com/prometheus/client_golang/prometheus/wrap.go b/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
index 2ed1285068..697f55558b 100644
--- a/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
+++ b/vendor/github.com/prometheus/client_golang/prometheus/wrap.go
@@ -230,6 +230,7 @@ func wrapDesc(desc *Desc, prefix string, labels Labels) *Desc {
 			return &Desc{
 				fqName:          desc.fqName,
 				help:            desc.help,
+				unit:            desc.unit,
 				variableLabels:  desc.variableLabels,
 				constLabelPairs: desc.constLabelPairs,
 				err:             fmt.Errorf("attempted wrapping with already existing label name %q", ln),
@@ -238,8 +239,8 @@ func wrapDesc(desc *Desc, prefix string, labels Labels) *Desc {
 		constLabels[ln] = lv
 	}
 	// NewDesc will do remaining validations.
-	newDesc := V2.NewDesc(prefix+desc.fqName, desc.help, desc.variableLabels, constLabels)
-	// Propagate errors if there was any. This will override any errer
+	newDesc := V2.NewDesc(prefix+desc.fqName, desc.help, desc.variableLabels, constLabels, WithUnit(desc.unit))
+	// Propagate errors if there was any. This will override any error
 	// created by NewDesc above, i.e. earlier errors get precedence.
 	if desc.err != nil {
 		newDesc.err = desc.err
diff --git a/vendor/github.com/prometheus/procfs/net_wireless.go b/vendor/github.com/prometheus/procfs/net_wireless.go
index 69d0794451..f74dd3bed0 100644
--- a/vendor/github.com/prometheus/procfs/net_wireless.go
+++ b/vendor/github.com/prometheus/procfs/net_wireless.go
@@ -114,47 +114,47 @@ func parseWireless(r io.Reader) ([]*Wireless, error) {
 
 		qlink, err := strconv.Atoi(strings.TrimSuffix(stats[1], "."))
 		if err != nil {
-			return nil, fmt.Errorf("%w: parse Quality:link as integer %q: %w", ErrFileParse, qlink, err)
+			return nil, fmt.Errorf("%w: parse Quality:link as integer %q: %w", ErrFileParse, stats[1], err)
 		}
 
 		qlevel, err := strconv.Atoi(strings.TrimSuffix(stats[2], "."))
 		if err != nil {
-			return nil, fmt.Errorf("%w: Quality:level as integer %q: %w", ErrFileParse, qlevel, err)
+			return nil, fmt.Errorf("%w: Quality:level as integer %q: %w", ErrFileParse, stats[2], err)
 		}
 
 		qnoise, err := strconv.Atoi(strings.TrimSuffix(stats[3], "."))
 		if err != nil {
-			return nil, fmt.Errorf("%w: Quality:noise as integer %q: %w", ErrFileParse, qnoise, err)
+			return nil, fmt.Errorf("%w: Quality:noise as integer %q: %w", ErrFileParse, stats[3], err)
 		}
 
 		dnwid, err := strconv.Atoi(stats[4])
 		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:nwid as integer %q: %w", ErrFileParse, dnwid, err)
+			return nil, fmt.Errorf("%w: Discarded:nwid as integer %q: %w", ErrFileParse, stats[4], err)
 		}
 
 		dcrypt, err := strconv.Atoi(stats[5])
 		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:crypt as integer %q: %w", ErrFileParse, dcrypt, err)
+			return nil, fmt.Errorf("%w: Discarded:crypt as integer %q: %w", ErrFileParse, stats[5], err)
 		}
 
 		dfrag, err := strconv.Atoi(stats[6])
 		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:frag as integer %q: %w", ErrFileParse, dfrag, err)
+			return nil, fmt.Errorf("%w: Discarded:frag as integer %q: %w", ErrFileParse, stats[6], err)
 		}
 
 		dretry, err := strconv.Atoi(stats[7])
 		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:retry as integer %q: %w", ErrFileParse, dretry, err)
+			return nil, fmt.Errorf("%w: Discarded:retry as integer %q: %w", ErrFileParse, stats[7], err)
 		}
 
 		dmisc, err := strconv.Atoi(stats[8])
 		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:misc as integer %q: %w", ErrFileParse, dmisc, err)
+			return nil, fmt.Errorf("%w: Discarded:misc as integer %q: %w", ErrFileParse, stats[8], err)
 		}
 
 		mbeacon, err := strconv.Atoi(stats[9])
 		if err != nil {
-			return nil, fmt.Errorf("%w: Missed:beacon as integer %q: %w", ErrFileParse, mbeacon, err)
+			return nil, fmt.Errorf("%w: Missed:beacon as integer %q: %w", ErrFileParse, stats[9], err)
 		}
 
 		w := &Wireless{
diff --git a/vendor/github.com/prometheus/procfs/proc_cgroup.go b/vendor/github.com/prometheus/procfs/proc_cgroup.go
index 535c08d6fc..7e8a122978 100644
--- a/vendor/github.com/prometheus/procfs/proc_cgroup.go
+++ b/vendor/github.com/prometheus/procfs/proc_cgroup.go
@@ -60,7 +60,7 @@ func parseCgroupString(cgroupStr string) (*Cgroup, error) {
 	}
 	cgroup.HierarchyID, err = strconv.Atoi(fields[0])
 	if err != nil {
-		return nil, fmt.Errorf("%w: hierarchy ID: %q", ErrFileParse, cgroup.HierarchyID)
+		return nil, fmt.Errorf("%w: hierarchy ID: %q", ErrFileParse, fields[0])
 	}
 	if fields[1] != "" {
 		ssNames := strings.Split(fields[1], ",")
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 8bba933888..2cbef87139 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -332,7 +332,7 @@ github.com/jstemmer/go-junit-report/v2/junit
 github.com/jstemmer/go-junit-report/v2/parser/gotest
 github.com/jstemmer/go-junit-report/v2/parser/gotest/internal/collector
 github.com/jstemmer/go-junit-report/v2/parser/gotest/internal/reader
-# github.com/klauspost/compress v1.18.6
+# github.com/klauspost/compress v1.19.0
 ## explicit; go 1.24
 github.com/klauspost/compress
 github.com/klauspost/compress/fse
@@ -406,8 +406,8 @@ github.com/pkg/errors
 # github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2
 ## explicit
 github.com/pmezard/go-difflib/difflib
-# github.com/prometheus/client_golang v1.23.2
-## explicit; go 1.23.0
+# github.com/prometheus/client_golang v1.24.0
+## explicit; go 1.25.0
 github.com/prometheus/client_golang/api
 github.com/prometheus/client_golang/api/prometheus/v1
 github.com/prometheus/client_golang/internal/github.com/golang/gddo/httputil
@@ -424,7 +424,7 @@ github.com/prometheus/client_model/go
 ## explicit; go 1.25.0
 github.com/prometheus/common/expfmt
 github.com/prometheus/common/model
-# github.com/prometheus/procfs v0.21.0
+# github.com/prometheus/procfs v0.21.1
 ## explicit; go 1.25.0
 github.com/prometheus/procfs
 github.com/prometheus/procfs/internal/fs