F-parts: distribution and gitea bind mesh-sdk's idle key and binding cap instead of their own copies

Both holders carried the same idle bound and the same read of incoming's cap; the second instance of the
kind moved into mesh-sdk's Receiver (Arm, Expired, Bound, with BusArm, BusCap and FollowIdle). Each
holder now hands its idle state and its objects to those, and keeps its rows.

Claude-Session: https://claude.ai/code/session_01JG73KJNrH5EgFXMKKYSrig

modules/distribution/cmd/distribution-tools/main.go

@@ -15,12 +15,10 @@ import (
 	"os"
 	"strings"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	reg "git.novox.be/novox/mesh-contracts/go/seats/containerimageregistry"
 	stdio "git.novox.be/novox/mesh-sdk/go"
-	"git.novox.be/novox/mesh-sdk/go/busstate"
 	"git.novox.be/novox/mesh-sdk/go/delivery"
 	"git.novox.be/novox/mesh-sdk/go/health"
 	"git.novox.be/novox/mesh-sdk/go/parts"
@@ -166,53 +164,6 @@ func learnInto(state casState, module, fp string, attempts int) (bool, error) {
 	return false, fmt.Errorf("%s was written by another writer first %d times: %w", holder.PublishingKey, attempts, stdio.ErrChanged)
 }
 
-// incomingCap reads incoming's cap from its binding (the bus's bound of the object store, design 51 *Publishing*), once
-// it answers one: the binding's cap does not change while the bundle runs.
-func incomingCap() func() (uint64, error) {
-	var known atomic.Uint64
-	return func() (uint64, error) {
-		if c := known.Load(); c > 0 {
-			return c, nil
-		}
-		f, err := busstate.ObjectsOf(holder.IncomingObjects).Fill()
-		if err != nil {
-			return 0, fmt.Errorf("incoming's cap cannot be read from its binding: %w", err)
-		}
-		if f.MaxBytes == 0 {
-			return 0, errors.New("incoming's binding carries no cap")
-		}
-		known.Store(f.MaxBytes)
-		return f.MaxBytes, nil
-	}
-}
-
-// armIdle writes a transfer's idle key with its own time to live; one already there is the same bound, kept.
-func armIdle(id string, ttl time.Duration) error {
-	if _, err := stdio.State(holder.IdleState).CreateTTL(id, map[string]any{"transfer": id}, ttl); err != nil && !errors.Is(err, stdio.ErrChanged) {
-		return err
-	}
-	return nil
-}
-
-// followIdle drops a transfer when its idle key ends (holder.Expired): the bus's marker is the event, no timer runs.
-func followIdle(h *holder.Holder) {
-	<-stdio.Served()
-	stdio.State(holder.IdleState).Follow("", func(ch stdio.StateChange) error {
-		if ch.Op != stdio.OpExpire {
-			return nil
-		}
-		dropped, err := h.Expired(ch.Key)
-		if err != nil {
-			logf("%v", err)
-			return err
-		}
-		if dropped {
-			logf("transfer %s had no part for %s: dropped with its parts", ch.Key, holder.TransferIdle)
-		}
-		return nil
-	})
-}
-
 // mirrors is the state mirrors: an ask is created once; one already kept is the same copy, taken on already.
 type mirrors struct{}
 
@@ -547,10 +498,16 @@ func main() {
 	base, _ := url.Parse("http://127.0.0.1:5001")
 	store := &holder.OCI{Base: base, Upstream: &holder.Upstream{}}
 	h := &holder.Holder{Objects: parts.BusObjects(holder.IncomingObjects), Builder: delivery.BuilderVersions{Ask: stdio.Ask}, Store: store, Say: say, Finding: finding,
-		Transfers: parts.BusTransfers[holder.Opening](holder.TransfersState), Cap: incomingCap(), Idle: armIdle}
+		Transfers: parts.BusTransfers[holder.Opening](holder.TransfersState), Cap: parts.BusCap(holder.IncomingObjects), Idle: parts.BusArm(holder.IdleState)}
 	v := &holder.Verbs{Holder: h, Catalog: store, Holds: kept[holder.Hold]{state: "holds", key: holder.Hold.Key}, Mirrors: mirrors{}}
 	go followMirrors(v)
-	go followIdle(h)
+	go parts.FollowIdle(holder.IdleState, h.Expired, func(id string, dropped bool, err error) {
+		if err != nil {
+			logf("%v", err)
+			return
+		}
+		logf("transfer %s had no part for %s: dropped with its parts", id, holder.TransferIdle)
+	})
 	windows := kept[holder.Window]{state: "windows", key: func(w holder.Window) string { return w.Name }}
 	if err := stdio.Serve("", tools(v, windows, holder.ConfiguredCallers)); err != nil {
 		logf("%v", err)