[performance] processing media and scheduled jobs improvements (#1482)

* replace media workers with just runners.WorkerPool, move to state structure, use go-sched for global task scheduling

* improved code comment

* fix worker tryUntil function, update go-runners/go-sched

* make preprocess functions package public, use these where possible to stop doubled up processing

* remove separate emoji worker pool

* limit calls to time.Now() during media preprocessing

* use Processor{} to manage singular runtime of processing media

* ensure workers get started when media manager is used

* improved error setting in processing media, fix media test

* port changes from processingmedia to processing emoji

* finish code commenting

* finish code commenting and comment-out client API + federator worker pools until concurrency worker pools replaced

* linterrrrrrrrrrrrrrrr

---------

Signed-off-by: kim <grufwub@gmail.com>

13 files changed, 1207 insertions, 490 deletions

diff --git a/vendor/codeberg.org/gruf/go-bitutil/abs.go b/vendor/codeberg.org/gruf/go-bitutil/abs.go
new file mode 100644
index 000000000..f4ce8ad75
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-bitutil/abs.go
@@ -0,0 +1,29 @@
+package bitutil
+
+// Abs8 returns the absolute value of i (calculated without branching).
+func Abs8(i int8) int8 {
+	const bits = 8
+	u := uint64(i >> (bits - 1))
+	return (i ^ int8(u)) + int8(u&1)
+}
+
+// Abs16 returns the absolute value of i (calculated without branching).
+func Abs16(i int16) int16 {
+	const bits = 16
+	u := uint64(i >> (bits - 1))
+	return (i ^ int16(u)) + int16(u&1)
+}
+
+// Abs32 returns the absolute value of i (calculated without branching).
+func Abs32(i int32) int32 {
+	const bits = 32
+	u := uint64(i >> (bits - 1))
+	return (i ^ int32(u)) + int32(u&1)
+}
+
+// Abs64 returns the absolute value of i (calculated without branching).
+func Abs64(i int64) int64 {
+	const bits = 64
+	u := uint64(i >> (bits - 1))
+	return (i ^ int64(u)) + int64(u&1)
+}
diff --git a/vendor/codeberg.org/gruf/go-bitutil/flag.go b/vendor/codeberg.org/gruf/go-bitutil/flag.go
index d8b0f8b66..6a5b20d11 100644
--- a/vendor/codeberg.org/gruf/go-bitutil/flag.go
+++ b/vendor/codeberg.org/gruf/go-bitutil/flag.go
@@ -1,11 +1,11 @@
 package bitutil
 
 import (
-	"codeberg.org/gruf/go-byteutil"
+	"unsafe"
 )
 
 // Flags8 is a type-casted unsigned integer with helper
-// methods for easily managing up to 8 bit flags.
+// methods for easily managing up to 8 bit-flags.
 type Flags8 uint8
 
 // Get will fetch the flag bit value at index 'bit'.
@@ -172,80 +172,135 @@ func (f Flags8) Unset7() Flags8 {
 
 // String returns a human readable representation of Flags8.
 func (f Flags8) String() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
 
-	buf.WriteByte('{')
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = 1 + (len("false ") * 8) - 1 + 1
+	buf = make([]byte, prealloc)
+
+	buf[i] = '{'
+	i++
 
 	val = f.Get0()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 // GoString returns a more verbose human readable representation of Flags8.
 func (f Flags8) GoString() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
+
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = len("bitutil.Flags8{") + (len("7=false ") * 8) - 1 + 1
+	buf = make([]byte, prealloc)
 
-	buf.WriteString("bitutil.Flags8{")
+	i += copy(buf[i:], "bitutil.Flags8{")
 
 	val = f.Get0()
-	buf.WriteString("0=" + bool2str(val) + " ")
+	i += copy(buf[i:], "0=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString("1=" + bool2str(val) + " ")
+	i += copy(buf[i:], "1=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString("2=" + bool2str(val) + " ")
+	i += copy(buf[i:], "2=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString("3=" + bool2str(val) + " ")
+	i += copy(buf[i:], "3=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString("4=" + bool2str(val) + " ")
+	i += copy(buf[i:], "4=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString("5=" + bool2str(val) + " ")
+	i += copy(buf[i:], "5=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString("6=" + bool2str(val) + " ")
+	i += copy(buf[i:], "6=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString("7=" + bool2str(val) + " ")
+	i += copy(buf[i:], "7=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 // Flags16 is a type-casted unsigned integer with helper
-// methods for easily managing up to 16 bit flags.
+// methods for easily managing up to 16 bit-flags.
 type Flags16 uint16
 
 // Get will fetch the flag bit value at index 'bit'.
@@ -556,128 +611,223 @@ func (f Flags16) Unset15() Flags16 {
 
 // String returns a human readable representation of Flags16.
 func (f Flags16) String() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
 
-	buf.WriteByte('{')
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = 1 + (len("false ") * 16) - 1 + 1
+	buf = make([]byte, prealloc)
+
+	buf[i] = '{'
+	i++
 
 	val = f.Get0()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get8()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get9()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get10()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get11()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get12()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get13()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get14()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get15()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 // GoString returns a more verbose human readable representation of Flags16.
 func (f Flags16) GoString() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
+
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = len("bitutil.Flags16{") + (len("15=false ") * 16) - 1 + 1
+	buf = make([]byte, prealloc)
 
-	buf.WriteString("bitutil.Flags16{")
+	i += copy(buf[i:], "bitutil.Flags16{")
 
 	val = f.Get0()
-	buf.WriteString("0=" + bool2str(val) + " ")
+	i += copy(buf[i:], "0=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString("1=" + bool2str(val) + " ")
+	i += copy(buf[i:], "1=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString("2=" + bool2str(val) + " ")
+	i += copy(buf[i:], "2=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString("3=" + bool2str(val) + " ")
+	i += copy(buf[i:], "3=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString("4=" + bool2str(val) + " ")
+	i += copy(buf[i:], "4=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString("5=" + bool2str(val) + " ")
+	i += copy(buf[i:], "5=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString("6=" + bool2str(val) + " ")
+	i += copy(buf[i:], "6=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString("7=" + bool2str(val) + " ")
+	i += copy(buf[i:], "7=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get8()
-	buf.WriteString("8=" + bool2str(val) + " ")
+	i += copy(buf[i:], "8=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get9()
-	buf.WriteString("9=" + bool2str(val) + " ")
+	i += copy(buf[i:], "9=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get10()
-	buf.WriteString("10=" + bool2str(val) + " ")
+	i += copy(buf[i:], "10=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get11()
-	buf.WriteString("11=" + bool2str(val) + " ")
+	i += copy(buf[i:], "11=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get12()
-	buf.WriteString("12=" + bool2str(val) + " ")
+	i += copy(buf[i:], "12=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get13()
-	buf.WriteString("13=" + bool2str(val) + " ")
+	i += copy(buf[i:], "13=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get14()
-	buf.WriteString("14=" + bool2str(val) + " ")
+	i += copy(buf[i:], "14=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get15()
-	buf.WriteString("15=" + bool2str(val) + " ")
+	i += copy(buf[i:], "15=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 // Flags32 is a type-casted unsigned integer with helper
-// methods for easily managing up to 32 bit flags.
+// methods for easily managing up to 32 bit-flags.
 type Flags32 uint32
 
 // Get will fetch the flag bit value at index 'bit'.
@@ -1276,224 +1426,399 @@ func (f Flags32) Unset31() Flags32 {
 
 // String returns a human readable representation of Flags32.
 func (f Flags32) String() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
 
-	buf.WriteByte('{')
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = 1 + (len("false ") * 32) - 1 + 1
+	buf = make([]byte, prealloc)
+
+	buf[i] = '{'
+	i++
 
 	val = f.Get0()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get8()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get9()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get10()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get11()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get12()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get13()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get14()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get15()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get16()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get17()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get18()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get19()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get20()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get21()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get22()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get23()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get24()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get25()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get26()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get27()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get28()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get29()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get30()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get31()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 // GoString returns a more verbose human readable representation of Flags32.
 func (f Flags32) GoString() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
+
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = len("bitutil.Flags32{") + (len("31=false ") * 32) - 1 + 1
+	buf = make([]byte, prealloc)
 
-	buf.WriteString("bitutil.Flags32{")
+	i += copy(buf[i:], "bitutil.Flags32{")
 
 	val = f.Get0()
-	buf.WriteString("0=" + bool2str(val) + " ")
+	i += copy(buf[i:], "0=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString("1=" + bool2str(val) + " ")
+	i += copy(buf[i:], "1=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString("2=" + bool2str(val) + " ")
+	i += copy(buf[i:], "2=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString("3=" + bool2str(val) + " ")
+	i += copy(buf[i:], "3=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString("4=" + bool2str(val) + " ")
+	i += copy(buf[i:], "4=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString("5=" + bool2str(val) + " ")
+	i += copy(buf[i:], "5=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString("6=" + bool2str(val) + " ")
+	i += copy(buf[i:], "6=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString("7=" + bool2str(val) + " ")
+	i += copy(buf[i:], "7=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get8()
-	buf.WriteString("8=" + bool2str(val) + " ")
+	i += copy(buf[i:], "8=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get9()
-	buf.WriteString("9=" + bool2str(val) + " ")
+	i += copy(buf[i:], "9=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get10()
-	buf.WriteString("10=" + bool2str(val) + " ")
+	i += copy(buf[i:], "10=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get11()
-	buf.WriteString("11=" + bool2str(val) + " ")
+	i += copy(buf[i:], "11=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get12()
-	buf.WriteString("12=" + bool2str(val) + " ")
+	i += copy(buf[i:], "12=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get13()
-	buf.WriteString("13=" + bool2str(val) + " ")
+	i += copy(buf[i:], "13=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get14()
-	buf.WriteString("14=" + bool2str(val) + " ")
+	i += copy(buf[i:], "14=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get15()
-	buf.WriteString("15=" + bool2str(val) + " ")
+	i += copy(buf[i:], "15=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get16()
-	buf.WriteString("16=" + bool2str(val) + " ")
+	i += copy(buf[i:], "16=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get17()
-	buf.WriteString("17=" + bool2str(val) + " ")
+	i += copy(buf[i:], "17=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get18()
-	buf.WriteString("18=" + bool2str(val) + " ")
+	i += copy(buf[i:], "18=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get19()
-	buf.WriteString("19=" + bool2str(val) + " ")
+	i += copy(buf[i:], "19=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get20()
-	buf.WriteString("20=" + bool2str(val) + " ")
+	i += copy(buf[i:], "20=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get21()
-	buf.WriteString("21=" + bool2str(val) + " ")
+	i += copy(buf[i:], "21=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get22()
-	buf.WriteString("22=" + bool2str(val) + " ")
+	i += copy(buf[i:], "22=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get23()
-	buf.WriteString("23=" + bool2str(val) + " ")
+	i += copy(buf[i:], "23=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get24()
-	buf.WriteString("24=" + bool2str(val) + " ")
+	i += copy(buf[i:], "24=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get25()
-	buf.WriteString("25=" + bool2str(val) + " ")
+	i += copy(buf[i:], "25=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get26()
-	buf.WriteString("26=" + bool2str(val) + " ")
+	i += copy(buf[i:], "26=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get27()
-	buf.WriteString("27=" + bool2str(val) + " ")
+	i += copy(buf[i:], "27=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get28()
-	buf.WriteString("28=" + bool2str(val) + " ")
+	i += copy(buf[i:], "28=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get29()
-	buf.WriteString("29=" + bool2str(val) + " ")
+	i += copy(buf[i:], "29=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get30()
-	buf.WriteString("30=" + bool2str(val) + " ")
+	i += copy(buf[i:], "30=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get31()
-	buf.WriteString("31=" + bool2str(val) + " ")
+	i += copy(buf[i:], "31=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 // Flags64 is a type-casted unsigned integer with helper
-// methods for easily managing up to 64 bit flags.
+// methods for easily managing up to 64 bit-flags.
 type Flags64 uint64
 
 // Get will fetch the flag bit value at index 'bit'.
@@ -2668,412 +2993,747 @@ func (f Flags64) Unset63() Flags64 {
 
 // String returns a human readable representation of Flags64.
 func (f Flags64) String() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
 
-	buf.WriteByte('{')
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = 1 + (len("false ") * 64) - 1 + 1
+	buf = make([]byte, prealloc)
+
+	buf[i] = '{'
+	i++
 
 	val = f.Get0()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get8()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get9()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get10()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get11()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get12()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get13()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get14()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get15()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get16()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get17()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get18()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get19()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get20()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get21()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get22()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get23()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get24()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get25()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get26()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get27()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get28()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get29()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get30()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get31()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get32()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get33()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get34()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get35()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get36()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get37()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get38()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get39()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get40()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get41()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get42()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get43()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get44()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get45()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get46()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get47()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get48()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get49()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get50()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get51()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get52()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get53()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get54()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get55()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get56()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get57()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get58()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get59()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get60()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get61()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get62()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get63()
-	buf.WriteString(bool2str(val) + " ")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 // GoString returns a more verbose human readable representation of Flags64.
 func (f Flags64) GoString() string {
-	var val bool
-	var buf byteutil.Buffer
+	var (
+		i   int
+		val bool
+		buf []byte
+	)
+
+	// Make a prealloc est. based on longest-possible value
+	const prealloc = len("bitutil.Flags64{") + (len("63=false ") * 64) - 1 + 1
+	buf = make([]byte, prealloc)
 
-	buf.WriteString("bitutil.Flags64{")
+	i += copy(buf[i:], "bitutil.Flags64{")
 
 	val = f.Get0()
-	buf.WriteString("0=" + bool2str(val) + " ")
+	i += copy(buf[i:], "0=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get1()
-	buf.WriteString("1=" + bool2str(val) + " ")
+	i += copy(buf[i:], "1=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get2()
-	buf.WriteString("2=" + bool2str(val) + " ")
+	i += copy(buf[i:], "2=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get3()
-	buf.WriteString("3=" + bool2str(val) + " ")
+	i += copy(buf[i:], "3=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get4()
-	buf.WriteString("4=" + bool2str(val) + " ")
+	i += copy(buf[i:], "4=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get5()
-	buf.WriteString("5=" + bool2str(val) + " ")
+	i += copy(buf[i:], "5=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get6()
-	buf.WriteString("6=" + bool2str(val) + " ")
+	i += copy(buf[i:], "6=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get7()
-	buf.WriteString("7=" + bool2str(val) + " ")
+	i += copy(buf[i:], "7=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get8()
-	buf.WriteString("8=" + bool2str(val) + " ")
+	i += copy(buf[i:], "8=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get9()
-	buf.WriteString("9=" + bool2str(val) + " ")
+	i += copy(buf[i:], "9=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get10()
-	buf.WriteString("10=" + bool2str(val) + " ")
+	i += copy(buf[i:], "10=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get11()
-	buf.WriteString("11=" + bool2str(val) + " ")
+	i += copy(buf[i:], "11=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get12()
-	buf.WriteString("12=" + bool2str(val) + " ")
+	i += copy(buf[i:], "12=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get13()
-	buf.WriteString("13=" + bool2str(val) + " ")
+	i += copy(buf[i:], "13=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get14()
-	buf.WriteString("14=" + bool2str(val) + " ")
+	i += copy(buf[i:], "14=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get15()
-	buf.WriteString("15=" + bool2str(val) + " ")
+	i += copy(buf[i:], "15=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get16()
-	buf.WriteString("16=" + bool2str(val) + " ")
+	i += copy(buf[i:], "16=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get17()
-	buf.WriteString("17=" + bool2str(val) + " ")
+	i += copy(buf[i:], "17=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get18()
-	buf.WriteString("18=" + bool2str(val) + " ")
+	i += copy(buf[i:], "18=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get19()
-	buf.WriteString("19=" + bool2str(val) + " ")
+	i += copy(buf[i:], "19=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get20()
-	buf.WriteString("20=" + bool2str(val) + " ")
+	i += copy(buf[i:], "20=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get21()
-	buf.WriteString("21=" + bool2str(val) + " ")
+	i += copy(buf[i:], "21=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get22()
-	buf.WriteString("22=" + bool2str(val) + " ")
+	i += copy(buf[i:], "22=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get23()
-	buf.WriteString("23=" + bool2str(val) + " ")
+	i += copy(buf[i:], "23=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get24()
-	buf.WriteString("24=" + bool2str(val) + " ")
+	i += copy(buf[i:], "24=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get25()
-	buf.WriteString("25=" + bool2str(val) + " ")
+	i += copy(buf[i:], "25=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get26()
-	buf.WriteString("26=" + bool2str(val) + " ")
+	i += copy(buf[i:], "26=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get27()
-	buf.WriteString("27=" + bool2str(val) + " ")
+	i += copy(buf[i:], "27=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get28()
-	buf.WriteString("28=" + bool2str(val) + " ")
+	i += copy(buf[i:], "28=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get29()
-	buf.WriteString("29=" + bool2str(val) + " ")
+	i += copy(buf[i:], "29=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get30()
-	buf.WriteString("30=" + bool2str(val) + " ")
+	i += copy(buf[i:], "30=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get31()
-	buf.WriteString("31=" + bool2str(val) + " ")
+	i += copy(buf[i:], "31=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get32()
-	buf.WriteString("32=" + bool2str(val) + " ")
+	i += copy(buf[i:], "32=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get33()
-	buf.WriteString("33=" + bool2str(val) + " ")
+	i += copy(buf[i:], "33=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get34()
-	buf.WriteString("34=" + bool2str(val) + " ")
+	i += copy(buf[i:], "34=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get35()
-	buf.WriteString("35=" + bool2str(val) + " ")
+	i += copy(buf[i:], "35=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get36()
-	buf.WriteString("36=" + bool2str(val) + " ")
+	i += copy(buf[i:], "36=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get37()
-	buf.WriteString("37=" + bool2str(val) + " ")
+	i += copy(buf[i:], "37=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get38()
-	buf.WriteString("38=" + bool2str(val) + " ")
+	i += copy(buf[i:], "38=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get39()
-	buf.WriteString("39=" + bool2str(val) + " ")
+	i += copy(buf[i:], "39=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get40()
-	buf.WriteString("40=" + bool2str(val) + " ")
+	i += copy(buf[i:], "40=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get41()
-	buf.WriteString("41=" + bool2str(val) + " ")
+	i += copy(buf[i:], "41=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get42()
-	buf.WriteString("42=" + bool2str(val) + " ")
+	i += copy(buf[i:], "42=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get43()
-	buf.WriteString("43=" + bool2str(val) + " ")
+	i += copy(buf[i:], "43=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get44()
-	buf.WriteString("44=" + bool2str(val) + " ")
+	i += copy(buf[i:], "44=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get45()
-	buf.WriteString("45=" + bool2str(val) + " ")
+	i += copy(buf[i:], "45=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get46()
-	buf.WriteString("46=" + bool2str(val) + " ")
+	i += copy(buf[i:], "46=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get47()
-	buf.WriteString("47=" + bool2str(val) + " ")
+	i += copy(buf[i:], "47=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get48()
-	buf.WriteString("48=" + bool2str(val) + " ")
+	i += copy(buf[i:], "48=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get49()
-	buf.WriteString("49=" + bool2str(val) + " ")
+	i += copy(buf[i:], "49=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get50()
-	buf.WriteString("50=" + bool2str(val) + " ")
+	i += copy(buf[i:], "50=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get51()
-	buf.WriteString("51=" + bool2str(val) + " ")
+	i += copy(buf[i:], "51=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get52()
-	buf.WriteString("52=" + bool2str(val) + " ")
+	i += copy(buf[i:], "52=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get53()
-	buf.WriteString("53=" + bool2str(val) + " ")
+	i += copy(buf[i:], "53=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get54()
-	buf.WriteString("54=" + bool2str(val) + " ")
+	i += copy(buf[i:], "54=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get55()
-	buf.WriteString("55=" + bool2str(val) + " ")
+	i += copy(buf[i:], "55=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get56()
-	buf.WriteString("56=" + bool2str(val) + " ")
+	i += copy(buf[i:], "56=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get57()
-	buf.WriteString("57=" + bool2str(val) + " ")
+	i += copy(buf[i:], "57=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get58()
-	buf.WriteString("58=" + bool2str(val) + " ")
+	i += copy(buf[i:], "58=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get59()
-	buf.WriteString("59=" + bool2str(val) + " ")
+	i += copy(buf[i:], "59=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get60()
-	buf.WriteString("60=" + bool2str(val) + " ")
+	i += copy(buf[i:], "60=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get61()
-	buf.WriteString("61=" + bool2str(val) + " ")
+	i += copy(buf[i:], "61=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get62()
-	buf.WriteString("62=" + bool2str(val) + " ")
+	i += copy(buf[i:], "62=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
 	val = f.Get63()
-	buf.WriteString("63=" + bool2str(val) + " ")
+	i += copy(buf[i:], "63=")
+	i += copy(buf[i:], bool2str(val))
+	buf[i] = ' '
+	i++
 
-	buf.Truncate(1)
-	buf.WriteByte('}')
+	buf[i-1] = '}'
+	buf = buf[:i]
 
-	return buf.String()
+	return *(*string)(unsafe.Pointer(&buf))
 }
 
 func bool2str(b bool) string {
diff --git a/vendor/codeberg.org/gruf/go-bitutil/flag.tpl b/vendor/codeberg.org/gruf/go-bitutil/flag.tpl
index 89f881930..ac00bfa97 100644
--- a/vendor/codeberg.org/gruf/go-bitutil/flag.tpl
+++ b/vendor/codeberg.org/gruf/go-bitutil/flag.tpl
@@ -2,14 +2,13 @@ package bitutil
 
 import (
     "strings"
-
-    "codeberg.org/gruf/go-byteutil"
+    "unsafe"
 )
 
 {{ range $idx, $size := . }}
 
 // Flags{{ $size.Size }} is a type-casted unsigned integer with helper
-// methods for easily managing up to {{ $size.Size }} bit flags.
+// methods for easily managing up to {{ $size.Size }} bit-flags.
 type Flags{{ $size.Size }} uint{{ $size.Size }}
 
 // Get will fetch the flag bit value at index 'bit'.
@@ -54,34 +53,58 @@ func (f Flags{{ $size.Size }}) Unset{{ $idx }}() Flags{{ $size.Size }} {
 
 // String returns a human readable representation of Flags{{ $size.Size }}.
 func (f Flags{{ $size.Size }}) String() string {
-    var val bool
-    var buf byteutil.Buffer
+    var (
+        i   int
+        val bool
+        buf []byte
+    )
+
+    // Make a prealloc est. based on longest-possible value
+    const prealloc = 1+(len("false ")*{{ $size.Size }})-1+1
+    buf = make([]byte, prealloc)
+
+    buf[i] = '{'
+    i++
 
-    buf.WriteByte('{')
     {{ range $idx := .Bits }}
     val = f.Get{{ $idx }}()
-    buf.WriteString(bool2str(val) + " ")
+    i += copy(buf[i:], bool2str(val))
+    buf[i] = ' '
+    i++
     {{ end }}
-    buf.Truncate(1)
-    buf.WriteByte('}')
 
-    return buf.String()
+    buf[i-1] = '}'
+    buf = buf[:i]
+
+    return *(*string)(unsafe.Pointer(&buf))
 }
 
 // GoString returns a more verbose human readable representation of Flags{{ $size.Size }}.
 func (f Flags{{ $size.Size }})GoString() string {
-    var val bool
-    var buf byteutil.Buffer
+    var (
+        i   int
+        val bool
+        buf []byte
+    )
+
+    // Make a prealloc est. based on longest-possible value
+    const prealloc = len("bitutil.Flags{{ $size.Size }}{")+(len("{{ sub $size.Size 1 }}=false ")*{{ $size.Size }})-1+1
+    buf = make([]byte, prealloc)
+
+    i += copy(buf[i:], "bitutil.Flags{{ $size.Size }}{")
 
-    buf.WriteString("bitutil.Flags{{ $size.Size }}{")
     {{ range $idx := .Bits }}
     val = f.Get{{ $idx }}()
-    buf.WriteString("{{ $idx }}="+bool2str(val)+" ")
+    i += copy(buf[i:], "{{ $idx }}=")
+    i += copy(buf[i:], bool2str(val))
+    buf[i] = ' '
+    i++
     {{ end }}
-    buf.Truncate(1)
-    buf.WriteByte('}')
+ 
+    buf[i-1] = '}'
+    buf = buf[:i]
 
-    return buf.String()
+    return *(*string)(unsafe.Pointer(&buf))
 }
 
 {{ end }}
diff --git a/vendor/codeberg.org/gruf/go-debug/debug.go b/vendor/codeberg.org/gruf/go-debug/debug.go
index 6b5e56548..e7121390d 100644
--- a/vendor/codeberg.org/gruf/go-debug/debug.go
+++ b/vendor/codeberg.org/gruf/go-debug/debug.go
@@ -4,14 +4,9 @@ import (
 	_debug "runtime/debug"
 )
 
-// DEBUG returns whether debugging is enabled.
-func DEBUG() bool {
-	return debug
-}
-
 // Run will only call fn if DEBUG is enabled.
 func Run(fn func()) {
-	if debug {
+	if DEBUG {
 		fn()
 	}
 }
diff --git a/vendor/codeberg.org/gruf/go-debug/debug_env.go b/vendor/codeberg.org/gruf/go-debug/debug_env.go
index 7ab231b08..4401b9725 100644
--- a/vendor/codeberg.org/gruf/go-debug/debug_env.go
+++ b/vendor/codeberg.org/gruf/go-debug/debug_env.go
@@ -5,5 +5,5 @@ package debug
 
 import "os"
 
-// check if debug env variable is set
-var debug = (os.Getenv("DEBUG") != "")
+// DEBUG returns whether debugging is enabled.
+var DEBUG = (os.Getenv("DEBUG") != "")
diff --git a/vendor/codeberg.org/gruf/go-debug/debug_off.go b/vendor/codeberg.org/gruf/go-debug/debug_off.go
index a7eb9daac..82ef7263e 100644
--- a/vendor/codeberg.org/gruf/go-debug/debug_off.go
+++ b/vendor/codeberg.org/gruf/go-debug/debug_off.go
@@ -3,5 +3,5 @@
 
 package debug
 
-// debug always off.
-const debug = false
+// DEBUG returns whether debugging is enabled.
+const DEBUG = false
diff --git a/vendor/codeberg.org/gruf/go-debug/debug_on.go b/vendor/codeberg.org/gruf/go-debug/debug_on.go
index 744d70178..91edd5fe5 100644
--- a/vendor/codeberg.org/gruf/go-debug/debug_on.go
+++ b/vendor/codeberg.org/gruf/go-debug/debug_on.go
@@ -3,5 +3,5 @@
 
 package debug
 
-// debug always on.
-const debug = true
+// DEBUG returns whether debugging is enabled.
+const DEBUG = true
diff --git a/vendor/codeberg.org/gruf/go-debug/pprof_on.go b/vendor/codeberg.org/gruf/go-debug/pprof_on.go
index a569ab823..4f91aa092 100644
--- a/vendor/codeberg.org/gruf/go-debug/pprof_on.go
+++ b/vendor/codeberg.org/gruf/go-debug/pprof_on.go
@@ -11,7 +11,7 @@ import (
 
 // ServePprof will start an HTTP server serving /debug/pprof only if debug enabled.
 func ServePprof(addr string) error {
-	if !debug {
+	if !DEBUG {
 		// debug disabled in env
 		return nil
 	}
@@ -21,7 +21,7 @@ func ServePprof(addr string) error {
 
 // WithPprof will add /debug/pprof handling (provided by "net/http/pprof") only if debug enabled.
 func WithPprof(handler http.Handler) http.Handler {
-	if !debug {
+	if !DEBUG {
 		// debug disabled in env
 		return handler
 	}
diff --git a/vendor/codeberg.org/gruf/go-runners/pool.go b/vendor/codeberg.org/gruf/go-runners/pool.go
index 16222b2e1..3d9105986 100644
--- a/vendor/codeberg.org/gruf/go-runners/pool.go
+++ b/vendor/codeberg.org/gruf/go-runners/pool.go
@@ -157,6 +157,34 @@ func (pool *WorkerPool) EnqueueCtx(ctx context.Context, fn WorkerFunc) bool {
 	}
 }
 
+// MustEnqueueCtx functionally performs similarly to WorkerPool.EnqueueCtx(), but in the case
+// that the provided <-ctx.Done() is closed, it is passed asynchronously to WorkerPool.Enqueue().
+// Return boolean indicates whether function was executed in time before <-ctx.Done() is closed.
+func (pool *WorkerPool) MustEnqueueCtx(ctx context.Context, fn WorkerFunc) (ok bool) {
+	// Check valid fn
+	if fn == nil {
+		return false
+	}
+
+	select {
+	case <-ctx.Done():
+		// We failed to add this entry to the worker queue before the
+		// incoming context was cancelled. So to ensure processing
+		// we simply queue it asynchronously and return early to caller.
+		go pool.Enqueue(fn)
+		return false
+
+	case <-pool.svc.Done():
+		// Pool ctx cancelled
+		fn(closedctx)
+		return false
+
+	case pool.fns <- fn:
+		// Placed fn in queue
+		return true
+	}
+}
+
 // EnqueueNow attempts Enqueue but returns false if not executed.
 func (pool *WorkerPool) EnqueueNow(fn WorkerFunc) bool {
 	// Check valid fn
diff --git a/vendor/codeberg.org/gruf/go-runners/process.go b/vendor/codeberg.org/gruf/go-runners/process.go
new file mode 100644
index 000000000..908e6edca
--- /dev/null
+++ b/vendor/codeberg.org/gruf/go-runners/process.go
@@ -0,0 +1,75 @@
+package runners
+
+import (
+	"fmt"
+	"sync"
+)
+
+// Processable defines a runnable process with error return
+// that can be passed to a Processor instance for managed running.
+type Processable func() error
+
+// Processor acts similarly to a sync.Once object, except that it is reusable. After
+// the first call to Process(), any further calls before this first has returned will
+// block until the first call has returned, and return the same error. This ensures
+// that only a single instance of it is ever running at any one time.
+type Processor struct {
+	mutex sync.Mutex
+	state uint32
+	wait  sync.WaitGroup
+	err   *error
+}
+
+// Process will process the given function if first-call, else blocking until
+// the first function has returned, returning the same error result.
+func (p *Processor) Process(proc Processable) (err error) {
+	// Acquire state lock.
+	p.mutex.Lock()
+
+	if p.state != 0 {
+		// Already running.
+		//
+		// Get current err ptr.
+		errPtr := p.err
+
+		// Wait until finish.
+		p.mutex.Unlock()
+		p.wait.Wait()
+		return *errPtr
+	}
+
+	// Reset error ptr.
+	p.err = new(error)
+
+	// Set started.
+	p.wait.Add(1)
+	p.state = 1
+	p.mutex.Unlock()
+
+	defer func() {
+		if r := recover(); r != nil {
+			if err != nil {
+				rOld := r // wrap the panic so we don't lose existing returned error
+				r = fmt.Errorf("panic occured after error %q: %v", err.Error(), rOld)
+			}
+
+			// Catch any panics and wrap as error.
+			err = fmt.Errorf("caught panic: %v", r)
+		}
+
+		// Store error.
+		*p.err = err
+
+		// Mark done.
+		p.wait.Done()
+
+		// Set stopped.
+		p.mutex.Lock()
+		p.state = 0
+		p.mutex.Unlock()
+	}()
+
+	// Run process.
+	err = proc()
+	return
+}
diff --git a/vendor/codeberg.org/gruf/go-runners/run.go b/vendor/codeberg.org/gruf/go-runners/run.go
deleted file mode 100644
index 67d19b40c..000000000
--- a/vendor/codeberg.org/gruf/go-runners/run.go
+++ /dev/null
@@ -1,124 +0,0 @@
-package runners
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"time"
-
-	"codeberg.org/gruf/go-atomics"
-)
-
-// FuncRunner provides a means of managing long-running functions e.g. main logic loops.
-type FuncRunner struct {
-	// HandOff is the time after which a blocking function will be considered handed off
-	HandOff time.Duration
-
-	// ErrorHandler is the function that errors are passed to when encountered by the
-	// provided function. This can be used both for logging, and for error filtering
-	ErrorHandler func(err error) error
-
-	svc Service // underlying service to manage start/stop
-	err atomics.Error
-}
-
-// Go will attempt to run 'fn' asynchronously. The provided context is used to propagate requested
-// cancel if FuncRunner.Stop() is called. Any returned error will be passed to FuncRunner.ErrorHandler
-// for filtering/logging/etc. Any blocking functions will be waited on for FuncRunner.HandOff amount of
-// time before considering the function as handed off. Returned bool is success state, i.e. returns true
-// if function is successfully handed off or returns within hand off time with nil error.
-func (r *FuncRunner) Go(fn func(ctx context.Context) error) bool {
-	var has bool
-
-	done := make(chan struct{})
-
-	go func() {
-		var cancelled bool
-
-		has = r.svc.Run(func(ctx context.Context) {
-			// reset error
-			r.err.Store(nil)
-
-			// Run supplied func and set errror if returned
-			if err := Run(func() error { return fn(ctx) }); err != nil {
-				r.err.Store(err)
-			}
-
-			// signal done
-			close(done)
-
-			// Check if cancelled
-			select {
-			case <-ctx.Done():
-				cancelled = true
-			default:
-				cancelled = false
-			}
-		})
-
-		switch has {
-		// returned after starting
-		case true:
-			// Load set error
-			err := r.err.Load()
-
-			// filter out errors due FuncRunner.Stop() being called
-			if cancelled && errors.Is(err, context.Canceled) {
-				// filter out errors from FuncRunner.Stop() being called
-				r.err.Store(nil)
-			} else if err != nil && r.ErrorHandler != nil {
-				// pass any non-nil error to set handler
-				r.err.Store(r.ErrorHandler(err))
-			}
-
-		// already running
-		case false:
-			close(done)
-		}
-	}()
-
-	// get valid handoff to use
-	handoff := r.HandOff
-	if handoff < 1 {
-		handoff = time.Second * 5
-	}
-
-	select {
-	// handed off (long-run successful)
-	case <-time.After(handoff):
-		return true
-
-	// 'fn' returned, check error
-	case <-done:
-		return has
-	}
-}
-
-// Stop will cancel the context supplied to the running function.
-func (r *FuncRunner) Stop() bool {
-	return r.svc.Stop()
-}
-
-// Err returns the last-set error value.
-func (r *FuncRunner) Err() error {
-	return r.err.Load()
-}
-
-// Run will execute the supplied 'fn' catching any panics. Returns either function-returned error or formatted panic.
-func Run(fn func() error) (err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			if e, ok := r.(error); ok {
-				// wrap and preserve existing error
-				err = fmt.Errorf("caught panic: %w", e)
-			} else {
-				// simply create new error fromt iface
-				err = fmt.Errorf("caught panic: %v", r)
-			}
-		}
-	}()
-
-	// run supplied func
-	err = fn()
-	return
-}
diff --git a/vendor/codeberg.org/gruf/go-runners/service.go b/vendor/codeberg.org/gruf/go-runners/service.go
index c019a10f6..8a7c0051a 100644
--- a/vendor/codeberg.org/gruf/go-runners/service.go
+++ b/vendor/codeberg.org/gruf/go-runners/service.go
@@ -9,7 +9,7 @@ import (
 // changes and preventing multiple instances running. Also providing service state information.
 type Service struct {
 	state uint32        // 0=stopped, 1=running, 2=stopping
-	mutex sync.Mutex    // mutext protects overall state changes
+	mutex sync.Mutex    // mutex protects overall state changes
 	wait  sync.Mutex    // wait is used as a single-entity wait-group, only ever locked within 'mutex'
 	ctx   chan struct{} // ctx is the current context for running function (or nil if not running)
 }
@@ -62,6 +62,29 @@ func (svc *Service) GoRun(fn func(context.Context)) bool {
 	return true
 }
 
+// RunWait is functionally the same as .Run(), but blocks until the first instance of .Run() returns.
+func (svc *Service) RunWait(fn func(context.Context)) bool {
+	// Attempt to start the svc
+	ctx, ok := svc.doStart()
+	if !ok {
+		<-ctx // block
+		return false
+	}
+
+	defer func() {
+		// unlock single wait
+		svc.wait.Unlock()
+
+		// ensure stopped
+		_ = svc.Stop()
+	}()
+
+	// Run with context.
+	fn(CancelCtx(ctx))
+
+	return true
+}
+
 // Stop will attempt to stop the service, cancelling the running function's context. Immediately
 // returns false if not running, and true only after Service is fully stopped.
 func (svc *Service) Stop() bool {
@@ -108,28 +131,29 @@ func (svc *Service) doStart() (chan struct{}, bool) {
 	// Protect startup
 	svc.mutex.Lock()
 
-	if svc.state != 0 /* not stopped */ {
-		svc.mutex.Unlock()
-		return nil, false
-	}
-
-	// state started
-	svc.state = 1
-
 	if svc.ctx == nil {
 		// this will only have been allocated
 		// if svc.Done() was already called.
 		svc.ctx = make(chan struct{})
 	}
 
-	// Start the waiter
-	svc.wait.Lock()
-
 	// Take our own ptr
-	// and unlock state
 	ctx := svc.ctx
-	svc.mutex.Unlock()
 
+	if svc.state != 0 {
+		// State was not stopped.
+		svc.mutex.Unlock()
+		return ctx, false
+	}
+
+	// Set started.
+	svc.state = 1
+
+	// Start waiter.
+	svc.wait.Lock()
+
+	// Unlock and return
+	svc.mutex.Unlock()
 	return ctx, true
 }
 
diff --git a/vendor/codeberg.org/gruf/go-sched/scheduler.go b/vendor/codeberg.org/gruf/go-sched/scheduler.go
index df19cf18b..537e588fe 100644
--- a/vendor/codeberg.org/gruf/go-sched/scheduler.go
+++ b/vendor/codeberg.org/gruf/go-sched/scheduler.go
@@ -2,7 +2,6 @@ package sched
 
 import (
 	"context"
-	"runtime"
 	"sort"
 	"sync"
 	"sync/atomic"
@@ -55,11 +54,6 @@ func (sch *Scheduler) Start(gorun func(func())) bool {
 			sch.rgo = func(f func()) { go f() }
 		}
 
-		// Set GC finalizer to ensure scheduler stopped
-		runtime.SetFinalizer(sch, func(sch *Scheduler) {
-			_ = sch.Stop()
-		})
-
 		// Unlock start routine
 		block.Unlock()
 
@@ -80,11 +74,16 @@ func (sch *Scheduler) Stop() bool {
 	return sch.svc.Stop()
 }
 
-// Running will return whether Scheduler is running.
+// Running will return whether Scheduler is running (i.e. NOT stopped / stopping).
 func (sch *Scheduler) Running() bool {
 	return sch.svc.Running()
 }
 
+// Done returns a channel that's closed when Scheduler.Stop() is called.
+func (sch *Scheduler) Done() <-chan struct{} {
+	return sch.svc.Done()
+}
+
 // Schedule will add provided Job to the Scheduler, returning a cancel function.
 func (sch *Scheduler) Schedule(job *Job) (cancel func()) {
 	switch {
@@ -127,20 +126,26 @@ func (sch *Scheduler) Schedule(job *Job) (cancel func()) {
 // run is the main scheduler run routine, which runs for as long as ctx is valid.
 func (sch *Scheduler) run(ctx context.Context) {
 	var (
+		// now stores the current time, and will only be
+		// set when the timer channel is set to be the
+		// 'alwaysticks' channel. this allows minimizing
+		// the number of calls required to time.Now().
+		now time.Time
+
 		// timerset represents whether timer was running
 		// for a particular run of the loop. false means
-		// that tch == neverticks || tch == alwaysticks
+		// that tch == neverticks || tch == alwaysticks.
 		timerset bool
 
-		// timer tick channel (or a never-tick channel)
+		// timer tick channel (or always / never ticks).
 		tch <-chan time.Time
 
 		// timer notifies this main routine to wake when
-		// the job queued needs to be checked for executions
+		// the job queued needs to be checked for executions.
 		timer *time.Timer
 
 		// stopdrain will stop and drain the timer
-		// if it has been running (i.e. timerset == true)
+		// if it has been running (i.e. timerset == true).
 		stopdrain = func() {
 			if timerset && !timer.Stop() {
 				<-timer.C
@@ -148,33 +153,33 @@ func (sch *Scheduler) run(ctx context.Context) {
 		}
 	)
 
-	// Create a stopped timer
+	// Create a stopped timer.
 	timer = time.NewTimer(1)
 	<-timer.C
 
 	for {
-		// Reset timer state
+		// Reset timer state.
 		timerset = false
 
 		if len(sch.jobs) > 0 {
-			// Sort jobs by next occurring
-			sort.Sort(byNext(sch.jobs))
+			// Get now time.
+			now = time.Now()
 
-			// Get execution time
-			now := time.Now()
+			// Sort jobs by next occurring.
+			sort.Sort(byNext(sch.jobs))
 
-			// Get next job time
+			// Get next job time.
 			next := sch.jobs[0].Next()
 
-			// If this job is _just_ about to be ready, we
-			// don't bother sleeping. It's wasted cycles only
-			// sleeping for some obscenely tiny amount of time
-			// we can't guarantee precision for.
+			// If this job is _just_ about to be ready, we don't bother
+			// sleeping. It's wasted cycles only sleeping for some obscenely
+			// tiny amount of time we can't guarantee precision for.
 			if until := next.Sub(now); until <= precision/1e3 {
-				// This job is behind schedule, set to always tick.
+				// This job is behind,
+				// set to always tick.
 				tch = alwaysticks
 			} else {
-				// Reset timer to period
+				// Reset timer to period.
 				timer.Reset(until)
 				tch = timer.C
 				timerset = true
@@ -191,12 +196,14 @@ func (sch *Scheduler) run(ctx context.Context) {
 			return
 
 		// Timer ticked, run scheduled
-		case now := <-tch:
+		case t := <-tch:
 			if !timerset {
-				// alwaysticks returns zero times
-				now = time.Now()
+				// 'alwaysticks' returns zero
+				// times, BUT 'now' will have
+				// been set during above sort.
+				t = now
 			}
-			sch.schedule(now)
+			sch.schedule(t)
 
 		// Received update, handle job/id
 		case v := <-sch.jch: