The runtime serves a bundle its module's state (novox/hq ADR 0201)

mesh/state.get, put, delete, keys and watch on the stdio channel, from the
buckets the membership issues. A watch hands the current values without
deletions, then every change, and is answered once the current values are
delivered. Refused with the reason: state not issued, a reader's write, a
value with a credential-named field — the bus alone would answer a refused
write with a timeout.

node-tools/internal/runtime/runtime.go

@@ -578,3 +578,69 @@ func (b *moduleBus) Subscribe(deliver func(json.RawMessage) error) error {
 	c.logf("[mesh-tools] %s's events arrive on its consumer %s", module, bus.ConsumerOf(c.conn.Node(), module))
 	return nil
 }
+
+// stateAsked is what a bundle names when it reaches its state (ADR 0201): the state by the name its
+// module uses, a key, and for a put the value.
+type stateAsked struct {
+	State string          `json:"state"`
+	Key   string          `json:"key"`
+	Value json.RawMessage `json:"value"`
+}
+
+// State answers a bundle's `get`, `put`, `delete` and `keys` on its module's state (ADR 0201). The
+// runtime refuses, with the reason, a state the module was not issued and a write to one it only reads.
+func (b *moduleBus) State(verb string, params json.RawMessage) (json.RawMessage, error) {
+	var asked stateAsked
+	if err := json.Unmarshal(params, &asked); err != nil || asked.State == "" {
+		return nil, fmt.Errorf("mesh/state.%s names no state: {state, key, value}", verb)
+	}
+	conn := b.all.conn
+	var answer any
+	switch verb {
+	case "get":
+		entry, err := conn.StateGet(b.module, asked.State, asked.Key)
+		if err != nil {
+			return nil, err
+		}
+		if entry == nil {
+			return json.RawMessage("null"), nil
+		}
+		answer = entry
+	case "put":
+		revision, err := conn.StatePut(b.module, asked.State, asked.Key, asked.Value)
+		if err != nil {
+			return nil, err
+		}
+		answer = map[string]any{"revision": revision}
+	case "delete":
+		if err := conn.StateDelete(b.module, asked.State, asked.Key); err != nil {
+			return nil, err
+		}
+		answer = map[string]any{}
+	case "keys":
+		keys, err := conn.StateKeys(b.module, asked.State)
+		if err != nil {
+			return nil, err
+		}
+		answer = keys
+	default:
+		return nil, fmt.Errorf("the runtime answers no mesh/state.%s", verb)
+	}
+	return json.Marshal(answer)
+}
+
+// Watch hands a bundle its module's state as it is and as it changes (ADR 0201): `{state, key}`, the
+// key a pattern with `*` and `**`, empty for every key.
+func (b *moduleBus) Watch(params json.RawMessage, deliver func(json.RawMessage) error) (func(), error) {
+	var asked stateAsked
+	if err := json.Unmarshal(params, &asked); err != nil || asked.State == "" {
+		return nil, fmt.Errorf("mesh/state.watch names no state: {state, key}")
+	}
+	return b.all.conn.StateWatch(b.module, asked.State, asked.Key, func(change bus.StateChange) error {
+		raw, err := json.Marshal(change)
+		if err != nil {
+			return err
+		}
+		return deliver(raw)
+	})
+}