test(bench): AX-11 harnesses for int/encode/format/unicode/result/context/reflect

Wave A of the missing-bench sweep — seven primitive files covered.
All are stdlib passthroughs; the harnesses lock the contract floor so
a Core reroute can't slow them silently.

* int.go      — Atoi/Itoa/FormatInt/FormatUint/ParseInt
* encode.go   — Hex + Base64 (std + URL) encode/decode at 16B + 1KB
* format.go   — Sprint/Sprintf/Sprintln/Print/Errorf (with %w wrap)
* unicode.go  — IsLetter/IsDigit/IsSpace/IsUpper/IsLower + ToUpper/ToLower
                (ASCII + non-ASCII paths)
* result.go   — Ok/Fail/ResultOf/Error/Code/Or/Must/Cast/MustCast/Try
* context.go  — Background/TODO/WithCancel/WithTimeout/WithDeadline/
                WithValue + Value lookup
* reflect.go  — TypeOf/ValueOf/Kind/DeepEqual/Zero across int/struct/
                slice/map fixtures

Floor numbers on Apple M3 Ultra captured in commit message via
'go test -bench=. -benchmem'.

Author: Snider

context_bench_test.go

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: EUPL-1.2
+
+// Benchmarks for the context primitives in context.go.
+// Per AX-11 — Background / TODO / WithCancel / WithTimeout / WithValue
+// are called by every Action handler and Service lifecycle entry point.
+// Bare passthroughs to context but the bench harness gates the contract.
+//
+// Run:    go test -bench='BenchmarkCtx' -benchmem -run='^$' .
+
+package core_test
+
+import (
+	. "dappco.re/go"
+)
+
+// Sinks defeat compiler DCE.
+var (
+	ctxSinkContext Context
+	ctxSinkCancel  CancelFunc
+	ctxSinkAny     any
+)
+
+type ctxKey struct{}
+
+// --- Roots ---
+
+func BenchmarkCtx_Background(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ctxSinkContext = Background()
+	}
+}
+
+func BenchmarkCtx_TODO(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ctxSinkContext = TODO()
+	}
+}
+
+// --- Cancellable variants ---
+//
+// WithCancel + WithTimeout + WithDeadline allocate a child ctx node
+// each call. The cancel func must be invoked to release the goroutine
+// the runtime starts behind it — otherwise the bench leaks one per iter.
+
+func BenchmarkCtx_WithCancel(b *B) {
+	parent := Background()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ctxSinkContext, ctxSinkCancel = WithCancel(parent)
+		ctxSinkCancel()
+	}
+}
+
+func BenchmarkCtx_WithTimeout(b *B) {
+	parent := Background()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ctxSinkContext, ctxSinkCancel = WithTimeout(parent, 1*Second)
+		ctxSinkCancel()
+	}
+}
+
+func BenchmarkCtx_WithDeadline(b *B) {
+	parent := Background()
+	deadline := Now().Add(1 * Second)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ctxSinkContext, ctxSinkCancel = WithDeadline(parent, deadline)
+		ctxSinkCancel()
+	}
+}
+
+// --- Values ---
+
+func BenchmarkCtx_WithValue(b *B) {
+	parent := Background()
+	k := ctxKey{}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ctxSinkContext = WithValue(parent, k, "req-12345")
+	}
+}
+
+func BenchmarkCtx_Value_Lookup(b *B) {
+	k := ctxKey{}
+	ctx := WithValue(Background(), k, "req-12345")
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ctxSinkAny = ctx.Value(k)
+	}
+}

encode_bench_test.go

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: EUPL-1.2
+
+// Benchmarks for the encoding primitives in encode.go.
+// Per AX-11 — hex + base64 are on every fingerprint emit, every API
+// auth-header build, every model-hash compare, every keys.Pack write.
+// The wrappers are encoding/{hex,base64} passthroughs; the bench
+// harness gates the contract so a Core reroute can't slow them silently.
+//
+// Run:    go test -bench='BenchmarkEncode' -benchmem -run='^$' .
+
+package core_test
+
+import (
+	. "dappco.re/go"
+)
+
+// Sinks defeat compiler DCE.
+var (
+	encodeSinkString string
+	encodeSinkResult Result
+)
+
+// --- Fixtures ---
+//
+// 16-byte payload mirrors SHA-256 truncated or a small auth token.
+// 1KB payload covers larger blobs (model header chunk, jwt body).
+
+var (
+	encodeBytes16 = []byte("aaaaaaaaaaaaaaaa")
+	encodeBytes1K = func() []byte {
+		out := make([]byte, 1024)
+		for i := range out {
+			out[i] = byte('a' + i%26)
+		}
+		return out
+	}()
+)
+
+// --- Hex ---
+
+func BenchmarkEncode_HexEncode_16B(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkString = HexEncode(encodeBytes16)
+	}
+}
+
+func BenchmarkEncode_HexEncode_1KB(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkString = HexEncode(encodeBytes1K)
+	}
+}
+
+func BenchmarkEncode_HexDecode_16B(b *B) {
+	encoded := HexEncode(encodeBytes16)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkResult = HexDecode(encoded)
+	}
+}
+
+func BenchmarkEncode_HexDecode_1KB(b *B) {
+	encoded := HexEncode(encodeBytes1K)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkResult = HexDecode(encoded)
+	}
+}
+
+// --- Base64 std ---
+
+func BenchmarkEncode_Base64Encode_16B(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkString = Base64Encode(encodeBytes16)
+	}
+}
+
+func BenchmarkEncode_Base64Encode_1KB(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkString = Base64Encode(encodeBytes1K)
+	}
+}
+
+func BenchmarkEncode_Base64Decode_16B(b *B) {
+	encoded := Base64Encode(encodeBytes16)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkResult = Base64Decode(encoded)
+	}
+}
+
+func BenchmarkEncode_Base64Decode_1KB(b *B) {
+	encoded := Base64Encode(encodeBytes1K)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkResult = Base64Decode(encoded)
+	}
+}
+
+// --- Base64 url ---
+
+func BenchmarkEncode_Base64URLEncode_16B(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkString = Base64URLEncode(encodeBytes16)
+	}
+}
+
+func BenchmarkEncode_Base64URLDecode_16B(b *B) {
+	encoded := Base64URLEncode(encodeBytes16)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		encodeSinkResult = Base64URLDecode(encoded)
+	}
+}

format_bench_test.go

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: EUPL-1.2
+
+// Benchmarks for the formatting primitives in format.go.
+// Per AX-11 — Sprintf is on every error message, every log key=val
+// pair, every CLI output line. Bare passthroughs to fmt but the bench
+// harness gates the contract so a Core reroute can't slow them.
+//
+// Run:    go test -bench='BenchmarkFormat' -benchmem -run='^$' .
+
+package core_test
+
+import (
+	"bytes"
+
+	. "dappco.re/go"
+)
+
+// Sinks defeat compiler DCE.
+var (
+	formatSinkString string
+	formatSinkErr    error
+)
+
+// --- Sprint ---
+
+func BenchmarkFormat_Sprint_OneArg(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		formatSinkString = Sprint(42)
+	}
+}
+
+func BenchmarkFormat_Sprint_ThreeArgs(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		formatSinkString = Sprint("agent", "ready", 9000)
+	}
+}
+
+// --- Sprintf ---
+
+func BenchmarkFormat_Sprintf_Verbs(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		formatSinkString = Sprintf("%s connected on %d", "homelab", 9000)
+	}
+}
+
+func BenchmarkFormat_Sprintf_KeyVal(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		formatSinkString = Sprintf("%v=%q", "key", "value")
+	}
+}
+
+// --- Sprintln ---
+
+func BenchmarkFormat_Sprintln(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		formatSinkString = Sprintln("agent", "ready")
+	}
+}
+
+// --- Print to a buffer (writer-mediated, avoids stdout in bench) ---
+
+func BenchmarkFormat_Print_Buffer(b *B) {
+	var buf bytes.Buffer
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		buf.Reset()
+		Print(&buf, "port: %d", 9000)
+	}
+}
+
+// --- Errorf ---
+
+func BenchmarkFormat_Errorf_NoWrap(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		formatSinkErr = Errorf("connect %s failed", "homelab")
+	}
+}
+
+func BenchmarkFormat_Errorf_Wrap(b *B) {
+	cause := NewError("connection refused")
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		formatSinkErr = Errorf("connect %s: %w", "homelab", cause)
+	}
+}

int_bench_test.go

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: EUPL-1.2
+
+// Benchmarks for the integer conversion primitives in int.go.
+// Per AX-11 — Atoi / Itoa / ParseInt / FormatInt land on every config
+// parse, every HTTP query-string read, every protocol-port handler.
+// These are strconv passthroughs but the bench harness gates the
+// contract: if a Core reroute slows them down, the regression surfaces
+// against a published floor.
+//
+// Run:    go test -bench='BenchmarkInt' -benchmem -run='^$' .
+
+package core_test
+
+import (
+	. "dappco.re/go"
+)
+
+// Sinks defeat compiler DCE.
+var (
+	intSinkResult Result
+	intSinkString string
+)
+
+// --- Atoi / Itoa ---
+
+func BenchmarkInt_Atoi(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkResult = Atoi("42")
+	}
+}
+
+func BenchmarkInt_Atoi_Bad(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkResult = Atoi("not-a-number")
+	}
+}
+
+func BenchmarkInt_Itoa(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkString = Itoa(123456)
+	}
+}
+
+// --- FormatInt / FormatUint ---
+
+func BenchmarkInt_FormatInt_Decimal(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkString = FormatInt(1234567890, 10)
+	}
+}
+
+func BenchmarkInt_FormatInt_Hex(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkString = FormatInt(255, 16)
+	}
+}
+
+func BenchmarkInt_FormatUint_Hex(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkString = FormatUint(0xdeadbeef, 16)
+	}
+}
+
+// --- ParseInt ---
+
+func BenchmarkInt_ParseInt_Hex(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkResult = ParseInt("deadbeef", 16, 64)
+	}
+}
+
+func BenchmarkInt_ParseInt_Decimal(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		intSinkResult = ParseInt("1234567890", 10, 64)
+	}
+}