library: the last three protocols speak the envelope

These were the awkward ones. Each began with an operation packed into a
single byte — two of them with a version wedged in beside it — so there was
no wrapping them: the layouts had to be rebuilt. The device manager's own
enumerate and subscribe become the reserved verbs that mean the same thing
everywhere, its replies lose three status structs the envelope already
carries, and a device id becomes the packet's target. Power drops the
version it repeated on every request, because describe is the handshake,
and stops claiming a 64-byte ceiling it never needed for calls. USB moves a
control transfer's data to the packet tail in both directions, which makes
the status length the transferred length and retires a field that had been
saying the same thing twice.

The danger in this one was not the protocols but their readers. Init
recognised a power button by two bytes at the head of a message, the ACPI
service dispatched on the first byte, the xHCI driver read its operation
with a raw integer load, and the HID drivers reinterpreted a report
wholesale — none of which would have failed to compile once the layouts
moved. They would simply have stopped: no shutdown on the power button, no
reports from the keyboard. Every one of them now reads through the
generated types, and the shutdown gate that answers only a subscriber is
the same code it was.

Two sizes were decided by measuring rather than assuming. The child-added
message is both a request and the event broadcast to subscribers, and
alignment rounds it to 48 bytes, which puts its packet exactly on the
64-byte push floor — a test pins that, because a field added carelessly
would now overflow it. The interrupt report gives up eight bytes of inline
room to make space for the header; the two drivers that produce reports
send eight and four.

Suite 110/110.

system/services/init/init.zig

@@ -902,9 +902,12 @@ fn onPowerEvent(sender: u32, payload: []const u8) void {
         std.log.info("ignored a power event from pid {d}: /protocol/power is pid {d}", .{ sender, authorized });
         return;
     }
-    if (payload.len < 2) return;
-    if (payload[0] != @intFromEnum(power_protocol.Operation.event)) return;
-    if (payload[1] == @intFromEnum(power_protocol.Event.power_button)) shutDown();
+    // Read as an envelope packet, never by byte offset: the kind IS the packet's
+    // verb, so a power event is decoded exactly the way every other event in the
+    // system is. A packet whose operation is not one of this protocol's events —
+    // anything else that lands in this mailbox — decodes to null and is dropped.
+    const kind = power_protocol.Protocol.eventOf(payload) orelse return;
+    if (kind == .power_button) shutDown();
 }
 
 /// A supervised boot service died. Find which one and restart it — unless it exited
@@ -955,9 +958,11 @@ fn restartChild(id: u32) void {
 /// init calls owes the same discipline.
 fn subscribePower() void {
     const handle = power_endpoint orelse return;
-    const request = power_protocol.Subscribe{};
+    // The reserved `subscribe` verb: nothing but the header, with our own
+    // endpoint riding as the call's capability.
+    const header = envelope.Header{ .operation = envelope.operation_subscribe };
     var reply: [power_protocol.message_maximum]u8 = undefined;
-    _ = ipc.callCap(handle, std.mem.asBytes(&request), &reply, supervision_endpoint) catch {};
+    _ = ipc.callCap(handle, std.mem.asBytes(&header), &reply, supervision_endpoint) catch {};
 }
 
 /// The stop sequence: persist the log while storage is still up, then terminate
@@ -976,9 +981,11 @@ fn shutDown() void {
         if (child_ids[i] != 0) process.stop(child_ids[i], 2000, supervision_endpoint);
     }
     if (power_endpoint) |h| {
-        const request = power_protocol.Shutdown{};
-        var reply: [power_protocol.message_maximum]u8 = undefined;
-        _ = ipc.call(h, std.mem.asBytes(&request), &reply) catch {};
+        var packet: [power_protocol.message_maximum]u8 = undefined;
+        if (power_protocol.Protocol.encodeRequest(.shutdown, 0, {}, &.{}, &packet)) |framed| {
+            var reply: [power_protocol.message_maximum]u8 = undefined;
+            _ = ipc.call(h, framed, &reply) catch {};
+        }
     }
     // If S5 did not take, init has nothing left to do but idle.
     while (true) time.sleepMillis(1000);