5 files changed, 138 insertions, 11 deletions
diff --git a/vendor/codeberg.org/gruf/go-iotools/close.go b/vendor/codeberg.org/gruf/go-iotools/close.go
index 3f0ee7780..f3d4814ba 100644
--- a/vendor/codeberg.org/gruf/go-iotools/close.go
+++ b/vendor/codeberg.org/gruf/go-iotools/close.go
@@ -2,6 +2,13 @@ package iotools
 
 import "io"
 
+// NopCloser is an empty
+// implementation of io.Closer,
+// that simply does nothing!
+type NopCloser struct{}
+
+func (NopCloser) Close() error { return nil }
+
 // CloserFunc is a function signature which allows
 // a function to implement the io.Closer type.
 type CloserFunc func() error
@@ -10,6 +17,7 @@ func (c CloserFunc) Close() error {
 	return c()
 }
 
+// CloserCallback wraps io.Closer to add a callback deferred to call just after Close().
 func CloserCallback(c io.Closer, cb func()) io.Closer {
 	return CloserFunc(func() error {
 		defer cb()
@@ -17,6 +25,7 @@ func CloserCallback(c io.Closer, cb func()) io.Closer {
 	})
 }
 
+// CloserAfterCallback wraps io.Closer to add a callback called just before Close().
 func CloserAfterCallback(c io.Closer, cb func()) io.Closer {
 	return CloserFunc(func() (err error) {
 		defer func() { err = c.Close() }()
diff --git a/vendor/codeberg.org/gruf/go-iotools/helpers.go b/vendor/codeberg.org/gruf/go-iotools/helpers.go
new file mode 100644
index 000000000..0e50e05e0
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-iotools/helpers.go
@@ -0,0 +1,85 @@
+package iotools
+
+import "io"
+
+// AtEOF returns true when reader at EOF,
+// this is checked with a 0 length read.
+func AtEOF(r io.Reader) bool {
+	_, err := r.Read(nil)
+	return (err == io.EOF)
+}
+
+// GetReadCloserLimit attempts to cast io.Reader to access its io.LimitedReader with limit.
+func GetReaderLimit(r io.Reader) (*io.LimitedReader, int64) {
+	lr, ok := r.(*io.LimitedReader)
+	if !ok {
+		return nil, -1
+	}
+	return lr, lr.N
+}
+
+// UpdateReaderLimit attempts to  update the limit of a reader for existing, newly wrapping if necessary.
+func UpdateReaderLimit(r io.Reader, limit int64) (*io.LimitedReader, int64) {
+	lr, ok := r.(*io.LimitedReader)
+	if !ok {
+		lr = &io.LimitedReader{r, limit}
+		return lr, limit
+	}
+
+	if limit < lr.N {
+		// Update existing.
+		lr.N = limit
+	}
+
+	return lr, lr.N
+}
+
+// GetReadCloserLimit attempts to unwrap io.ReadCloser to access its io.LimitedReader with limit.
+func GetReadCloserLimit(rc io.ReadCloser) (*io.LimitedReader, int64) {
+	rct, ok := rc.(*ReadCloserType)
+	if !ok {
+		return nil, -1
+	}
+	lr, ok := rct.Reader.(*io.LimitedReader)
+	if !ok {
+		return nil, -1
+	}
+	return lr, lr.N
+}
+
+// UpdateReadCloserLimit attempts to update the limit of a readcloser for existing, newly wrapping if necessary.
+func UpdateReadCloserLimit(rc io.ReadCloser, limit int64) (io.ReadCloser, *io.LimitedReader, int64) {
+
+	// Check for our wrapped ReadCloserType.
+	if rct, ok := rc.(*ReadCloserType); ok {
+
+		// Attempt to update existing wrapped limit reader.
+		if lr, ok := rct.Reader.(*io.LimitedReader); ok {
+
+			if limit < lr.N {
+				// Update existing.
+				lr.N = limit
+			}
+
+			return rct, lr, lr.N
+		}
+
+		// Wrap the reader type with new limit.
+		lr := &io.LimitedReader{rct.Reader, limit}
+		rct.Reader = lr
+
+		return rct, lr, lr.N
+	}
+
+	// Wrap separated types.
+	rct := &ReadCloserType{
+		Reader: rc,
+		Closer: rc,
+	}
+
+	// Wrap separated reader part with limit.
+	lr := &io.LimitedReader{rct.Reader, limit}
+	rct.Reader = lr
+
+	return rct, lr, lr.N
+}
diff --git a/vendor/codeberg.org/gruf/go-iotools/read.go b/vendor/codeberg.org/gruf/go-iotools/read.go
index 6ce2789a7..13c5e21ac 100644
--- a/vendor/codeberg.org/gruf/go-iotools/read.go
+++ b/vendor/codeberg.org/gruf/go-iotools/read.go
@@ -4,6 +4,16 @@ import (
 	"io"
 )
 
+// ReadCloserType implements io.ReadCloser
+// by combining the two underlying interfaces,
+// while providing an exported type to still
+// access the underlying original io.Reader or
+// io.Closer separately (e.g. without wrapping).
+type ReadCloserType struct {
+	io.Reader
+	io.Closer
+}
+
 // ReaderFunc is a function signature which allows
 // a function to implement the io.Reader type.
 type ReaderFunc func([]byte) (int, error)
@@ -22,15 +32,10 @@ func (rf ReaderFromFunc) ReadFrom(r io.Reader) (int64, error) {
 
 // ReadCloser wraps an io.Reader and io.Closer in order to implement io.ReadCloser.
 func ReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
-	return &struct {
-		io.Reader
-		io.Closer
-	}{r, c}
+	return &ReadCloserType{r, c}
 }
 
-// NopReadCloser wraps an io.Reader to implement io.ReadCloser with empty io.Closer implementation.
+// NopReadCloser wraps io.Reader with NopCloser{} in ReadCloserType.
 func NopReadCloser(r io.Reader) io.ReadCloser {
-	return ReadCloser(r, CloserFunc(func() error {
-		return nil
-	}))
+	return &ReadCloserType{r, NopCloser{}}
 }
diff --git a/vendor/codeberg.org/gruf/go-iotools/size.go b/vendor/codeberg.org/gruf/go-iotools/size.go
new file mode 100644
index 000000000..f3841facf
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-iotools/size.go
@@ -0,0 +1,25 @@
+package iotools
+
+type Sizer interface {
+	Size() int64
+}
+
+// SizerFunc is a function signature which allows
+// a function to implement the Sizer type.
+type SizerFunc func() int64
+
+func (s SizerFunc) Size() int64 {
+	return s()
+}
+
+type Lengther interface {
+	Len() int
+}
+
+// LengthFunc is a function signature which allows
+// a function to implement the Lengther type.
+type LengthFunc func() int
+
+func (l LengthFunc) Len() int {
+	return l()
+}
diff --git a/vendor/codeberg.org/gruf/go-iotools/write.go b/vendor/codeberg.org/gruf/go-iotools/write.go
index e1b44db24..2037c42af 100644
--- a/vendor/codeberg.org/gruf/go-iotools/write.go
+++ b/vendor/codeberg.org/gruf/go-iotools/write.go
@@ -28,7 +28,10 @@ func WriteCloser(w io.Writer, c io.Closer) io.WriteCloser {
 
 // NopWriteCloser wraps an io.Writer to implement io.WriteCloser with empty io.Closer implementation.
 func NopWriteCloser(w io.Writer) io.WriteCloser {
-	return WriteCloser(w, CloserFunc(func() error {
-		return nil
-	}))
+	return &nopWriteCloser{w}
 }
+
+// nopWriteCloser implements io.WriteCloser with a no-op Close().
+type nopWriteCloser struct{ io.Writer }
+
+func (wc *nopWriteCloser) Close() error { return nil }