shaders: -Dprebuilt-shaders, so a gui build needs no Vulkan SDK

glslc is the one build input that wants a tool a stock machine does not have,
and it is also the input that changes least often: eight GLSL files that have
outlived several rewrites of everything around them. Asking every machine that
wants to run the SDL shell for shaderc is the wrong trade.

The SPIR-V is now COMMITTED, under shaders/prebuilt/, and -Dprebuilt-shaders
embeds that copy instead of shelling out. The default stays the honest one --
compile the shaders that are actually in the tree -- because the flag trades a
dependency for a freshness problem: with it on, the .glsl sources are not build
inputs at all, so editing one changes nothing.

`zig build shaders` is the other half, and it is deliberately independent of
-Dplatform: it recompiles every shader and writes the result back into the
tracked directory, so whoever changes a shader refreshes the cache on a machine
that has the compiler and commits the diff. `jj diff shaders/prebuilt` after it
is the freshness check -- empty means the cache was already current.

The shader list is also spelled once now (gui_shaders): the eight embeds, the
eight glslc runs and the refresh step all read it, so adding a shader is a name
there plus the @embedFile in gui.zig, not three edits in two places.

Verified: -Dplatform=gui -Dprebuilt-shaders builds with glslc absent from PATH,
and image-harness passes on that binary -- real SDL GPU pipelines built from the
committed SPIR-V, 512 source pixels read back. The default gui build still runs
the eight glslc steps; tty runs none. The committed bytes are identical to a
fresh glslc run, and `zig build shaders` is idempotent.

1 files changed, 31 insertions, 0 deletions

diff --git a/src/builtins.zig b/src/builtins.zig
index 8b3d44d0..bb1a1273 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -202,6 +202,36 @@ pub const Restore = struct {
     }
 };
 
+// ---- the message row ----
+
+/// TEXT onto this pane's transient message row — the row a failed save, a
+/// refused Look and a language server that would not start all report through
+/// (Pardes.setMessage, and Pardes.reportError one line above it). Every writer
+/// of that row is something going wrong, so until this word there was no way
+/// to look at it without breaking something on purpose: no wording could be
+/// checked against a narrow pane, and no test could pin the row without
+/// arranging a real failure first.
+///
+/// Bare, it reports ITSELF through the error path, because that is the other
+/// half of the same machinery — `reportError` is `setMessage` plus an
+/// `<operation>: <Error>` — and because a word that needs no argument to
+/// demonstrate one is a word you can also just click.
+///
+/// Whether the row is FREE is not asked here and is not this word's business:
+/// an armed prompt outranks a message at render time, so posting under one is
+/// stored and invisible, exactly as a save finishing under one is. Nor does
+/// anything here decide when it goes away — your next key or click does, on
+/// every pane at once, because a message is exactly as old as your last input.
+pub const Msg = struct {
+    pub const takes_arg = true;
+    pub fn run(c: Ctx) void {
+        if (c.arg) |text|
+            c.p.setMessage(c.id, text)
+        else
+            c.p.reportError(c.id, comptime word(@This()), error.NoMessage);
+    }
+};
+
 // ---- display toggles ----
 
 pub const Debug = struct {
@@ -357,6 +387,7 @@ pub const Font = struct {
         if (path.len > fonts.want_buf.len) return;
         @memcpy(fonts.want_buf[0..path.len], path);
         fonts.want = fonts.want_buf[0..path.len];
+        fonts.chosen = std.fs.path.stem(fonts.want.?);
     }
 };