Day 075 — 2026-10-15 | ミドルウェア設計パターン: 応答後の仕事を「止めずに止める」——Detach を (*Edge).Go に育て、srv.Shutdown → 仕事の待ち → 期限で切る、の順を Serve の中に固定する（逆順・RegisterOnShutdown・ErrServerClosed で抜ける、の 3 通りは 50 件の監査を 1 件も残さなかった）

止める側には 2 つの「入口」があります。HTTP の入口（新しい接続）と、応答後の仕事の入口（Go）。仕事の入口を閉じてよいのは、仕事を生む者（処理中の要求）がいなくなった後です。順番を逆にすると、まだ処理中の要求が Go を呼んだ瞬間に断られます。そして「いなくなった」を確かめる手段は srv.Shutdown の戻りだけです。

• 数え方: WaitGroup は「Wait の後に 0 から Add するな」という約束があり、「閉じたか」の確認と Add の間に隙間ができる。sync.Mutex で「閉じたか」と「何本走っているか」を同じ鍵で守り、0 になったら channel を閉じる
• 仕事の ctx: WithoutCancel（値を残して cancel を外す）→ WithCancelCause（停止で切るため）→ WithTimeoutCause（期限）。停止の合図は Edge が持つ 1 つの ctx にし、context.AfterFunc で各仕事の cancel につなぐ。仕事が終わったら AfterFunc の登録を外す
• 期限: goroutine は外から止められない。切った後に少しだけ待ち、それでも残る数を error で報告する
• Serve: srv.Serve(ln) を goroutine で走らせ、ctx.Done() を待つ。止める期限は終わった ctx から作らない（WithoutCancel してから WithTimeout）。srv.Shutdown が期限切れなら srv.Close() で残った接続を切る

📋 コピーfunc (e *Edge) Go(ctx context.Context, timeout time.Duration, name string, fn func(context.Context) error) error {
	e.mu.Lock()
	if e.closing { e.mu.Unlock(); /* ログ */ return ErrClosed }
	if e.running >= e.max { e.mu.Unlock(); /* ログ */ return ErrBusy }
	e.running++                    // 同じ鍵の中で
	e.mu.Unlock()
	jctx, cancel := context.WithCancelCause(context.WithoutCancel(ctx))
	jctx, cancelT := context.WithTimeoutCause(jctx, timeout, ErrTimeout)
	unhook := context.AfterFunc(e.stop, func() { cancel(ErrCut) })
	go func() {
		defer func() { /* recover・cause を読む・unhook・cancel・ログ・e.finish() */ }()
		err = fn(jctx)
	}()
	return nil
}

func (e *Edge) Serve(ctx context.Context, srv *http.Server, ln net.Listener, grace time.Duration) error {
	go func() { errc <- srv.Serve(ln) }()
	<-ctx.Done()
	sctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), grace)
	srv.Shutdown(sctx)   // 1. 要求を待つ（要求の中の Go はまだ受ける）
	<-errc
	return e.Shutdown(sctx) // 2. 仕事を待つ。期限なら切る
}

📋 コピーpackage edge_test

import (
	"context"
	"errors"
	"io"
	"log/slog"
	"net"
	"net/http"
	"runtime"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"d75/edge"
)

// ---- テスト用の道具 ----

type ridKey struct{}

func withRID(ctx context.Context, id string) context.Context {
	return context.WithValue(ctx, ridKey{}, id)
}

// rec は slog.Handler。ctx の request_id を鍵として足して覚える（Day 072 の LogHandler の代わり）。
type rec struct {
	mu   sync.Mutex
	recs []map[string]string
}

func (h *rec) Enabled(context.Context, slog.Level) bool { return true }
func (h *rec) WithAttrs([]slog.Attr) slog.Handler       { return h }
func (h *rec) WithGroup(string) slog.Handler            { return h }
func (h *rec) Handle(ctx context.Context, r slog.Record) error {
	m := map[string]string{"msg": r.Message, "level": r.Level.String()}
	if id, ok := ctx.Value(ridKey{}).(string); ok {
		m["request_id"] = id
	}
	r.Attrs(func(a slog.Attr) bool { m[a.Key] = a.Value.String(); return true })
	h.mu.Lock()
	h.recs = append(h.recs, m)
	h.mu.Unlock()
	return nil
}
func (h *rec) find(msg string) []map[string]string {
	h.mu.Lock()
	defer h.mu.Unlock()
	var out []map[string]string
	for _, m := range h.recs {
		if m["msg"] == msg {
			out = append(out, m)
		}
	}
	return out
}
func (h *rec) count() int { h.mu.Lock(); defer h.mu.Unlock(); return len(h.recs) }

func newEdge(t *testing.T, max int) (*edge.Edge, *rec) {
	t.Helper()
	h := &rec{}
	e, err := edge.New(edge.Config{Logger: h, MaxJobs: max})
	if err != nil {
		t.Fatal(err)
	}
	return e, h
}

func shutdownNow(t *testing.T, e *edge.Edge) {
	t.Helper()
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	if err := e.Shutdown(ctx); err != nil {
		t.Fatalf("Shutdown: %v", err)
	}
}

// ---- G1〜G13 ----

// G1: Logger と MaxJobs が無ければ、1 回の New で 2 つまとめて error。
func TestG1_NewFailsFastWithAllErrors(t *testing.T) {
	_, err := edge.New(edge.Config{})
	if err == nil {
		t.Fatal("New(Config{}) succeeded")
	}
	for _, want := range []string{"Logger", "MaxJobs"} {
		if !strings.Contains(err.Error(), want) {
			t.Errorf("error %q does not mention %s", err, want)
		}
	}
	if _, err := edge.New(edge.Config{Logger: &rec{}, MaxJobs: -1}); err == nil {
		t.Error("MaxJobs=-1 accepted")
	}
}

// G2: 仕事の ctx は値を残し、要求の cancel を外し、timeout の期限を持つ。timeout<=0 は panic。
func TestG2_JobContext(t *testing.T) {
	e, _ := newEdge(t, 4)
	req, cancelReq := context.WithCancel(withRID(context.Background(), "r-2"))
	type obs struct {
		rid      any
		errAfter error
		deadline time.Duration
		ok       bool
	}
	got := make(chan obs, 1)
	started := make(chan struct{})
	err := e.Go(req, 300*time.Millisecond, "g2", func(ctx context.Context) error {
		close(started)
		time.Sleep(30 * time.Millisecond) // この間に要求が終わる
		dl, ok := ctx.Deadline()
		got <- obs{ctx.Value(ridKey{}), ctx.Err(), time.Until(dl), ok}
		return nil
	})
	if err != nil {
		t.Fatal(err)
	}
	<-started
	cancelReq() // ServeHTTP が戻ったのと同じ
	o := <-got
	if o.rid != "r-2" {
		t.Errorf("value lost: %v", o.rid)
	}
	if o.errAfter != nil {
		t.Errorf("job ctx cancelled with request: %v", o.errAfter)
	}
	if !o.ok || o.deadline <= 0 || o.deadline > 300*time.Millisecond {
		t.Errorf("deadline: ok=%v left=%v", o.ok, o.deadline)
	}
	func() {
		defer func() {
			if recover() == nil {
				t.Error("timeout=0 did not panic")
			}
		}()
		e.Go(req, 0, "zero", func(context.Context) error { return nil })
	}()
	shutdownNow(t, e)
}

// G3: 期限切れは cause=ErrTimeout で 1 行、request_id 付き。
func TestG3_TimeoutLoggedWithCause(t *testing.T) {
	e, h := newEdge(t, 4)
	e.Go(withRID(context.Background(), "r-3"), 20*time.Millisecond, "slow", func(ctx context.Context) error {
		<-ctx.Done()
		if !errors.Is(context.Cause(ctx), edge.ErrTimeout) {
			t.Errorf("cause = %v", context.Cause(ctx))
		}
		return ctx.Err()
	})
	shutdownNow(t, e)
	l := h.find("after-response job failed")
	if len(l) != 1 {
		t.Fatalf("failed lines = %d", len(l))
	}
	if l[0]["request_id"] != "r-3" || !strings.Contains(l[0]["cause"], "timed out") || l[0]["job"] != "slow" {
		t.Errorf("line = %v", l[0])
	}
}

// G4: 失敗は 1 行（request_id 付き）、成功は 0 行。
func TestG4_ErrorOnceSuccessSilent(t *testing.T) {
	e, h := newEdge(t, 4)
	ctx := withRID(context.Background(), "r-4")
	e.Go(ctx, time.Second, "ok", func(context.Context) error { return nil })
	e.Go(ctx, time.Second, "bad", func(context.Context) error { return errors.New("audit write: 503") })
	shutdownNow(t, e)
	if n := h.count(); n != 1 {
		t.Fatalf("log lines = %d, want 1", n)
	}
	l := h.find("after-response job failed")
	if len(l) != 1 || l[0]["request_id"] != "r-4" || l[0]["err"] != "audit write: 503" || l[0]["cause"] != "" {
		t.Errorf("line = %v", l)
	}
}

// G5: panic はプロセスを落とさず、request_id・値・stack 付きで 1 行。数も戻る。
func TestG5_PanicRecovered(t *testing.T) {
	e, h := newEdge(t, 1)
	e.Go(withRID(context.Background(), "r-5"), time.Second, "boom", func(context.Context) error {
		var m map[string]int
		m["x"] = 1 // nil map への書き込み
		return nil
	})
	shutdownNow(t, e) // running が戻らなければここで期限切れ
	l := h.find("after-response job panicked")
	if len(l) != 1 || l[0]["request_id"] != "r-5" ||
		!strings.Contains(l[0]["panic"], "nil map") || !strings.Contains(l[0]["stack"], "TestG5") {
		t.Errorf("line = %v", l)
	}
}

// G6: 上限を超えた Go は ErrBusy で始めず、ログ 1 行。空いたらまた受ける。
func TestG6_MaxJobs(t *testing.T) {
	e, h := newEdge(t, 2)
	release := make(chan struct{})
	block := func(context.Context) error { <-release; return nil }
	ctx := withRID(context.Background(), "r-6")
	for i := 0; i < 2; i++ {
		if err := e.Go(ctx, time.Second, "block", block); err != nil {
			t.Fatal(err)
		}
	}
	var ran atomic.Bool
	if err := e.Go(ctx, time.Second, "third", func(context.Context) error { ran.Store(true); return nil }); !errors.Is(err, edge.ErrBusy) {
		t.Fatalf("third Go err = %v", err)
	}
	close(release)
	deadline := time.Now().Add(time.Second)
	for {
		if err := e.Go(ctx, time.Second, "after", func(context.Context) error { return nil }); err == nil {
			break
		}
		if time.Now().After(deadline) {
			t.Fatal("slot never freed")
		}
		time.Sleep(time.Millisecond)
	}
	shutdownNow(t, e)
	if ran.Load() {
		t.Error("rejected job ran")
	}
	if l := h.find("after-response job rejected"); len(l) < 1 || l[0]["reason"] != "busy" || l[0]["request_id"] != "r-6" {
		t.Errorf("rejected line = %v", l)
	}
}

// G7: Shutdown は走っている仕事が終わるまで戻らない。
func TestG7_ShutdownWaits(t *testing.T) {
	e, _ := newEdge(t, 4)
	var done atomic.Bool
	e.Go(context.Background(), time.Second, "w", func(context.Context) error {
		time.Sleep(80 * time.Millisecond)
		done.Store(true)
		return nil
	})
	start := time.Now()
	shutdownNow(t, e)
	if !done.Load() {
		t.Error("Shutdown returned before job finished")
	}
	if d := time.Since(start); d < 70*time.Millisecond {
		t.Errorf("Shutdown took %v", d)
	}
}

// G8: Shutdown の後の Go は ErrClosed で、fn は走らない。
func TestG8_GoAfterShutdown(t *testing.T) {
	e, h := newEdge(t, 4)
	shutdownNow(t, e)
	var ran atomic.Bool
	err := e.Go(withRID(context.Background(), "r-8"), time.Second, "late", func(context.Context) error { ran.Store(true); return nil })
	if !errors.Is(err, edge.ErrClosed) {
		t.Fatalf("err = %v", err)
	}
	time.Sleep(10 * time.Millisecond)
	if ran.Load() {
		t.Error("job ran after shutdown")
	}
	if l := h.find("after-response job rejected"); len(l) != 1 || l[0]["reason"] != "closing" || l[0]["request_id"] != "r-8" {
		t.Errorf("line = %v", l)
	}
	shutdownNow(t, e) // 2 回目も nil
}

// G9: 停止の期限で仕事を切る。ctx を見る仕事は cause=ErrCut で戻り、見ない仕事は「まだ走っている」と数える。
func TestG9_DeadlineCuts(t *testing.T) {
	e, h := newEdge(t, 4)
	cutSeen := make(chan error, 1)
	e.Go(context.Background(), time.Minute, "polite", func(ctx context.Context) error {
		<-ctx.Done()
		cutSeen <- context.Cause(ctx)
		return ctx.Err()
	})
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)
	defer cancel()
	err := e.Shutdown(ctx)
	if !errors.Is(err, context.DeadlineExceeded) || !strings.Contains(err.Error(), "cut 1 jobs, 0 still running") {
		t.Fatalf("polite: err = %v", err)
	}
	if c := <-cutSeen; !errors.Is(c, edge.ErrCut) {
		t.Errorf("cause = %v", c)
	}
	if l := h.find("after-response job failed"); len(l) != 1 || !strings.Contains(l[0]["cause"], "cut by shutdown") {
		t.Errorf("failed line = %v", l)
	}

	e2, h2 := newEdge(t, 4)
	release := make(chan struct{})
	defer close(release)
	e2.Go(context.Background(), time.Minute, "rude", func(context.Context) error { <-release; return nil })
	ctx2, cancel2 := context.WithTimeout(context.Background(), 30*time.Millisecond)
	defer cancel2()
	start := time.Now()
	err = e2.Shutdown(ctx2)
	if d := time.Since(start); d > 400*time.Millisecond {
		t.Errorf("rude: Shutdown took %v", d)
	}
	if err == nil || !strings.Contains(err.Error(), "cut 1 jobs, 1 still running") {
		t.Fatalf("rude: err = %v", err)
	}
	if l := h2.find("after-response jobs abandoned"); len(l) != 1 || l[0]["still_running"] != "1" {
		t.Errorf("abandoned line = %v", l)
	}
}

// ---- 本物のサーバーで ----

type server struct {
	e        *edge.Edge
	addr     string
	stop     context.CancelFunc
	served   chan error
	jobsDone atomic.Int64
	jobsAcc  atomic.Int64
	inflight sync.WaitGroup // 要求がハンドラに入ったら Done
}

// startServer: /work は handlerDur 寝てから Go(jobDur) を呼び、200 を返す。
func startServer(t *testing.T, h slog.Handler, handlerDur, jobDur, grace time.Duration) *server {
	t.Helper()
	e, err := edge.New(edge.Config{Logger: h, MaxJobs: 1000})
	if err != nil {
		t.Fatal(err)
	}
	s := &server{e: e, served: make(chan error, 1)}
	mux := http.NewServeMux()
	mux.HandleFunc("GET /work", func(w http.ResponseWriter, r *http.Request) {
		s.inflight.Done()
		time.Sleep(handlerDur)
		if err := e.Go(r.Context(), 5*time.Second, "audit", func(ctx context.Context) error {
			select {
			case <-time.After(jobDur):
				s.jobsDone.Add(1)
				return nil
			case <-ctx.Done():
				return ctx.Err()
			}
		}); err == nil {
			s.jobsAcc.Add(1)
		}
		io.WriteString(w, "ok")
	})
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	s.addr = ln.Addr().String()
	ctx, stop := context.WithCancel(context.Background())
	s.stop = stop
	go func() { s.served <- e.Serve(ctx, &http.Server{Handler: mux}, ln, grace) }()
	return s
}

func (s *server) fire(n int) (codes chan int) {
	codes = make(chan int, n)
	s.inflight.Add(n)
	for i := 0; i < n; i++ {
		go func() {
			c := &http.Client{Transport: &http.Transport{DisableKeepAlives: true}}
			resp, err := c.Get("http://" + s.addr + "/work")
			if err != nil {
				codes <- -1
				return
			}
			io.Copy(io.Discard, resp.Body)
			resp.Body.Close()
			codes <- resp.StatusCode
		}()
	}
	s.inflight.Wait() // 全部ハンドラに入った
	return codes
}

// G10: 処理中の要求が 20 本ある所で止めても、20 本とも 200、受けた仕事 20 件が全部終わってから Serve が戻る。
func TestG10_ServeDrainsRequestsThenJobs(t *testing.T) {
	h := &rec{}
	s := startServer(t, h, 50*time.Millisecond, 100*time.Millisecond, 3*time.Second)
	codes := s.fire(20)
	s.stop() // SIGTERM と同じ
	err := <-s.served
	if err != nil {
		t.Fatalf("Serve: %v", err)
	}
	for i := 0; i < 20; i++ {
		if c := <-codes; c != 200 {
			t.Errorf("status = %d", c)
		}
	}
	if a, d := s.jobsAcc.Load(), s.jobsDone.Load(); a != 20 || d != 20 {
		t.Errorf("accepted=%d done-before-return=%d, want 20/20", a, d)
	}
	if l := h.find("after-response job rejected"); len(l) != 0 {
		t.Errorf("rejected %d jobs", len(l))
	}
}

// G11: 止め始めた後の新しい接続は断られる。
func TestG11_NewConnectionsRefused(t *testing.T) {
	s := startServer(t, &rec{}, 200*time.Millisecond, 0, 3*time.Second)
	codes := s.fire(1)
	s.stop()
	time.Sleep(30 * time.Millisecond) // srv.Shutdown が Listener を閉じるまで
	if _, err := net.DialTimeout("tcp", s.addr, 200*time.Millisecond); err == nil {
		t.Error("new connection accepted during shutdown")
	}
	if c := <-codes; c != 200 {
		t.Errorf("in-flight status = %d", c)
	}
	if err := <-s.served; err != nil {
		t.Fatal(err)
	}
}

// G12: 期限より長い要求があると、Serve は期限で error を返し、仕事は始まらないか切られる。
func TestG12_ServeGraceExpires(t *testing.T) {
	h := &rec{}
	s := startServer(t, h, 400*time.Millisecond, time.Second, 100*time.Millisecond)
	codes := s.fire(1)
	s.stop()
	start := time.Now()
	err := <-s.served
	if !errors.Is(err, context.DeadlineExceeded) {
		t.Fatalf("err = %v", err)
	}
	if d := time.Since(start); d > 400*time.Millisecond {
		t.Errorf("Serve took %v", d)
	}
	<-codes
	time.Sleep(400 * time.Millisecond) // ハンドラが目覚めて Go を呼ぶ
	if s.jobsAcc.Load() != 0 {
		t.Error("job accepted after edge closed")
	}
	if l := h.find("after-response job rejected"); len(l) != 1 || l[0]["reason"] != "closing" {
		t.Errorf("rejected = %v", l)
	}
}

// G13: Go と Shutdown を同時に 500 回ぶつける。Go が nil を返した仕事は、必ず Shutdown が戻る前に終わる。
func TestG13_NoLostJobsUnderRace(t *testing.T) {
	lost := 0
	for i := 0; i < 500; i++ {
		e, _ := newEdge(t, 1000)
		var accepted, finished atomic.Int64
		var wg sync.WaitGroup
		for g := 0; g < 8; g++ {
			wg.Add(1)
			go func() {
				defer wg.Done()
				for k := 0; k < 4; k++ {
					if e.Go(context.Background(), time.Second, "j", func(context.Context) error {
						time.Sleep(time.Millisecond)
						finished.Add(1)
						return nil
					}) == nil {
						accepted.Add(1)
					}
				}
			}()
		}
		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
		err := e.Shutdown(ctx)
		finAtReturn := finished.Load()
		cancel()
		wg.Wait()
		if err != nil {
			t.Fatal(err)
		}
		if a, f := accepted.Load(), finAtReturn; f < a {
			lost += int(a - f)
		}
	}
	if lost != 0 {
		t.Errorf("lost %d accepted jobs (finished after Shutdown returned)", lost)
	}
}

// G14: 期限で止めきれなかった要求は、接続を切って要求の ctx を cancel する（ハンドラが ctx を見ていれば戻れる）。
func TestG14_GraceExpiredCancelsRequests(t *testing.T) {
	e, _ := newEdge(t, 4)
	returned := make(chan time.Time, 1)
	entered := make(chan struct{})
	mux := http.NewServeMux()
	mux.HandleFunc("GET /stream", func(w http.ResponseWriter, r *http.Request) {
		close(entered)
		<-r.Context().Done() // 長い配信。ctx が終わるまで返らない
		returned <- time.Now()
	})
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	ctx, stop := context.WithCancel(context.Background())
	served := make(chan error, 1)
	go func() { served <- e.Serve(ctx, &http.Server{Handler: mux}, ln, 100*time.Millisecond) }()
	go http.Get("http://" + ln.Addr().String() + "/stream")
	<-entered
	stop()
	if err := <-served; !errors.Is(err, context.DeadlineExceeded) {
		t.Fatalf("Serve err = %v", err)
	}
	select {
	case <-returned:
	case <-time.After(time.Second):
		t.Error("handler still running 1s after Serve returned (connection not closed)")
	}
}

// G15: 終わった仕事は停止用の ctx に何も残さない（AfterFunc の登録を外す）。5 万件で保持が 2 MiB 未満。
func TestG15_NoRetentionPerJob(t *testing.T) {
	e, _ := newEdge(t, 100000)
	var ms runtime.MemStats
	runtime.GC()
	runtime.ReadMemStats(&ms)
	before := ms.HeapAlloc
	const n = 50000
	var wg sync.WaitGroup
	wg.Add(n)
	for i := 0; i < n; i++ {
		e.Go(context.Background(), time.Minute, "j", func(context.Context) error { wg.Done(); return nil })
	}
	wg.Wait()
	time.Sleep(50 * time.Millisecond) // 後始末の defer が終わるまで
	runtime.GC()
	runtime.ReadMemStats(&ms)
	grown := int64(ms.HeapAlloc) - int64(before)
	t.Logf("heap grown after %d jobs: %d B (%.1f B/job)", n, grown, float64(grown)/n)
	if grown > 2<<20 {
		t.Errorf("heap grew %d B after %d finished jobs", grown, n)
	}
	shutdownNow(t, e)
}

📋 コピー//go:build measure

package edge_test

import (
	"context"
	"errors"
	"io"
	"net"
	"net/http"
	"runtime"
	"sort"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"d75/edge"
)

// 実測 1: 止める順 4 通り。処理中 50 本（ハンドラ 50 ms → Go(仕事 200 ms)）の所で止める。
func TestMeasureOrder(t *testing.T) {
	const n = 50
	type variant struct {
		name string
		run  func(ctx context.Context, e *edge.Edge, srv *http.Server, ln net.Listener)
	}
	vs := []variant{
		{"A Serve（srv→仕事）", func(ctx context.Context, e *edge.Edge, srv *http.Server, ln net.Listener) {
			e.Serve(ctx, srv, ln, 3*time.Second)
		}},
		{"B 逆順（仕事→srv）", func(ctx context.Context, e *edge.Edge, srv *http.Server, ln net.Listener) {
			go srv.Serve(ln)
			<-ctx.Done()
			sctx, c := context.WithTimeout(context.Background(), 3*time.Second)
			defer c()
			e.Shutdown(sctx)
			srv.Shutdown(sctx)
		}},
		{"C RegisterOnShutdown で仕事を待つ", func(ctx context.Context, e *edge.Edge, srv *http.Server, ln net.Listener) {
			sctx, c := context.WithTimeout(context.Background(), 3*time.Second)
			defer c()
			srv.RegisterOnShutdown(func() { e.Shutdown(sctx) })
			go srv.Serve(ln)
			<-ctx.Done()
			srv.Shutdown(sctx)
		}},
		{"D Serve が ErrServerClosed を返したら main を抜ける", func(ctx context.Context, e *edge.Edge, srv *http.Server, ln net.Listener) {
			go func() {
				<-ctx.Done()
				sctx, c := context.WithTimeout(context.Background(), 3*time.Second)
				defer c()
				srv.Shutdown(sctx)
				e.Shutdown(sctx)
			}()
			srv.Serve(ln) // ここで戻ったら main が終わる想定
		}},
	}
	for _, v := range vs {
		e, _ := edge.New(edge.Config{Logger: &rec{}, MaxJobs: 1000})
		var acc, rej, done, ok200 atomic.Int64
		var entered sync.WaitGroup
		entered.Add(n)
		mux := http.NewServeMux()
		mux.HandleFunc("GET /w", func(w http.ResponseWriter, r *http.Request) {
			entered.Done()
			time.Sleep(50 * time.Millisecond)
			if e.Go(r.Context(), 5*time.Second, "audit", func(ctx context.Context) error {
				time.Sleep(200 * time.Millisecond)
				done.Add(1)
				return nil
			}) == nil {
				acc.Add(1)
			} else {
				rej.Add(1)
			}
		})
		ln, _ := net.Listen("tcp", "127.0.0.1:0")
		srv := &http.Server{Handler: mux}
		ctx, stop := context.WithCancel(context.Background())
		ret := make(chan struct{})
		go func() { v.run(ctx, e, srv, ln); close(ret) }()
		var cw sync.WaitGroup
		for i := 0; i < n; i++ {
			cw.Add(1)
			go func() {
				defer cw.Done()
				c := &http.Client{Transport: &http.Transport{DisableKeepAlives: true}}
				if resp, err := c.Get("http://" + ln.Addr().String() + "/w"); err == nil {
					io.Copy(io.Discard, resp.Body)
					resp.Body.Close()
					if resp.StatusCode == 200 {
						ok200.Add(1)
					}
				}
			}()
		}
		entered.Wait()
		start := time.Now()
		stop()
		<-ret
		el := time.Since(start)
		atExit := done.Load()
		cw.Wait()
		time.Sleep(300 * time.Millisecond)
		t.Logf("%-40s 戻るまで %4d ms / 200=%d / 受けた %d・断った %d / 戻った時点で終わった仕事 %d（その後 %d）",
			v.name, el.Milliseconds(), ok200.Load(), acc.Load(), rej.Load(), atExit, done.Load())
	}
}

// 実測 2: srv.Shutdown は「最後の要求が終わってから」何 ms 遅れて戻るか（ポーリング 1 ms→倍々→上限 500 ms）。
func TestMeasureShutdownPollLag(t *testing.T) {
	for _, hd := range []time.Duration{5 * time.Millisecond, 50 * time.Millisecond, 200 * time.Millisecond, 700 * time.Millisecond, 1500 * time.Millisecond} {
		var lags []time.Duration
		for k := 0; k < 5; k++ {
			entered := make(chan struct{})
			finished := make(chan time.Time, 1)
			mux := http.NewServeMux()
			mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
				close(entered)
				time.Sleep(hd)
				finished <- time.Now()
			})
			ln, _ := net.Listen("tcp", "127.0.0.1:0")
			srv := &http.Server{Handler: mux}
			go srv.Serve(ln)
			go func() {
				c := &http.Client{Transport: &http.Transport{DisableKeepAlives: true}}
				if resp, err := c.Get("http://" + ln.Addr().String() + "/"); err == nil {
					resp.Body.Close()
				}
			}()
			<-entered
			srv.Shutdown(context.Background())
			lags = append(lags, time.Since(<-finished))
		}
		sort.Slice(lags, func(i, j int) bool { return lags[i] < lags[j] })
		t.Logf("ハンドラ %5v: 終わってから Shutdown が戻るまで 最小 %v 中央 %v 最大 %v", hd, lags[0].Round(100*time.Microsecond), lags[2].Round(100*time.Microsecond), lags[4].Round(100*time.Microsecond))
	}
}

// 実測 3: WaitGroup ＋ atomic の素朴版。Go と Shutdown がぶつかると何が起きるか。
type naive struct {
	closed atomic.Bool
	wg     sync.WaitGroup
}

func (n *naive) Go(fn func()) error {
	if n.closed.Load() {
		return edge.ErrClosed
	}
	n.wg.Add(1) // closed を見てから Add するまでの隙間
	go func() { defer n.wg.Done(); fn() }()
	return nil
}
func (n *naive) Shutdown() { n.closed.Store(true); n.wg.Wait() }

func TestMeasureNaiveWaitGroup(t *testing.T) {
	const trials = 2000
	lostTrials, lostJobs, panics, acceptedTotal := 0, 0, 0, 0
	for i := 0; i < trials; i++ {
		var nv naive
		var acc, fin atomic.Int64
		var wg sync.WaitGroup
		var panicked atomic.Bool
		for g := 0; g < 8; g++ {
			wg.Add(1)
			go func() {
				defer wg.Done()
				defer func() {
					if recover() != nil {
						panicked.Store(true)
					}
				}()
				for k := 0; k < 4; k++ {
					if nv.Go(func() { time.Sleep(time.Millisecond); fin.Add(1) }) == nil {
						acc.Add(1)
					}
				}
			}()
		}
		runtime.Gosched()
		nv.Shutdown()
		f := fin.Load()
		wg.Wait()
		acceptedTotal += int(acc.Load())
		if panicked.Load() {
			panics++
		}
		if a := acc.Load(); f < a {
			lostTrials++
			lostJobs += int(a - f)
		}
		time.Sleep(2 * time.Millisecond)
	}
	t.Logf("素朴版: %d 回中 %d 回で Shutdown が戻った後に終わる仕事があった（計 %d 件 / 受けた %d 件）、WaitGroup misuse の panic %d 回",
		trials, lostTrials, lostJobs, acceptedTotal, panics)

	lost, accTotal := 0, 0
	for i := 0; i < trials; i++ {
		e, _ := edge.New(edge.Config{Logger: &rec{}, MaxJobs: 1000})
		var acc, fin atomic.Int64
		var wg sync.WaitGroup
		for g := 0; g < 8; g++ {
			wg.Add(1)
			go func() {
				defer wg.Done()
				for k := 0; k < 4; k++ {
					if e.Go(context.Background(), time.Second, "j", func(context.Context) error { time.Sleep(time.Millisecond); fin.Add(1); return nil }) == nil {
						acc.Add(1)
					}
				}
			}()
		}
		runtime.Gosched()
		e.Shutdown(context.Background())
		f := fin.Load()
		wg.Wait()
		accTotal += int(acc.Load())
		if a := acc.Load(); f < a {
			lost += int(a - f)
		}
	}
	t.Logf("Edge 版: %d 回で取りこぼし %d 件 / 受けた %d 件", trials, lost, accTotal)
}

// 実測 4: ctx を見ない仕事は、Shutdown が戻った後も生きている（goroutine は外から止められない）。
func TestMeasureRudeJobSurvives(t *testing.T) {
	base := runtime.NumGoroutine()
	e, _ := edge.New(edge.Config{Logger: &rec{}, MaxJobs: 100})
	release := make(chan struct{})
	var polite, rude atomic.Int64
	cutLat := make(chan time.Duration, 10)
	var cutAt atomic.Int64
	for i := 0; i < 10; i++ {
		e.Go(context.Background(), time.Minute, "polite", func(ctx context.Context) error {
			<-ctx.Done()
			cutLat <- time.Since(time.Unix(0, cutAt.Load()))
			polite.Add(1)
			return ctx.Err()
		})
		e.Go(context.Background(), time.Minute, "rude", func(context.Context) error { <-release; rude.Add(1); return nil })
	}
	ctx, c := context.WithTimeout(context.Background(), 50*time.Millisecond)
	defer c()
	time.AfterFunc(50*time.Millisecond-time.Microsecond, func() { cutAt.Store(time.Now().UnixNano()) })
	err := e.Shutdown(ctx)
	var lats []time.Duration
	for i := 0; i < 10; i++ {
		lats = append(lats, <-cutLat)
	}
	sort.Slice(lats, func(i, j int) bool { return lats[i] < lats[j] })
	t.Logf("Shutdown: %v", err)
	t.Logf("戻った後の goroutine 増分 %d（ctx を見る仕事 %d 件は戻った・見ない仕事 %d 件はまだ）", runtime.NumGoroutine()-base, polite.Load(), 10-rude.Load())
	t.Logf("期限から ctx を見る仕事が戻るまで: 最小 %v 最大 %v", lats[0], lats[9])
	close(release)
}

// 実測 5: 1 件あたりの費用。Day 074 の Detach＋go と比べる。
func BenchmarkGo(b *testing.B) {
	e, _ := edge.New(edge.Config{Logger: &rec{}, MaxJobs: 1 << 20})
	ctx := withRID(context.Background(), "r")
	var wg sync.WaitGroup
	b.ReportAllocs()
	for b.Loop() {
		wg.Add(1)
		e.Go(ctx, time.Second, "j", func(context.Context) error { wg.Done(); return nil })
	}
	wg.Wait()
}

func BenchmarkDetachGo(b *testing.B) {
	ctx := withRID(context.Background(), "r")
	var wg sync.WaitGroup
	b.ReportAllocs()
	for b.Loop() {
		wg.Add(1)
		dctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), time.Second)
		go func() { defer cancel(); _ = dctx; wg.Done() }()
	}
	wg.Wait()
}

var _ = errors.Is