package runtime import ( "fmt" "strings" "git.novox.be/novox/mesh-sdk/go/approval" "git.novox.be/novox/mesh-sdk/go/seatdef" "github.com/novox/mesh-tools/node-tools/internal/launch" ) // FingerprintWord is the word of a module's composed environment that names the build its bundle serves (design 47 G §424). const FingerprintWord = "MESH_FINGERPRINT" // Gate is the approval gate the runner serves through (design 46 7-approval-mark §4, §20; node-tools/internal/approval). type Gate interface { // Unserved is, of a module's marked tools, those its bundle does not register, saying it as the module's finding. Unserved(module, fingerprint string, registered []string) []string // Run is a call through the gate: run is called only when the call may run now, once. Run(call approval.Call, run func() (any, error)) (any, error) // Approvals is the seat verb `approvals` for a caller: the calls the gate holds, its acts and claims (A-265, A-271). Approvals(caller string) (approval.Approvals, error) } // gatedRun is how a handler calls a tool: through the gate where there is one. type gatedRun func(call approval.Call, t launch.Tool, caller string) (any, error) // gated calls the tool through the gate, or straight where the runner has none. func (c *consumers) gated(call approval.Call, t launch.Tool, caller string) (any, error) { run := func() (any, error) { return t.Run(caller, call.Args) } if c.gate == nil { return run() } return c.gate.Run(call, run) } // approvalsOf is how the runner answers a held seat's verb `approvals`: from its gate's record, nil without a gate. func (r *runner) approvalsOf() func(caller string) (any, error) { if r.events.gate == nil { return nil } return func(caller string) (any, error) { return r.events.gate.Approvals(caller) } } // WithGate serves every call through the approval gate. func WithGate(g Gate) Option { return func(c *consumers) { c.gate = g } } var _ Gate = (*approval.Gate)(nil) // WithSeatDefinitions refuses, where a seat's verb is answered, a caller outside the verb's effective callers, before the // bundle runs (design 47 G §610; lead answers A-165, A-179): defs are the seat definitions the runner's seat list holds. // Without it a verb is answered for every caller, as before. func WithSeatDefinitions(defs func() map[string]seatdef.Definition) Option { return func(c *consumers) { c.definitions = defs } } // admitted says why a seat's verb is refused to a caller: never. Every caller is admitted, whether or not the seat's definition // is read and whatever callers it names (the operator, 2026-11-15 23:25 CET: every module, agent and operator may call anything; // approval stays as the mark on a verb, held by the gate). func (c *consumers) admitted(seat, verb, caller string) error { return nil } // unservedMarks is, of the module's marked tools, those its bundle's registrations under its own name do not register. func (r *runner) unservedMarks(module string, regs []launch.Registration) []string { if r.events.gate == nil { return nil } var registered []string for _, reg := range regs { if reg.Module == module { for _, t := range reg.Tools { registered = append(registered, t.Name) } } } return r.events.gate.Unserved(module, r.fingerprintOf(module), registered) } // WithSeatDefinitionsAgain gives the runner the way to read the seat list again (the seat list reader's Reload): a seat verb a bundle asks // that the definitions held do not name is looked up again after it, never taken for a verb that sends no chunks. func WithSeatDefinitionsAgain(again func() error) Option { return func(c *consumers) { c.reread = again } } // chunkedAsked is chunked for a verb a bundle asks, where the answer decides whether the runner chooses the `call` the holder // requires (AskAsChunked) (design 47 G A-490m). A verb of a seat the definitions held DEFINE, whose definition does not name it, // is not taken for one that sends no chunks, since the holder then refuses an ask that carries no call: the seat list is read // again once (one read shared by the asks that wait on it) and a verb still unnamed is an error saying so. An ask of a seat the // definitions do not define at all, a module's tool and a runner that holds no definitions (nil) are asked as before. func (c *consumers) chunkedAsked(key string) (bool, error) { if c.definitions == nil || !strings.HasPrefix(key, "seat:") { return false, nil } name, _, _ := strings.Cut(key, "@") seat, verb, ok := strings.Cut(strings.TrimPrefix(name, "seat:"), ".") if !ok { return false, nil } find := func() (chunks, defined, named bool) { d, defined := c.definitions()[seat] for _, v := range d.Verbs { if v.Name == verb { return v.Chunks, true, true } } return false, defined, false } chunks, defined, named := find() if named || !defined { return chunks, nil } var why string if c.reread != nil { if err := c.rereadShared(); err != nil { why = " (reading the seat list again failed: " + err.Error() + ")" } chunks, defined, named = find() if named { return chunks, nil } if !defined { return false, nil } } return false, fmt.Errorf("the definition of the seat %s names no verb %s, so the runner cannot tell whether it sends its answer in chunks and does not ask it%s", seat, verb, why) } // rereadShared reads the seat list again; asks that arrive while a read runs wait for it and share its result. func (c *consumers) rereadShared() error { c.rereadMu.Lock() if f := c.rereading; f != nil { f.waiters++ c.rereadMu.Unlock() <-f.done return f.err } f := &rereadFlight{done: make(chan struct{})} c.rereading = f c.rereadMu.Unlock() f.err = c.reread() c.rereadMu.Lock() c.rereading = nil c.rereadMu.Unlock() close(f.done) return f.err } type rereadFlight struct { done chan struct{} err error waiters int // the asks that joined the read (under rereadMu) } // rereadWaiting is how many asks have joined the read now running; a test waits on it instead of sleeping. func (c *consumers) rereadWaiting() int { c.rereadMu.Lock() defer c.rereadMu.Unlock() if c.rereading == nil { return 0 } return c.rereading.waiters } // chunked says whether key names a seat's verb whose definition says `chunks` (design 47 G A-249): its answer is received in // chunks by the runner, whose call hands the bundle the whole. func (c *consumers) chunked(key string) bool { if c.definitions == nil || !strings.HasPrefix(key, "seat:") { return false } name, _, _ := strings.Cut(key, "@") // a verb asked of the machine that ran the ask is chunked as the verb is (A-254) seat, verb, ok := strings.Cut(strings.TrimPrefix(name, "seat:"), ".") if !ok { return false } for _, v := range c.definitions()[seat].Verbs { if v.Name == verb { return v.Chunks } } return false }