A-3 judge and claim: the same call again runs once on the router's record of its Approve

The gate sits on both handlers the runner serves, a module's tools (its ledger repairs
among them) and the seat verbs its modules hold, before the bundle. The same call again
is judged on the router's own record of its act's newest ask: held to the warrant
(operatorchannelclient.For), the option and the act it bound (Performs), within 30 minutes
of the choice, and claimed by compare-and-set (Client.Take) before it runs, so one
approval runs one call. A later call is told it still waits, was declined (not asked again
for 10 minutes), or asks anew after expired, approved too long ago or already run. A
runner's own tool marked is refused unasked; with no state approvals bound a marked call is
refused and an unmarked one runs. The gate's reach (state, publish, the router's record)
is the runner's own connection, in one place; it waits for the catalog half's first view
on the events the runner hears.

Builds: design 46 7-approval-mark §13, §14, §15, §17, §20

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

node-tools/internal/firstview/approval.go

@@ -3,6 +3,7 @@ package firstview
 import (
 	"context"
 	"strconv"
+	"time"
 
 	"git.novox.be/novox/mesh-delivery/contracts/go/clients/meshcatalogclient"
 	catalogseat "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshcatalog"
@@ -81,3 +82,76 @@ type notFollowed struct{}
 func (notFollowed) Error() string { return "the catalog half is not followed by this runner" }
 
 var errNotFollowed error = notFollowed{}
+
+// heardOne wakes every wait on the picture.
+func (v *Views) heardOne() {
+	v.mu.Lock()
+	defer v.mu.Unlock()
+	if v.heard != nil {
+		close(v.heard)
+	}
+	v.heard = make(chan struct{})
+}
+
+// heardNext is closed at the next event heard.
+func (v *Views) heardNext() <-chan struct{} {
+	v.mu.Lock()
+	defer v.mu.Unlock()
+	if v.heard == nil {
+		v.heard = make(chan struct{})
+	}
+	return v.heard
+}
+
+// WaitCatalog waits within the bound for the catalog half's first view of every watched branch (design 46 7-approval-mark
+// §19), waking at each event the runner hears and at each first view answered; nil once it is read, else why not.
+func (v *Views) WaitCatalog(within time.Duration) error {
+	c := approvalCatalog{v: v}
+	timer := time.NewTimer(within)
+	defer timer.Stop()
+	for {
+		next := v.heardNext()
+		err := c.Ready()
+		if err == nil {
+			return nil
+		}
+		var ready []<-chan struct{}
+		if v.branches != nil {
+			for _, branch := range v.branches.Followed() {
+				if cat, ok := v.branches.Catalog(branch); ok {
+					select {
+					case <-cat.Ready(): // read already: waits on nothing
+					default:
+						ready = append(ready, cat.Ready())
+					}
+				}
+			}
+		}
+		if !waitAny(next, timer.C, ready) {
+			return c.Ready()
+		}
+	}
+}
+
+// waitAny waits for next or one of ready, true, or for the bound, false.
+func waitAny(next <-chan struct{}, bound <-chan time.Time, ready []<-chan struct{}) bool {
+	woke := make(chan struct{}, 1)
+	stop := make(chan struct{})
+	defer close(stop)
+	for _, r := range ready {
+		go func(r <-chan struct{}) {
+			select {
+			case <-r:
+				woke <- struct{}{}
+			case <-stop:
+			}
+		}(r)
+	}
+	select {
+	case <-next:
+	case <-woke:
+	case <-bound:
+		return false
+	}
+	return true
+}

node-tools/internal/firstview/firstview.go

@@ -67,6 +67,8 @@ type Views struct {
 	cancel    context.CancelFunc
 	wg        sync.WaitGroup
 	deps      Deps
+	// heard is closed and made again at every event heard, so a wait for the picture wakes on events, never on a timer.
+	heard chan struct{}
 }
 
 // FindingsState is the runner's own state the findings are written in.
@@ -205,8 +207,10 @@ func StartWith(parent context.Context, d Deps, logf func(string, ...any)) (*View
 	return v, func() { stop(); cancel(); v.wg.Wait(); stopFindings() }
 }
 
-// hear applies one views event; a gap asks the first view once more.
+// hear applies one views event; a gap asks the first view once more. Every event heard wakes what waits on the picture
+// (heardOne).
 func (v *Views) hear(env bus.Envelope) error {
+	defer v.heardOne()
 	v.mu.Lock()
 	hs := append([]*adoption(nil), v.hearers[env.Key]...)
 	v.mu.Unlock()