test(bench): close export-coverage gaps across nine bench harnesses

Audit pass on the AX-11 sweep surfaced 9 files where the bench harness
existed but missed exported funcs / methods on their source file. This
pass brings each up to full surface coverage so the contract gate is
complete.

* slice.go:    + SliceReverse, SliceSorted (iter input)
* runtime.go:  + ServiceStartup, ServiceShutdown (empty Core lifecycle)
* string.go:   + HTMLUnescape, TrimCutset, TrimLeft, TrimRight, NewBuilder
* sync.go:     + SyncMap.Swap, LoadAndDelete, CompareAndSwap,
                  CompareAndDelete, Range, Clear + Once.Reset
* log.go:      + SetLevel, SetOutput, SetRedactKeys, Level.String,
                  Security, NewLogErr, NewLogPanic, LogErr.Log
* path.go:     + PathAbs (already / relative), PathEvalSymlinks,
                  PathGlob, PathWalk, PathWalkDir
* error.go:    + (*Err).Unwrap, AllOperations, StackTrace,
                  FormatStackTrace, ErrorPanic.Reports
* fs.go:       + Fs.Append, ReadStream, EnsureDir, DeleteAll,
                  Rename, NewUnrestricted, ReadDir, ReadFSFile
* api.go:      + HTTPFS, HTTPFileServer, NewHTTPTestTLSServer
                  (HTTPListenAndServe + RemoteAction excluded —
                   network-bound, not unit-benchable)

No source-side perf work this commit — pure surface gating.

Author: Snider

api_bench_test.go

@@ -228,3 +228,38 @@ func BenchmarkAPI_Protocols(b *B) {
 		_ = c.API().Protocols()
 	}
 }
+
+// --- HTTP file server constructors ---
+//
+// HTTPListenAndServe blocks on a network bind, so we can't run it in a
+// bench loop. The pure constructors HTTPFileServer + HTTPFS are cheap
+// adapter-builders worth gating, and NewHTTPTestTLSServer is the TLS
+// twin of NewHTTPTestServer.
+
+func BenchmarkHTTPFS(b *B) {
+	fsys := DirFS(".")
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = HTTPFS(fsys)
+	}
+}
+
+func BenchmarkHTTPFileServer(b *B) {
+	root := HTTPFS(DirFS("."))
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = HTTPFileServer(root)
+	}
+}
+
+func BenchmarkNewHTTPTestTLSServer(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		srv := NewHTTPTestTLSServer(apiBenchHandler)
+		srv.Close()
+	}
+}
+
+// HTTPListenAndServe + RemoteAction are not benched — they bind a real
+// socket / make a real outbound HTTP call. A unit-bench cannot do that
+// deterministically. They are exercised end-to-end in api_test.go.

error_bench_test.go

@@ -162,5 +162,58 @@ func BenchmarkErr_ErrorJoin_Two(b *B) {
 	}
 }
 
+// --- (*Err).Unwrap ---
+
+func BenchmarkErr_Unwrap(b *B) {
+	b.ReportAllocs()
+	leaf := errCoreLeaf.(*Err)
+	for i := 0; i < b.N; i++ {
+		errSinkErr = leaf.Unwrap()
+	}
+}
+
+// --- AllOperations / StackTrace / FormatStackTrace ---
+
+func BenchmarkErr_AllOperations_Iter(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		count := 0
+		for range AllOperations(errCoreDeep) {
+			count++
+		}
+		errSinkBool = count > 0
+	}
+}
+
+func BenchmarkErr_StackTrace_Deep(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		stack := StackTrace(errCoreDeep)
+		errSinkBool = len(stack) > 0
+	}
+}
+
+func BenchmarkErr_FormatStackTrace_Deep(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		errSinkStr = FormatStackTrace(errCoreDeep)
+	}
+}
+
+// --- ErrorPanic surface ---
+//
+// Recover / SafeGo would require triggering a panic per iteration, which
+// is far too costly to bench meaningfully — and not the hot path.
+// Reports() is the inspection accessor — that is benchable.
+
+func BenchmarkErr_ErrorPanic_Reports(b *B) {
+	c := New()
+	ep := c.Error()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = ep.Reports(10)
+	}
+}
+
 // Quiet unused-imports for "testing" — used implicitly via core.B alias chain.
 var _ = testing.Short

fs_bench_test.go

@@ -221,3 +221,96 @@ func BenchmarkFs_WriteAtomic_1KB(b *B) {
 		fsSinkResult = fs.WriteAtomic("w.bin", content)
 	}
 }
+
+// --- Append / Stream ---
+
+func BenchmarkFs_Append_Small(b *B) {
+	fs := fsBenchFixture(b, map[string]int{"appendme.txt": 0})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		fsSinkResult = fs.Append("appendme.txt")
+		if fsSinkResult.OK {
+			CloseStream(fsSinkResult.Value)
+		}
+	}
+}
+
+func BenchmarkFs_ReadStream(b *B) {
+	fs := fsBenchFixture(b, map[string]int{"stream.bin": 4096})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		fsSinkResult = fs.ReadStream("stream.bin")
+		if fsSinkResult.OK {
+			CloseStream(fsSinkResult.Value)
+		}
+	}
+}
+
+// --- EnsureDir / DeleteAll / Rename ---
+
+func BenchmarkFs_EnsureDir_Exists(b *B) {
+	fs := fsBenchFixture(b, map[string]int{})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		fsSinkResult = fs.EnsureDir("models")
+	}
+}
+
+func BenchmarkFs_EnsureDir_Create(b *B) {
+	fs := fsBenchFixture(b, map[string]int{})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		// Cycle the same dir so the bench captures the make-then-noop floor.
+		fsSinkResult = fs.EnsureDir("ephemeral")
+	}
+}
+
+func BenchmarkFs_DeleteAll(b *B) {
+	fs := fsBenchFixture(b, map[string]int{})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		fs.EnsureDir("nuked")
+		fsSinkResult = fs.DeleteAll("nuked")
+	}
+}
+
+func BenchmarkFs_Rename(b *B) {
+	fs := fsBenchFixture(b, map[string]int{"rename-src.bin": 16})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		fsSinkResult = fs.Rename("rename-src.bin", "rename-dst.bin")
+		if fsSinkResult.OK {
+			// Cycle back so the next iteration has the src again.
+			fs.Rename("rename-dst.bin", "rename-src.bin")
+		}
+	}
+}
+
+// --- NewUnrestricted ---
+
+func BenchmarkFs_NewUnrestricted(b *B) {
+	parent := fsBenchFixture(b, map[string]int{})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = parent.NewUnrestricted()
+	}
+}
+
+// --- ReadDir / ReadFSFile (the embed-side helpers) ---
+
+func BenchmarkFs_ReadDir_FS(b *B) {
+	fsys := DirFS(".")
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		fsSinkResult = ReadDir(fsys, ".")
+	}
+}
+
+func BenchmarkFs_ReadFSFile(b *B) {
+	fs := fsBenchFixture(b, map[string]int{"r.bin": 1024})
+	fsys := DirFS(fs.Root())
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		fsSinkResult = ReadFSFile(fsys, "r.bin")
+	}
+}

log_bench_test.go

@@ -100,3 +100,76 @@ func BenchmarkLog_PackageInfo_BelowThreshold(b *B) {
 		Info("agent ready", "host", "homelab.lan")
 	}
 }
+
+// --- Setters (mutex-gated, no formatting) ---
+
+func BenchmarkLog_SetLevel(b *B) {
+	l := logBenchFixture(LevelInfo)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		l.SetLevel(LevelInfo)
+	}
+}
+
+func BenchmarkLog_SetOutput(b *B) {
+	l := logBenchFixture(LevelInfo)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		l.SetOutput(io.Discard)
+	}
+}
+
+func BenchmarkLog_SetRedactKeys(b *B) {
+	l := logBenchFixture(LevelInfo)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		l.SetRedactKeys("token", "authorization", "cookie")
+	}
+}
+
+// --- Level.String ---
+
+func BenchmarkLog_LevelString(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = LevelInfo.String()
+	}
+}
+
+// --- Security path (formatter shared with Error) ---
+
+func BenchmarkLog_Security(b *B) {
+	l := logBenchFixture(LevelError)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		l.Security("entitlement.denied", "action", "process.run", "user", "darbs")
+	}
+}
+
+// --- LogErr / LogPanic ---
+
+func BenchmarkLog_NewLogErr(b *B) {
+	l := logBenchFixture(LevelError)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = NewLogErr(l)
+	}
+}
+
+func BenchmarkLog_NewLogPanic(b *B) {
+	l := logBenchFixture(LevelError)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = NewLogPanic(l)
+	}
+}
+
+func BenchmarkLog_LogErr_Log(b *B) {
+	l := logBenchFixture(LevelError)
+	logger := NewLogErr(l)
+	err := E("bench.LogErr", "synthetic", nil)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		logger.Log(err)
+	}
+}

path_bench_test.go

@@ -131,3 +131,67 @@ func BenchmarkPathToSlash(b *B) {
 		pathSinkString = PathToSlash("/home/agent/models")
 	}
 }
+
+// --- Filesystem-aware (Abs / EvalSymlinks / Glob / Walk*) ---
+//
+// These touch syscalls, so they are slower than the pure-string ops
+// above. The bench harness gates the contract — slowdowns from a Core
+// reroute show up here.
+
+func BenchmarkPathAbs_Already(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		pathSinkResult = PathAbs("/already/absolute/path")
+	}
+}
+
+func BenchmarkPathAbs_Relative(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		pathSinkResult = PathAbs("relative/path")
+	}
+}
+
+func BenchmarkPathEvalSymlinks_RealDir(b *B) {
+	// /tmp is real on every dev box and has no surprising depth.
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		pathSinkResult = PathEvalSymlinks("/tmp")
+	}
+}
+
+func BenchmarkPathGlob_NoMatch(b *B) {
+	pat := "/tmp/__core-bench-no-match-*.gguf"
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		pathSinkStrings = PathGlob(pat)
+	}
+}
+
+func BenchmarkPathWalk_TmpShallow(b *B) {
+	root := "/tmp"
+	noop := func(_ string, _ FsFileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+		return PathSkipDir
+	}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = PathWalk(root, noop)
+	}
+}
+
+func BenchmarkPathWalkDir_TmpShallow(b *B) {
+	root := "/tmp"
+	noop := func(_ string, _ FsDirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		return PathSkipDir
+	}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = PathWalkDir(root, noop)
+	}
+}

runtime_bench_test.go

@@ -118,3 +118,27 @@ func BenchmarkRuntime_ServiceName(b *B) {
 		runtimeSinkString = r.ServiceName()
 	}
 }
+
+// --- Service lifecycle (startup + shutdown round-trip on empty Core) ---
+//
+// Service registration is a one-shot per process — but the cost matters
+// during test loops + multi-Core consumers. Empty Core is the floor;
+// adds a startable to time the iteration overhead the dispatcher pays.
+
+func BenchmarkServiceStartup_Empty(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		c := New()
+		runtimeSinkRuntimeRes = c.ServiceStartup(Background(), nil)
+		c.ServiceShutdown(Background())
+	}
+}
+
+func BenchmarkServiceShutdown_Empty(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		c := New()
+		c.ServiceStartup(Background(), nil)
+		runtimeSinkRuntimeRes = c.ServiceShutdown(Background())
+	}
+}

slice_bench_test.go

@@ -167,3 +167,28 @@ func BenchmarkSliceFlatMap(b *B) {
 		_ = SliceFlatMap(src, func(n int) []int { return []int{n, n * 2, n * 3} })
 	}
 }
+
+// --- Reverse / Sorted ---
+
+func BenchmarkSliceReverse_Medium(b *B) {
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		s := SliceClone(benchSliceMedium)
+		SliceReverse(s)
+	}
+}
+
+func BenchmarkSliceSorted_Iter(b *B) {
+	src := benchSliceMedium
+	seq := Seq[int](func(yield func(int) bool) {
+		for _, v := range src {
+			if !yield(v) {
+				return
+			}
+		}
+	})
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = SliceSorted(seq)
+	}
+}