feat(v4.0.0): the wire in the engine -- whole messages, put and taken in one step

Queues of whole messages on the wires between nodes (v4/wire.h), the six
addresses and ten operations a node asks of the fabric (MESH.md 7d.3), and the
fabric's pool of queues. Engine only: the nucleus does not use any of it yet.
The ports in the host map move to BUF0_W - 140 so that the new addresses are
not among the nucleus variables, with a compile-time check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

v4/src/wire.c

@@ -0,0 +1,124 @@
+/* wire.c -- a queue of whole messages.  See wire.h.
+ *
+ * Nothing here uses the C library: the bare-metal kernel links this file.
+ */
+#include "v4/wire.h"
+#include "v4/message.h"
+
+void v4_wire_reset(v4_wire_queue *q)
+{
+    unsigned i;
+    for (i = 0; i < V4_WIRE_CELLS; i++) q->cell[i] = 0;
+    q->head = 0;
+    q->used = 0;
+    q->mark = 0;
+    q->arrived = 0;
+}
+
+unsigned v4_wire_cells(v4_cell length)
+{
+    if (length < 0 || length > (v4_cell)V4_MSG_MAX_CHARS) return 0;
+    return V4_WIRE_HEADER + ((unsigned)length + 3u) / 4u;
+}
+
+/* the cell `off` cells from the front */
+static unsigned slot(const v4_wire_queue *q, unsigned off)
+{
+    unsigned s = q->head + off;
+    return s >= V4_WIRE_CELLS ? s - V4_WIRE_CELLS : s;
+}
+
+/* the cells the message `off` cells from the front takes */
+static unsigned size_at(const v4_wire_queue *q, unsigned off)
+{
+    return v4_wire_cells(q->cell[slot(q, off + 6u)]);
+}
+
+int v4_wire_room(const v4_wire_queue *q, unsigned cells)
+{
+    return cells <= V4_WIRE_CELLS - q->used ? V4_WIRE_DONE : V4_WIRE_NO_ROOM;
+}
+
+/* `n` cells, already checked to fit, onto the back */
+static unsigned back(v4_wire_queue *q, unsigned n)
+{
+    unsigned at = q->used;
+    q->used += n;
+    q->arrived = 1;
+    return at;
+}
+
+int v4_wire_put(v4_wire_queue *q, const v4_cell *header7, const v4_cell *text)
+{
+    unsigned n = v4_wire_cells(header7[6]), at, i;
+    if (n == 0) return V4_WIRE_NOT_A_MESSAGE;
+    if (v4_wire_room(q, n) != V4_WIRE_DONE) return V4_WIRE_NO_ROOM;
+    at = back(q, n);
+    for (i = 0; i < V4_WIRE_HEADER; i++) q->cell[slot(q, at + i)] = header7[i];
+    for (; i < n; i++) q->cell[slot(q, at + i)] = text[i - V4_WIRE_HEADER];
+    return V4_WIRE_DONE;
+}
+
+void v4_wire_first(v4_wire_queue *q)
+{
+    q->mark = 0;
+}
+
+int v4_wire_next(v4_wire_queue *q)
+{
+    if (q->mark >= q->used) return V4_WIRE_NO_MESSAGE;
+    q->mark += size_at(q, q->mark);
+    return q->mark < q->used ? V4_WIRE_DONE : V4_WIRE_NO_MESSAGE;
+}
+
+int v4_wire_look(const v4_wire_queue *q, v4_cell *header7)
+{
+    unsigned i;
+    if (q->mark >= q->used) return V4_WIRE_NO_MESSAGE;
+    for (i = 0; i < V4_WIRE_HEADER; i++) header7[i] = q->cell[slot(q, q->mark + i)];
+    return V4_WIRE_DONE;
+}
+
+/* the marked message is off the queue; the mark is at the one that followed */
+static void remove_marked(v4_wire_queue *q)
+{
+    unsigned n = size_at(q, q->mark), i;
+    if (q->mark == 0) {
+        q->head = slot(q, n);
+    } else {
+        for (i = q->mark; i + n < q->used; i++) q->cell[slot(q, i)] = q->cell[slot(q, i + n)];
+    }
+    q->used -= n;
+}
+
+int v4_wire_take(v4_wire_queue *q, v4_cell *header7, v4_cell *text, unsigned text_cap)
+{
+    unsigned n, i;
+    if (q->mark >= q->used) return V4_WIRE_NO_MESSAGE;
+    n = size_at(q, q->mark);
+    if (n - V4_WIRE_HEADER > text_cap) return V4_WIRE_NOT_A_MESSAGE;
+    for (i = 0; i < V4_WIRE_HEADER; i++) header7[i] = q->cell[slot(q, q->mark + i)];
+    for (; i < n; i++) text[i - V4_WIRE_HEADER] = q->cell[slot(q, q->mark + i)];
+    remove_marked(q);
+    return V4_WIRE_DONE;
+}
+
+int v4_wire_drop(v4_wire_queue *q)
+{
+    if (q->mark >= q->used) return V4_WIRE_NO_MESSAGE;
+    remove_marked(q);
+    return V4_WIRE_DONE;
+}
+
+int v4_wire_move(v4_wire_queue *from, v4_wire_queue *to)
+{
+    unsigned n, at, i;
+    if (from->mark >= from->used) return V4_WIRE_NO_MESSAGE;
+    n = size_at(from, from->mark);
+    if (from == to || v4_wire_room(to, n) != V4_WIRE_DONE) return V4_WIRE_NO_ROOM;
+    at = back(to, n);
+    for (i = 0; i < n; i++) to->cell[slot(to, at + i)] = from->cell[slot(from, from->mark + i)];
+    to->cell[slot(to, at + 3u)] = (v4_cell)(from->cell[slot(from, from->mark + 3u)] - 1);
+    remove_marked(from);
+    return V4_WIRE_DONE;
+}