C1c-4: the tool runner sends a bundle's chunked seat answer in chunks, and a node's chunked verb is asked of the node

A seat verb whose definition says chunks, served by a bundle that answers the whole file as the member `file`, is sent by the
runner with buscalls.SeatChunks.Send and answered with the chunk count (Conn.AnswerChunked, called from serveSeats). A chunked verb
asked of one machine (`@<node>`) is received in chunks as the verb is.

Builds: design 47 G A-257, A-249, A-254, §681

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

node-tools/internal/bus/chunked.go

@@ -25,9 +25,12 @@ const FileField = "file"
 // counts with buscalls.SeatChunks, each acknowledged before the next, and answers the verb's own answer with the whole
 // file added as FileField. The asking bundle receives no chunk itself.
 func (c *Conn) AskAsChunked(module, key string, body any) (Answered, error) {
-	seat, verb, ok := strings.Cut(strings.TrimPrefix(key, "seat:"), ".")
-	if !strings.HasPrefix(key, "seat:") || !ok || strings.Contains(verb, "@") {
-		return Answered{}, fmt.Errorf("%q is no seat:<seat>.<verb> of no one machine, which a chunked answer needs", key)
+	// The verb may be asked of the machine that ran the ask (`@<node>`, A-254): the chunk subjects name the seat, the verb and
+	// the call alone.
+	name, _, _ := strings.Cut(key, "@")
+	seat, verb, ok := strings.Cut(strings.TrimPrefix(name, "seat:"), ".")
+	if !strings.HasPrefix(key, "seat:") || !ok {
+		return Answered{}, fmt.Errorf("%q is no seat:<seat>.<verb>, which a chunked answer needs", key)
 	}
 	args := map[string]any{}
 	if raw, err := json.Marshal(body); err != nil {
@@ -93,3 +96,48 @@ func (c *Conn) AskAsChunked(module, key string, body any) (Answered, error) {
 	answered.Result = out
 	return answered, nil
 }
+
+// AnswerChunked is a seat verb's answer as its definition says `chunks` (design 47 G A-257, §681): a bundle answers the whole file
+// as the member FileField (base64), and the runner that serves the verb sends it in chunks with buscalls.SeatChunks on the call
+// token the body names, each acknowledged by the caller before the next, and answers the verb's own members with `chunks`, the
+// count, in place of the file. The bundle sends no chunk itself. An answer with no file is answered as it is. The send runs after
+// the answer is returned: the caller hears the chunks before it asks (AskAsChunked) and acknowledges each once it has the answer.
+func (c *Conn) AnswerChunked(seat, verb string, body json.RawMessage, answer any) (any, error) {
+	raw, err := json.Marshal(answer)
+	if err != nil {
+		return nil, err
+	}
+	fields := map[string]json.RawMessage{}
+	if err := json.Unmarshal(raw, &fields); err != nil {
+		return answer, nil
+	}
+	enc, has := fields[FileField]
+	if !has {
+		return answer, nil
+	}
+	var text string
+	if err := json.Unmarshal(enc, &text); err != nil {
+		return nil, fmt.Errorf("%s.%s answers a %s that is no string: %w", seat, verb, FileField, err)
+	}
+	file, err := base64.StdEncoding.DecodeString(text)
+	if err != nil {
+		return nil, fmt.Errorf("%s.%s answers a %s in no base64: %w", seat, verb, FileField, err)
+	}
+	var asked struct {
+		Call string `json:"call"`
+	}
+	if err := json.Unmarshal(body, &asked); err != nil || asked.Call == "" {
+		return nil, fmt.Errorf("%s.%s is asked in chunks with no call token", seat, verb)
+	}
+	delete(fields, FileField)
+	count := int64((len(file) + buscalls.SeatChunkBytes - 1) / buscalls.SeatChunkBytes)
+	fields["chunks"], _ = json.Marshal(count)
+	send := buscalls.SeatChunks{Seat: seat, Verb: verb, Call: asked.Call}
+	go func() { _ = send.Send(c.nc, file, buscalls.SeatAckWithin, c.Logf) }()
+	return json.RawMessage(mustMarshal(fields)), nil
+}
+
+func mustMarshal(v any) []byte {
+	b, _ := json.Marshal(v)
+	return b
+}