diff options
| author | Gabriel Schneider <[email protected]> | 2026-10-30 17:35:06 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-10-30 17:35:06 -0300 |
| commit | 6d8da8721141284cf33bb901168b26135893eb86 (patch) | |
| tree | 791d63401d4e85fbca1d597a8ce0326e70efd545 /src/detached/wire.zig | |
| parent | efd43a3a2cf03bb741366331158b368abf9ac583 (diff) | |
| parent | bf6810a8f9d6cc82050e7d9c0cfb06358301b574 (diff) | |
| download | pardes-6d8da8721141284cf33bb901168b26135893eb86.tar.gz pardes-6d8da8721141284cf33bb901168b26135893eb86.zip | |
Merge latest upstream into the macOS branch for Zig 0.17
Retain the macOS branch history and local Acme selection color while adopting upstream's current core and platform changes. Pin Zig and ZLS to 0.17.0, and fetch the existing zstbi compatibility commit through upstream after its original fork was removed.
Diffstat (limited to 'src/detached/wire.zig')
| -rw-r--r-- | src/detached/wire.zig | 1096 |
1 files changed, 603 insertions, 493 deletions
diff --git a/src/detached/wire.zig b/src/detached/wire.zig index 245bc9f4..0e141686 100644 --- a/src/detached/wire.zig +++ b/src/detached/wire.zig @@ -3,10 +3,35 @@ const std = @import("std"); const pardes = @import("../pardes.zig"); const limits = @import("../memory.zig").limits; +const ShaderBuild = @import("../ShaderBuild.zig"); +const Scene = pardes.config.Runtime.Scene; +const ShaderAnimation = pardes.config.Runtime.ShaderAnimation; -pub const version: u16 = 6; +/// 7: tag layers gained the `.notice` kind, so a frame can carry a tag value +/// an older frontend would reject mid-session. The greeting is where that has +/// to be refused, which is what this number is for. +/// 8: one layer type: a tag band carries all its rows (not a layer per +/// line), and a frame carries the core's placed regions after its layers. +pub const version: u16 = 12; -pub const Error = error{ Truncated, Overlong, BadTag, BadValue, Trailing, NoSpace }; +/// The Chrome palette is carried field by field as its declaration lists +/// them, so any change to it changes the wire: bump `version`, then this. +const chrome_layout: u64 = 0xbe608bed776ff502; +comptime { + @setEvalBranchQuota(10_000); + var hash = std.hash.Fnv1a_64.init(); + const info = @typeInfo(pardes.Chrome).@"struct"; + for (info.field_names, info.field_types) |name, T| { + hash.update(name); + hash.update(@typeName(T)); + } + if (hash.final() != chrome_layout) @compileError(std.fmt.comptimePrint("pardes.Chrome changed (layout 0x{x}): bump wire.version, then chrome_layout", .{hash.final()})); +} + +/// EndOfStream: the message ends early; WriteFailed: no room for it. +/// ReadFailed is in only because std.Io.Reader says so: a fixed one never +/// fails a read. +pub const Error = error{ EndOfStream, ReadFailed, Overlong, BadTag, BadValue, Trailing, WriteFailed }; pub const max_cols: u16 = 512; pub const max_rows: u16 = 128; @@ -37,6 +62,7 @@ pub const ClientTag = enum(u8) { pinch = 0x1b, touch_scroll = 0x1c, pointer_leave = 0x1d, + focus = 0x1e, }; // Session control precedes display-local effects. @@ -55,6 +81,9 @@ pub const ServerTag = enum(u8) { set_clipboard = 0x10, read_clipboard = 0x11, open_link = 0x12, + /// The post chain this frontend draws its frames through: sent on + /// attach and whenever it or a file's SPIR-V changes. + post = 0x13, }; /// Why the server hung up on a connect. Sent as a `refuse` and followed by a @@ -133,8 +162,8 @@ pub const Hello = struct { /// An error rather than a zero on a payload shorter than two bytes, so a /// truncated hello stays diagnosable too instead of reading as version 0. pub fn helloVersion(payload: []const u8) Error!u16 { - var r: Reader = .init(payload); - return r.getU16(); + var r: std.Io.Reader = .fixed(payload); + return r.takeInt(u16, .little); } pub const Welcome = struct { @@ -164,7 +193,9 @@ pub const Frame = struct { nruns: u32, runs: []const u8, - pub fn applyLayers(f: Frame, gpa: std.mem.Allocator, layers: *[pardes.MAX_PANES]pardes.BodyLayer, tags: *[pardes.MAX_TAG_LAYERS]pardes.TagLayer) !void { + pub fn applyLayers(f: Frame, gpa: std.mem.Allocator, layers: *[pardes.MAX_PANES]pardes.Layer, tags: *[pardes.MAX_TAG_LAYERS]pardes.Layer, regions: *std.ArrayListUnmanaged(pardes.Region), chrome: *pardes.Chrome) !void { + regions.clearRetainingCapacity(); + chrome.* = .{}; for (layers) |*layer| { gpa.free(layer.cells); layer.* = .{}; @@ -182,52 +213,105 @@ pub const Frame = struct { gpa.free(layer.cells); layer.* = .{}; } + regions.clearRetainingCapacity(); + chrome.* = .{}; } if (f.layers.len == 0) return; - var r: Reader = .init(f.layers); - const count = try r.getU16(); + var r: std.Io.Reader = .fixed(f.layers); + const count = try r.takeInt(u16, .little); if (count > layers.len) return error.Overlong; for (layers[0..count]) |*layer| { - layer.pane = try r.getU16(); - layer.serial = try r.getU32(); - layer.viewport = .{ .x = try r.getU16(), .y = try r.getU16(), .w = try r.getU16(), .h = try r.getU16() }; - layer.cols = try r.getU16(); - layer.rows = try r.getU16(); - layer.context_rows = try r.getU16(); - if (layer.pane >= pardes.MAX_PANES or layer.cols == 0 or layer.cols > f.cols or + layer.kind = .body; + layer.id = try r.takeInt(u16, .little); + layer.serial = try r.takeInt(u32, .little); + layer.viewport = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .w = try r.takeInt(u16, .little), .h = try r.takeInt(u16, .little) }; + layer.cols = try r.takeInt(u16, .little); + layer.rows = try r.takeInt(u16, .little); + layer.context_rows = try r.takeInt(u16, .little); + if (layer.id >= pardes.MAX_PANES or layer.cols == 0 or layer.cols > f.cols or layer.rows == 0 or layer.rows > 2 * max_rows or layer.context_rows > layer.rows or layer.context_rows > limits.wrap_rows or layer.viewport.x > f.cols or layer.viewport.w > f.cols - layer.viewport.x or layer.viewport.y > f.rows or layer.viewport.h > f.rows - layer.viewport.y) return error.BadValue; for (0..layer.context_rows) |row| { - if (try r.getBool()) layer.context_separators.set(row); + if (try getBool(&r)) layer.context_separators.set(row); } const cursor = try getCursor(&r, layer.cols, layer.rows); layer.cursor = if (cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null; layer.cells = try gpa.alloc(pardes.Cell, @as(usize, layer.cols) * layer.rows); for (layer.cells) |*cell| cell.* = try decodeCell(&r); } - const tag_count = try r.getU16(); + const tag_count = try r.takeInt(u16, .little); if (tag_count > tags.len) return error.Overlong; for (tags[0..tag_count]) |*layer| { - layer.kind = try r.getTag(pardes.TagKind); - layer.id = try r.getU16(); - layer.serial = try r.getU32(); - layer.viewport = .{ .x = try r.getU16(), .y = try r.getU16(), .w = try r.getU16(), .h = try r.getU16() }; - layer.cols = try r.getU16(); - for (&layer.bg) |*channel| channel.* = try r.getByte(); - if (layer.cols == 0 or layer.viewport.w == 0 or layer.viewport.h != 1 or + layer.kind = try getTag(&r, pardes.TagKind); + layer.id = try r.takeInt(u16, .little); + layer.serial = try r.takeInt(u32, .little); + layer.viewport = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .w = try r.takeInt(u16, .little), .h = try r.takeInt(u16, .little) }; + layer.cols = try r.takeInt(u16, .little); + layer.rows = try r.takeInt(u16, .little); + for (&layer.bg) |*channel| channel.* = try r.takeByte(); + if (layer.cols == 0 or layer.viewport.w == 0 or layer.rows == 0 or layer.rows > pardes.MAX_TAG_ROWS or + layer.viewport.h != layer.rows or layer.viewport.x > f.cols or layer.viewport.w > f.cols - layer.viewport.x or - layer.viewport.y >= f.rows or (switch (layer.kind) { + layer.viewport.y >= f.rows or layer.viewport.h > f.rows - layer.viewport.y or (switch (layer.kind) { .workspace => layer.id != 0, .column => layer.id >= pardes.MAX_COLS, - .pane => layer.id >= pardes.MAX_PANES, + .pane, .notice => layer.id >= pardes.MAX_PANES, + .body => true, })) return error.BadValue; - const cursor = try getCursor(&r, layer.cols, 1); - layer.cursor = if (cursor) |c| .{ .col = c.x, .bar = c.bar } else null; - layer.cells = try gpa.alloc(pardes.Cell, layer.cols); + const cursor = try getCursor(&r, layer.cols, layer.rows); + layer.cursor = if (cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null; + layer.cells = try gpa.alloc(pardes.Cell, @as(usize, layer.cols) * layer.rows); for (layer.cells) |*cell| cell.* = try decodeCell(&r); } - try r.end(); + const region_count = try r.takeInt(u16, .little); + if (region_count > pardes.MAX_REGIONS) return error.Overlong; + try regions.ensureTotalCapacity(gpa, region_count); + for (0..region_count) |_| { + var region: pardes.Region = .{ .kind = try getTag(&r, pardes.Region.Kind), .rect = undefined }; + region.owner = try r.takeByte(); + region.serial = try r.takeInt(u32, .little); + region.rect = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .w = try r.takeInt(u16, .little), .h = try r.takeInt(u16, .little) }; + const flags = try r.takeByte(); + if (flags > 3) return error.BadValue; + region.active = flags & 1 != 0; + region.dirty = flags & 2 != 0; + region.thumb_y = try r.takeInt(u16, .little); + region.thumb_h = try r.takeInt(u16, .little); + region.notice = try r.takeByte(); + region.clip = try r.takeInt(u16, .little); + region.lift = @bitCast(try r.takeInt(u32, .little)); + region.line = @bitCast(try r.takeInt(u32, .little)); + // A springy flavour overshoots, and a wind-up dips below. + if (!(region.lift >= -1 and region.lift <= 2)) return error.BadValue; + if (region.rect.x > f.cols or region.rect.w > f.cols - region.rect.x or + region.rect.y > f.rows or region.rect.h > f.rows - region.rect.y or + region.clip > region.rect.w or region.thumb_y > region.rect.h or region.thumb_h > region.rect.h - region.thumb_y) return error.BadValue; + regions.appendAssumeCapacity(region); + } + const info = @typeInfo(pardes.Chrome).@"struct"; + inline for (info.field_names, info.field_types) |name, T| { + const rgb = &@field(chrome, name); + if (T == ?[3]u8) { + if (try getBool(&r)) { + rgb.* = .{ 0, 0, 0 }; + for (&rgb.*.?) |*channel| channel.* = try r.takeByte(); + } + } else if (T == u8) { + rgb.* = try r.takeByte(); + } else if (T == u32) { + rgb.* = try r.takeInt(u32, .little); + } else if (T == f32) { + rgb.* = @bitCast(try r.takeInt(u32, .little)); + if (!std.math.isFinite(rgb.*)) return error.BadValue; + } else if (T == [8]f32) { + for (rgb) |*value| { + value.* = @bitCast(try r.takeInt(u32, .little)); + if (!std.math.isFinite(value.*)) return error.BadValue; + } + } else for (rgb) |*channel| channel.* = try r.takeByte(); + } + try end(&r); } /// Paint this frame into `grid`, which must be exactly `cols * rows` cells @@ -239,12 +323,12 @@ pub const Frame = struct { pub fn apply(f: Frame, grid: []pardes.Cell) Error!void { if (grid.len != @as(usize, f.cols) * @as(usize, f.rows)) return error.BadValue; if (f.kind == .full) @memset(grid, .{}); - var r: Reader = .init(f.runs); + var r: std.Io.Reader = .fixed(f.runs); var i: u32 = 0; while (i < f.nruns) : (i += 1) { - const start = try r.getU32(); - const count = try r.getU16(); - // A zero-length run is not something `encodeFrame` emits, and + const start = try r.takeInt(u32, .little); + const count = try r.takeInt(u16, .little); + // A zero-length run is not something `encodeFrameLayers` emits, and // accepting one would let a peer spend the run budget saying // nothing. if (count == 0) return error.BadValue; @@ -254,7 +338,7 @@ pub const Frame = struct { if (start > grid.len or count > grid.len - start) return error.Overlong; for (grid[start..][0..count]) |*c| c.* = try decodeCell(&r); } - try r.end(); + try end(&r); } }; @@ -281,175 +365,115 @@ pub const ServerMsg = union(enum) { set_clipboard: []const u8, read_clipboard, open_link: []const u8, + post: Post, }; -// --------------------------------------------------------------------------- -// primitives -// --------------------------------------------------------------------------- - -pub const Writer = struct { - buf: []u8, - n: usize = 0, - - pub fn init(buf: []u8) Writer { - return .{ .buf = buf }; - } - - pub fn written(w: *const Writer) []const u8 { - return w.buf[0..w.n]; - } - - fn room(w: *Writer, k: usize) Error![]u8 { - if (w.buf.len - w.n < k) return error.NoSpace; - defer w.n += k; - return w.buf[w.n..][0..k]; - } - - fn putByte(w: *Writer, v: u8) Error!void { - (try w.room(1))[0] = v; - } - - fn putU16(w: *Writer, v: u16) Error!void { - std.mem.writeInt(u16, (try w.room(2))[0..2], v, .little); - } - - fn putU32(w: *Writer, v: u32) Error!void { - std.mem.writeInt(u32, (try w.room(4))[0..4], v, .little); - } - - /// One byte, 0 or 1, never "nonzero". `getBool` refuses anything else. - fn putBool(w: *Writer, v: bool) Error!void { - try w.putByte(@intFromBool(v)); - } - - /// IEEE-754 binary32, as its bit pattern in an explicit u32. A scalar - /// bitcast and not a struct blit: the format is the one thing a riscv32 - /// and an x86_64 do agree about. - fn putF32(w: *Writer, v: f32) Error!void { - try w.putU32(@bitCast(v)); - } - - fn putBytes(w: *Writer, v: []const u8) Error!void { - @memcpy(try w.room(v.len), v); - } - - /// Length-prefixed, u16: paths, command lines, a key's text. Nothing here - /// is legitimately longer than 64 KiB and a u16 says so on the wire. - fn putSlice16(w: *Writer, v: []const u8) Error!void { - if (v.len > std.math.maxInt(u16)) return error.Overlong; - try w.putU16(@intCast(v.len)); - try w.putBytes(v); - } +/// The session's post chain, as a GUI attached to it draws it: its passes in +/// order, each a bundled scene at its level or a Shadertoy file's SPIR-V +/// (compiled by the session, ShaderBuild.zig: a frontend reads no disk and +/// runs no program), and when it animates on its own. Slices borrow the +/// payload. +pub const Post = struct { + animation: ShaderAnimation = .on, + passes: [ShaderBuild.max]ShaderBuild.Pass = @splat(.{}), + len: u8 = 0, - /// ...and u32 for the ones that are: pty output, a paste, a file. - fn putSlice32(w: *Writer, v: []const u8) Error!void { - if (v.len > max_payload) return error.Overlong; - try w.putU32(@intCast(v.len)); - try w.putBytes(v); + pub fn list(p: *const Post) []const ShaderBuild.Pass { + return p.passes[0..p.len]; } }; -pub const Reader = struct { - bytes: []const u8, - i: usize = 0, - - pub fn init(bytes: []const u8) Reader { - return .{ .bytes = bytes }; - } - - /// `i <= bytes.len` is the invariant every getter below preserves, which is - /// what makes the subtraction here safe. - fn take(r: *Reader, n: usize) Error![]const u8 { - if (r.bytes.len - r.i < n) return error.Truncated; - defer r.i += n; - return r.bytes[r.i..][0..n]; - } - - fn getByte(r: *Reader) Error!u8 { - return (try r.take(1))[0]; - } - - fn getU16(r: *Reader) Error!u16 { - return std.mem.readInt(u16, (try r.take(2))[0..2], .little); - } +// --------------------------------------------------------------------------- +// primitives +// --------------------------------------------------------------------------- - fn getU32(r: *Reader) Error!u32 { - return std.mem.readInt(u32, (try r.take(4))[0..4], .little); - } +/// Length-prefixed, u16: paths, command lines, a key's text. Nothing here +/// is legitimately longer than 64 KiB and a u16 says so on the wire. +fn putSlice16(w: *std.Io.Writer, v: []const u8) Error!void { + if (v.len > std.math.maxInt(u16)) return error.Overlong; + try w.writeInt(u16, @intCast(v.len), .little); + try w.writeAll(v); +} - fn getBool(r: *Reader) Error!bool { - return switch (try r.getByte()) { - 0 => false, - 1 => true, - else => error.BadValue, - }; - } +/// ...and u32 for the ones that are: pty output, a paste, a file. +fn putSlice32(w: *std.Io.Writer, v: []const u8) Error!void { + if (v.len > max_payload) return error.Overlong; + try w.writeInt(u32, @intCast(v.len), .little); + try w.writeAll(v); +} - fn getF32(r: *Reader) Error!f32 { - const v: f32 = @bitCast(try r.getU32()); - // A NaN or an infinity here is not a scroll distance. `pinch` in - // particular multiplies into a zoom factor the pane keeps, so one bad - // value poisons that pane for the rest of the session. - if (!std.math.isFinite(v)) return error.BadValue; - return v; - } +/// One byte, 0 or 1, never "nonzero": the writer's `@intFromBool`. +fn getBool(r: *std.Io.Reader) Error!bool { + return switch (try r.takeByte()) { + 0 => false, + 1 => true, + else => error.BadValue, + }; +} - fn getSlice16(r: *Reader) Error![]const u8 { - return r.take(try r.getU16()); - } +/// IEEE-754 binary32, as its bit pattern in an explicit u32. A scalar +/// bitcast and not a struct blit: the format is the one thing a riscv32 +/// and an x86_64 do agree about. +fn getF32(r: *std.Io.Reader) Error!f32 { + const v: f32 = @bitCast(try r.takeInt(u32, .little)); + // A NaN or an infinity here is not a scroll distance. `pinch` in + // particular multiplies into a zoom factor the pane keeps, so one bad + // value poisons that pane for the rest of the session. + if (!std.math.isFinite(v)) return error.BadValue; + return v; +} - fn getSlice32(r: *Reader) Error![]const u8 { - const n = try r.getU32(); - if (n > max_payload) return error.Overlong; - return r.take(n); - } +fn getSlice32(r: *std.Io.Reader) Error![]const u8 { + const n = try r.takeInt(u32, .little); + if (n > max_payload) return error.Overlong; + return r.take(n); +} - /// A pane id the core can actually index. `Event.output{ .pane = 200 }` - /// would reach `p.panes[200]`. - fn getPane(r: *Reader) Error!u8 { - const pane = try r.getByte(); - if (pane >= pardes.MAX_PANES) return error.BadValue; - return pane; - } +/// A pane id the core can actually index. `Event.output{ .pane = 200 }` +/// would reach `p.panes[200]`. +fn getPane(r: *std.Io.Reader) Error!u8 { + const pane = try r.takeByte(); + if (pane >= pardes.MAX_PANES) return error.BadValue; + return pane; +} - /// A grid the core can render into. Zero is refused rather than clamped: a - /// frontend that has not been sized yet must not be allowed to collapse a - /// shared session to nothing (see server.zig `geometry`). - fn getCols(r: *Reader) Error!u16 { - const v = try r.getU16(); - if (v == 0 or v > max_cols) return error.BadValue; - return v; - } +/// A grid the core can render into. Zero is refused rather than clamped: a +/// frontend that has not been sized yet must not be allowed to collapse a +/// shared session to nothing (see server.zig `geometry`). +fn getCols(r: *std.Io.Reader) Error!u16 { + const v = try r.takeInt(u16, .little); + if (v == 0 or v > max_cols) return error.BadValue; + return v; +} - fn getRows(r: *Reader) Error!u16 { - const v = try r.getU16(); - if (v == 0 or v > max_rows) return error.BadValue; - return v; - } +fn getRows(r: *std.Io.Reader) Error!u16 { + const v = try r.takeInt(u16, .little); + if (v == 0 or v > max_rows) return error.BadValue; + return v; +} - fn getTag(r: *Reader, comptime T: type) Error!T { - return std.enums.fromInt(T, try r.getByte()) orelse error.BadTag; - } +fn getTag(r: *std.Io.Reader, comptime T: type) Error!T { + return std.enums.fromInt(T, try r.takeByte()) orelse error.BadTag; +} - fn end(r: *Reader) Error!void { - if (r.i != r.bytes.len) return error.Trailing; - } -}; +fn end(r: *std.Io.Reader) Error!void { + if (r.seek != r.end) return error.Trailing; +} /// Reserve a message header; `finishMessage` back-patches the length. Two /// passes would mean walking a frame's runs twice to find out how long they /// are, and the walk is the expensive half. -fn beginMessage(w: *Writer, tag: u8) Error!usize { - const at = w.n; - try w.putByte(tag); - try w.putU32(0); +fn beginMessage(w: *std.Io.Writer, tag: u8) Error!usize { + const at = w.end; + try w.writeByte(tag); + try w.writeInt(u32, 0, .little); return at; } -fn finishMessage(w: *Writer, at: usize) Error!void { - const len = w.n - at - header_len; +fn finishMessage(w: *std.Io.Writer, at: usize) Error!void { + const len = w.end - at - header_len; if (len > max_payload) return error.Overlong; - std.mem.writeInt(u32, w.buf[at + 1 ..][0..4], @intCast(len), .little); + std.mem.writeInt(u32, w.buffer[at + 1 ..][0..4], @intCast(len), .little); } /// One complete message at the front of a stream buffer, or null when the rest @@ -470,24 +494,24 @@ pub fn framed(buf: []const u8) Error!?Framed { // cells // --------------------------------------------------------------------------- -fn putColor(w: *Writer, c: pardes.Color) Error!void { +fn putColor(w: *std.Io.Writer, c: pardes.Color) Error!void { switch (c) { - .default => try w.putByte(@intFromEnum(ColorTag.default)), + .default => try w.writeByte(@backingInt(ColorTag.default)), .index => |i| { - try w.putByte(@intFromEnum(ColorTag.index)); - try w.putByte(i); + try w.writeByte(@backingInt(ColorTag.index)); + try w.writeByte(i); }, .rgb => |v| { - try w.putByte(@intFromEnum(ColorTag.rgb)); - try w.putBytes(&v); + try w.writeByte(@backingInt(ColorTag.rgb)); + try w.writeAll(&v); }, } } -fn getColor(r: *Reader) Error!pardes.Color { - return switch (try r.getTag(ColorTag)) { +fn getColor(r: *std.Io.Reader) Error!pardes.Color { + return switch (try getTag(r, ColorTag)) { .default => .default, - .index => .{ .index = try r.getByte() }, + .index => .{ .index = try r.takeByte() }, .rgb => .{ .rgb = (try r.take(3))[0..3].* }, }; } @@ -506,32 +530,32 @@ const Ul = @FieldType(pardes.CellStyle, "ul"); /// which is the whole property the six hand-written switches this replaced /// existed for, in a form that cannot fall out of step. A variant that has to /// travel under a DIFFERENT name than the core's gets an arm of its own before -/// the `inline else`, exactly as `clientTag` keeps `.fs_req`. -fn putUl(w: *Writer, u: Ul) Error!void { - try w.putByte(switch (u) { - inline else => |t| @intFromEnum(@field(UlTag, @tagName(t))), +/// the `inline else`, exactly as `clientTag` keeps the machine-local reports. +fn putUl(w: *std.Io.Writer, u: Ul) Error!void { + try w.writeByte(switch (u) { + inline else => |t| @backingInt(@field(UlTag, @tagName(t))), }); } -fn getUl(r: *Reader) Error!Ul { - return switch (try r.getTag(UlTag)) { +fn getUl(r: *std.Io.Reader) Error!Ul { + return switch (try getTag(r, UlTag)) { inline else => |t| @field(Ul, @tagName(t)), }; } -fn putFont(w: *Writer, f: pardes.FontRole) Error!void { - try w.putByte(switch (f) { - inline else => |t| @intFromEnum(@field(FontTag, @tagName(t))), +fn putFont(w: *std.Io.Writer, f: pardes.FontRole) Error!void { + try w.writeByte(switch (f) { + inline else => |t| @backingInt(@field(FontTag, @tagName(t))), }); } -fn getFont(r: *Reader) Error!pardes.FontRole { - return switch (try r.getTag(FontTag)) { +fn getFont(r: *std.Io.Reader) Error!pardes.FontRole { + return switch (try getTag(r, FontTag)) { inline else => |t| @field(pardes.FontRole, @tagName(t)), }; } -/// How many bytes `putCell` will write. Exact, because `encodeFrame` weighs it +/// How many bytes `putCell` will write. Exact, because `encodeFrameLayers` weighs it /// against `run_header` to decide whether to coalesce a run across it. fn cellSize(c: *const pardes.Cell) usize { if (c.default) return 1; @@ -547,13 +571,13 @@ fn colorSize(c: pardes.Color) usize { } /// An unpainted cell is ONE byte: `default` means "the shell renders the -/// terminal's default cell" (pardes.zig `Cell`), so its text and style are not +/// terminal's default cell" (surface.zig `Cell`), so its text and style are not /// merely equal to the defaults, they are not part of the frame at all. -fn putCell(w: *Writer, c: *const pardes.Cell) Error!void { - try w.putBool(c.default); +fn putCell(w: *std.Io.Writer, c: *const pardes.Cell) Error!void { + try w.writeByte(@intFromBool(c.default)); if (c.default) return; - try w.putByte(c.len); - try w.putBytes(c.grapheme()); + try w.writeByte(c.len); + try w.writeAll(c.grapheme()); const s = c.style; try putColor(w, s.fg); try putColor(w, s.bg); @@ -565,15 +589,15 @@ fn putCell(w: *Writer, c: *const pardes.Cell) Error!void { if (s.reverse) attrs |= attr_reverse; if (s.invisible) attrs |= attr_invisible; if (s.strikethrough) attrs |= attr_strikethrough; - try w.putByte(attrs); + try w.writeByte(attrs); try putUl(w, s.ul); try putFont(w, s.font_role); } -fn decodeCell(r: *Reader) Error!pardes.Cell { - if (try r.getBool()) return .{}; +fn decodeCell(r: *std.Io.Reader) Error!pardes.Cell { + if (try getBool(r)) return .{}; var c: pardes.Cell = .{ .default = false }; - const len = try r.getByte(); + const len = try r.takeByte(); // `Cell.text` is 7 bytes and `grapheme()` slices to `len`. A zero-length // grapheme is a cell with nothing to draw and no way to advance a column. if (len == 0 or len > c.text.len) return error.BadValue; @@ -581,7 +605,7 @@ fn decodeCell(r: *Reader) Error!pardes.Cell { @memcpy(c.text[0..len], try r.take(len)); c.style.fg = try getColor(r); c.style.bg = try getColor(r); - const attrs = try r.getByte(); + const attrs = try r.takeByte(); if (attrs & attr_reserved != 0) return error.BadValue; c.style.bold = attrs & attr_bold != 0; c.style.dim = attrs & attr_dim != 0; @@ -599,24 +623,24 @@ fn decodeCell(r: *Reader) Error!pardes.Cell { // frames // --------------------------------------------------------------------------- -fn putCursor(w: *Writer, cursor: ?Cursor, cols: u16, rows: u16) Error!void { +fn putCursor(w: *std.Io.Writer, cursor: ?Cursor, cols: u16, rows: u16) Error!void { // Fixed six bytes whether or not there is a cursor. An optional field // would save five bytes on a message that is already hundreds, and cost a // branch on both sides of the wire. - try w.putBool(cursor != null); + try w.writeByte(@intFromBool(cursor != null)); const c = cursor orelse Cursor{ .x = 0, .y = 0, .bar = false }; // Refused here as well as on decode, so this side cannot build a frame its // own decoder rejects: a dropped frame (sendFrame logs it) leaves a stale // screen, and a refused one takes the frontend's connection with it. if (c.x >= cols or c.y >= rows) return error.BadValue; - try w.putU16(c.x); - try w.putU16(c.y); - try w.putBool(c.bar); + try w.writeInt(u16, c.x, .little); + try w.writeInt(u16, c.y, .little); + try w.writeByte(@intFromBool(c.bar)); } -fn getCursor(r: *Reader, cols: u16, rows: u16) Error!?Cursor { - const present = try r.getBool(); - const c: Cursor = .{ .x = try r.getU16(), .y = try r.getU16(), .bar = try r.getBool() }; +fn getCursor(r: *std.Io.Reader, cols: u16, rows: u16) Error!?Cursor { + const present = try getBool(r); + const c: Cursor = .{ .x = try r.takeInt(u16, .little), .y = try r.takeInt(u16, .little), .bar = try getBool(r) }; // THE cursor bounds check. Every other field of a frame is checked against // the grid and these two were not, and they are the two a frontend indexes // with directly — `Surface.at(cursor.x, cursor.y)` on a grid this frame @@ -628,6 +652,22 @@ fn getCursor(r: *Reader, cols: u16, rows: u16) Error!?Cursor { return if (present) c else null; } +pub fn layersBound(layers: []const pardes.Layer, tags: []const pardes.Layer, regions: []const pardes.Region) usize { + var n: usize = 6; + for (layers) |layer| if (layer.rows != 0) { + n += 26 + layer.context_rows + layer.cells.len * cell_max; + }; + for (tags) |layer| if (layer.rows != 0) { + n += 28 + layer.cells.len * cell_max; + }; + return n + regions.len * region_len + chrome_len; +} + +const region_len = 1 + 1 + 4 + 8 + 1 + 2 + 2 + 1 + 2 + 4 + 4; +/// The palette: each colour three bytes, a theme's optional ones a flag +/// before them. +const chrome_len = @typeInfo(pardes.Chrome).@"struct".field_names.len * 4 + 8 * 4; + /// Encode one frame of `cells`, as a DIFF against `prev` when `prev` is the /// same grid this receiver last acknowledged, and as a FULL frame otherwise. /// @@ -649,41 +689,7 @@ fn getCursor(r: *Reader, cols: u16, rows: u16) Error!?Cursor { /// own 56x14 grid with uncoloured cells, where it is exact: 6298 against 56. /// This transport exists for a frontend on the far end of a slow link, and /// shipping the Surface every frame would be 3 MiB/s at the animation tick. -pub fn encodeFrame( - out: []u8, - cols: u16, - rows: u16, - cursor: ?Cursor, - cells: []const pardes.Cell, - prev: []const pardes.Cell, -) Error![]const u8 { - return encodeFramePointer(out, cols, rows, cursor, .arrow, cells, prev); -} - -pub fn encodeFramePointer( - out: []u8, - cols: u16, - rows: u16, - cursor: ?Cursor, - pointer_shape: pardes.Surface.PointerShape, - cells: []const pardes.Cell, - prev: []const pardes.Cell, -) Error![]const u8 { - return encodeFrameLayers(out, cols, rows, cursor, pointer_shape, cells, prev, &.{}, &.{}); -} - -pub fn layersBound(layers: []const pardes.BodyLayer, tags: []const pardes.TagLayer) usize { - var n: usize = 4; - for (layers) |layer| if (layer.rows != 0) { - n += 26 + layer.context_rows + layer.cells.len * cell_max; - }; - for (tags) |layer| if (layer.cols != 0) { - n += 26 + layer.cells.len * cell_max; - }; - return n; -} - -pub fn encodeFrameLayers(out: []u8, cols: u16, rows: u16, cursor: ?Cursor, pointer_shape: pardes.Surface.PointerShape, cells: []const pardes.Cell, prev: []const pardes.Cell, layers: []const pardes.BodyLayer, tags: []const pardes.TagLayer) Error![]const u8 { +pub fn encodeFrameLayers(out: []u8, cols: u16, rows: u16, cursor: ?Cursor, pointer_shape: pardes.Surface.PointerShape, cells: []const pardes.Cell, prev: []const pardes.Cell, layers: []const pardes.Layer, tags: []const pardes.Layer, regions: []const pardes.Region, chrome: pardes.Chrome) Error![]const u8 { // The protocol's ceiling, enforced by the ENCODER too, and BEFORE the // assert below so a caller can be told rather than tripped. `max_payload` // is derived from these two, so a larger grid is a frame this decoder @@ -692,65 +698,99 @@ pub fn encodeFrameLayers(out: []u8, cols: u16, rows: u16, cursor: ?Cursor, point if (cols == 0 or cols > max_cols or rows == 0 or rows > max_rows) return error.Overlong; std.debug.assert(cells.len == @as(usize, cols) * @as(usize, rows)); const full = prev.len != cells.len; - var w: Writer = .init(out); - const at = try beginMessage(&w, @intFromEnum(ServerTag.frame)); + var w: std.Io.Writer = .fixed(out); + const at = try beginMessage(&w, @backingInt(ServerTag.frame)); const header: FrameHeader = if (pointer_shape == .link) (if (full) .full_link else .diff_link) else (if (full) .full else .diff); - try w.putByte(@intFromEnum(header)); - try w.putU16(cols); - try w.putU16(rows); + try w.writeByte(@backingInt(header)); + try w.writeInt(u16, cols, .little); + try w.writeInt(u16, rows, .little); try putCursor(&w, cursor, cols, rows); - const layers_len_at = w.n; - try w.putU32(0); - const layers_start = w.n; - if (layers.len != 0 or tags.len != 0) { + const layers_len_at = w.end; + try w.writeInt(u32, 0, .little); + const layers_start = w.end; + if (layers.len != 0 or tags.len != 0 or regions.len != 0) { var count: u16 = 0; for (layers) |layer| if (layer.rows != 0) { count += 1; }; - try w.putU16(count); + try w.writeInt(u16, count, .little); for (layers) |layer| { if (layer.rows == 0) continue; if (layer.context_rows > limits.wrap_rows or layer.context_rows > layer.rows) return error.BadValue; - try w.putU16(layer.pane); - try w.putU32(layer.serial); - try w.putU16(layer.viewport.x); - try w.putU16(layer.viewport.y); - try w.putU16(layer.viewport.w); - try w.putU16(layer.viewport.h); - try w.putU16(layer.cols); - try w.putU16(layer.rows); - try w.putU16(layer.context_rows); - for (0..layer.context_rows) |row| try w.putBool(layer.context_separators.isSet(row)); + try w.writeInt(u16, layer.id, .little); + try w.writeInt(u32, layer.serial, .little); + try w.writeInt(u16, layer.viewport.x, .little); + try w.writeInt(u16, layer.viewport.y, .little); + try w.writeInt(u16, layer.viewport.w, .little); + try w.writeInt(u16, layer.viewport.h, .little); + try w.writeInt(u16, layer.cols, .little); + try w.writeInt(u16, layer.rows, .little); + try w.writeInt(u16, layer.context_rows, .little); + for (0..layer.context_rows) |row| try w.writeByte(@intFromBool(layer.context_separators.isSet(row))); try putCursor(&w, if (layer.cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null, layer.cols, layer.rows); for (layer.cells) |*cell| try putCell(&w, cell); } var tag_count: u16 = 0; - for (tags) |layer| if (layer.cols != 0) { + for (tags) |layer| if (layer.rows != 0) { tag_count += 1; }; - try w.putU16(tag_count); + try w.writeInt(u16, tag_count, .little); for (tags) |layer| { - if (layer.cols == 0) continue; - if (layer.cells.len != layer.cols) return error.BadValue; - try w.putByte(@intFromEnum(layer.kind)); - try w.putU16(layer.id); - try w.putU32(layer.serial); - try w.putU16(layer.viewport.x); - try w.putU16(layer.viewport.y); - try w.putU16(layer.viewport.w); - try w.putU16(layer.viewport.h); - try w.putU16(layer.cols); - for (layer.bg) |channel| try w.putByte(channel); - try putCursor(&w, if (layer.cursor) |c| .{ .x = c.col, .y = 0, .bar = c.bar } else null, layer.cols, 1); + if (layer.rows == 0) continue; + if (layer.cells.len != @as(usize, layer.cols) * layer.rows) return error.BadValue; + try w.writeByte(@backingInt(layer.kind)); + try w.writeInt(u16, layer.id, .little); + try w.writeInt(u32, layer.serial, .little); + try w.writeInt(u16, layer.viewport.x, .little); + try w.writeInt(u16, layer.viewport.y, .little); + try w.writeInt(u16, layer.viewport.w, .little); + try w.writeInt(u16, layer.viewport.h, .little); + try w.writeInt(u16, layer.cols, .little); + try w.writeInt(u16, layer.rows, .little); + for (layer.bg) |channel| try w.writeByte(channel); + try putCursor(&w, if (layer.cursor) |c| .{ .x = c.x, .y = c.y, .bar = c.bar } else null, layer.cols, layer.rows); for (layer.cells) |*cell| try putCell(&w, cell); } + try w.writeInt(u16, @intCast(regions.len), .little); + for (regions) |region| { + try w.writeByte(@backingInt(region.kind)); + try w.writeByte(region.owner); + try w.writeInt(u32, region.serial, .little); + try w.writeInt(u16, region.rect.x, .little); + try w.writeInt(u16, region.rect.y, .little); + try w.writeInt(u16, region.rect.w, .little); + try w.writeInt(u16, region.rect.h, .little); + try w.writeByte(@as(u8, @intFromBool(region.active)) | @as(u8, @intFromBool(region.dirty)) << 1); + try w.writeInt(u16, region.thumb_y, .little); + try w.writeInt(u16, region.thumb_h, .little); + try w.writeByte(region.notice); + try w.writeInt(u16, region.clip, .little); + try w.writeInt(u32, @bitCast(region.lift), .little); + try w.writeInt(u32, @bitCast(region.line), .little); + } + const info = @typeInfo(pardes.Chrome).@"struct"; + inline for (info.field_names, info.field_types) |name, T| { + const rgb = @field(chrome, name); + if (T == ?[3]u8) { + try w.writeByte(@intFromBool(rgb != null)); + if (rgb) |value| for (value) |channel| try w.writeByte(channel); + } else if (T == u8) { + try w.writeByte(rgb); + } else if (T == u32) { + try w.writeInt(u32, rgb, .little); + } else if (T == f32) { + try w.writeInt(u32, @bitCast(rgb), .little); + } else if (T == [8]f32) { + for (rgb) |value| try w.writeInt(u32, @bitCast(value), .little); + } else for (rgb) |channel| try w.writeByte(channel); + } } - std.mem.writeInt(u32, w.buf[layers_len_at..][0..4], @intCast(w.n - layers_start), .little); - const nruns_at = w.n; - try w.putU32(0); + std.mem.writeInt(u32, w.buffer[layers_len_at..][0..4], @intCast(w.end - layers_start), .little); + const nruns_at = w.end; + try w.writeInt(u32, 0, .little); var nruns: u32 = 0; var i: usize = 0; @@ -787,15 +827,15 @@ pub fn encodeFrameLayers(out: []u8, cols: u16, rows: u16, cursor: ?Cursor, point if (j >= cells.len or gap >= run_header) break; i = j; } - try w.putU32(@intCast(start)); - try w.putU16(@intCast(run_end - start)); + try w.writeInt(u32, @intCast(start), .little); + try w.writeInt(u16, @intCast(run_end - start), .little); for (cells[start..run_end]) |*c| try putCell(&w, c); nruns += 1; i = run_end; } - std.mem.writeInt(u32, w.buf[nruns_at..][0..4], nruns, .little); + std.mem.writeInt(u32, w.buffer[nruns_at..][0..4], nruns, .little); try finishMessage(&w, at); - return w.written(); + return w.buffered(); } fn sendCell(cells: []const pardes.Cell, prev: []const pardes.Cell, full: bool, i: usize) bool { @@ -816,7 +856,7 @@ fn clientTag(msg: ClientMsg) ClientTag { return switch (msg) { .event => |ev| switch (ev) { // Machine-local reports and 9P requests belong to the session owner. - .output, .eof, .lsp_resp, .pipe_resp, .file_changed, .tick, .fs_req => unreachable, + .output, .eof, .exited, .lsp_resp, .pipe_resp, .search, .file_changed, .handed, .tick => unreachable, inline else => |_, t| @field(ClientTag, @tagName(t)), }, inline else => |_, t| @field(ClientTag, @tagName(t)), @@ -828,64 +868,64 @@ fn clientTag(msg: ClientMsg) ClientTag { /// WIRE is not. const has_cell_pixels = @hasField(pardes.CellPixels, "w"); -fn putMetrics(w: *Writer, metrics: ?pardes.RowMetrics) Error!void { - try w.putBool(metrics != null); +fn putMetrics(w: *std.Io.Writer, metrics: ?pardes.RowMetrics) Error!void { + try w.writeByte(@intFromBool(metrics != null)); if (metrics) |m| { - try w.putU16(m.body_w); - try w.putU16(m.body_h); - try w.putU16(m.tagline_w); - try w.putU16(m.tagline_h); + try w.writeInt(u16, m.body_w, .little); + try w.writeInt(u16, m.body_h, .little); + try w.writeInt(u16, m.tagline_w, .little); + try w.writeInt(u16, m.tagline_h, .little); } } -fn getMetrics(r: *Reader) Error!?pardes.RowMetrics { - if (!try r.getBool()) return null; - const m: pardes.RowMetrics = .{ .body_w = try r.getU16(), .body_h = try r.getU16(), .tagline_w = try r.getU16(), .tagline_h = try r.getU16() }; +fn getMetrics(r: *std.Io.Reader) Error!?pardes.RowMetrics { + if (!try getBool(r)) return null; + const m: pardes.RowMetrics = .{ .body_w = try r.takeInt(u16, .little), .body_h = try r.takeInt(u16, .little), .tagline_w = try r.takeInt(u16, .little), .tagline_h = try r.takeInt(u16, .little) }; if (m.body_w == 0 or m.body_h == 0 or m.tagline_w == 0 or m.tagline_h == 0) return error.BadValue; return m; } -fn putBodyHit(w: *Writer, hit: ?pardes.Mouse.BodyHit) Error!void { - try w.putBool(hit != null); +fn putBodyHit(w: *std.Io.Writer, hit: ?pardes.Mouse.BodyHit) Error!void { + try w.writeByte(@intFromBool(hit != null)); if (hit) |h| { - try w.putU32(h.serial); - try w.putU16(h.row); - try w.putU16(h.col); - try w.putF32(h.pixel_x); - try w.putF32(h.pixel_y); + try w.writeInt(u32, h.serial, .little); + try w.writeInt(u16, h.row, .little); + try w.writeInt(u16, h.col, .little); + try w.writeInt(u32, @bitCast(h.pixel_x), .little); + try w.writeInt(u32, @bitCast(h.pixel_y), .little); try putMetrics(w, h.metrics); } } -fn getBodyHit(r: *Reader) Error!?pardes.Mouse.BodyHit { - if (!try r.getBool()) return null; - const hit: pardes.Mouse.BodyHit = .{ .serial = try r.getU32(), .row = try r.getU16(), .col = try r.getU16(), .pixel_x = try r.getF32(), .pixel_y = try r.getF32(), .metrics = (try getMetrics(r)) orelse return error.BadValue }; +fn getBodyHit(r: *std.Io.Reader) Error!?pardes.Mouse.BodyHit { + if (!try getBool(r)) return null; + const hit: pardes.Mouse.BodyHit = .{ .serial = try r.takeInt(u32, .little), .row = try r.takeInt(u16, .little), .col = try r.takeInt(u16, .little), .pixel_x = try getF32(r), .pixel_y = try getF32(r), .metrics = (try getMetrics(r)) orelse return error.BadValue }; if (!std.math.isFinite(hit.pixel_x) or !std.math.isFinite(hit.pixel_y)) return error.BadValue; return hit; } -fn putTagHit(w: *Writer, hit: ?pardes.TagHit) Error!void { - try w.putBool(hit != null); +fn putTagHit(w: *std.Io.Writer, hit: ?pardes.TagHit) Error!void { + try w.writeByte(@intFromBool(hit != null)); if (hit) |h| { - try w.putByte(@intFromEnum(h.kind)); - try w.putU16(h.id); - try w.putU32(h.serial); - try w.putU16(h.col); - try w.putF32(h.pixel_x); - try w.putF32(h.pixel_y); + try w.writeByte(@backingInt(h.kind)); + try w.writeInt(u16, h.id, .little); + try w.writeInt(u32, h.serial, .little); + try w.writeInt(u16, h.col, .little); + try w.writeInt(u32, @bitCast(h.pixel_x), .little); + try w.writeInt(u32, @bitCast(h.pixel_y), .little); try putMetrics(w, h.metrics); } } -fn getTagHit(r: *Reader) Error!?pardes.TagHit { - if (!try r.getBool()) return null; +fn getTagHit(r: *std.Io.Reader) Error!?pardes.TagHit { + if (!try getBool(r)) return null; const hit: pardes.TagHit = .{ - .kind = try r.getTag(pardes.TagKind), - .id = try r.getU16(), - .serial = try r.getU32(), - .col = try r.getU16(), - .pixel_x = try r.getF32(), - .pixel_y = try r.getF32(), + .kind = try getTag(r, pardes.TagKind), + .id = try r.takeInt(u16, .little), + .serial = try r.takeInt(u32, .little), + .col = try r.takeInt(u16, .little), + .pixel_x = try getF32(r), + .pixel_y = try getF32(r), .metrics = (try getMetrics(r)) orelse return error.BadValue, }; if (!std.math.isFinite(hit.pixel_x) or !std.math.isFinite(hit.pixel_y)) return error.BadValue; @@ -893,117 +933,124 @@ fn getTagHit(r: *Reader) Error!?pardes.TagHit { } pub fn encodeClient(out: []u8, msg: ClientMsg) Error![]const u8 { - var w: Writer = .init(out); - const at = try beginMessage(&w, @intFromEnum(clientTag(msg))); + var w: std.Io.Writer = .fixed(out); + const at = try beginMessage(&w, @backingInt(clientTag(msg))); switch (msg) { .hello => |h| { - try w.putU16(h.version); - try w.putU16(h.cols); - try w.putU16(h.rows); + try w.writeInt(u16, h.version, .little); + try w.writeInt(u16, h.cols, .little); + try w.writeInt(u16, h.rows, .little); }, .bye => {}, .event => |ev| switch (ev) { .key => |k| { - try w.putU32(k.cp); - try w.putSlice16(k.text); - try w.putBool(k.ctrl); - try w.putBool(k.alt); - try w.putBool(k.shift); + try w.writeInt(u32, k.cp, .little); + try putSlice16(&w, k.text); + try w.writeByte(@intFromBool(k.ctrl)); + try w.writeByte(@intFromBool(k.alt)); + try w.writeByte(@intFromBool(k.shift)); }, .mouse => |m| { - try w.putByte(switch (m.button) { - inline else => |t| @intFromEnum(@field(ButtonTag, @tagName(t))), + try w.writeByte(switch (m.button) { + inline else => |t| @backingInt(@field(ButtonTag, @tagName(t))), }); - try w.putByte(switch (m.kind) { - inline else => |t| @intFromEnum(@field(KindTag, @tagName(t))), + try w.writeByte(switch (m.kind) { + inline else => |t| @backingInt(@field(KindTag, @tagName(t))), }); - try w.putU16(m.col); - try w.putU16(m.row); - try w.putBool(m.ctrl); + try w.writeInt(u16, m.col, .little); + try w.writeInt(u16, m.row, .little); + try w.writeByte(@intFromBool(m.ctrl)); + try w.writeByte(@intFromBool(m.shift)); + try w.writeByte(@intFromBool(m.alt)); try putBodyHit(&w, m.body_hit); try putTagHit(&w, m.tag_hit); }, .resize => |rs| { - try w.putU16(rs.cols); - try w.putU16(rs.rows); + try w.writeInt(u16, rs.cols, .little); + try w.writeInt(u16, rs.rows, .little); // The conventional 1:2 cell aspect when this build has no // pixels of its own, which is the same default the field // carries where it exists. - try w.putU16(if (comptime has_cell_pixels) rs.cell_pixels.w else 8); - try w.putU16(if (comptime has_cell_pixels) rs.cell_pixels.h else 16); + try w.writeInt(u16, if (comptime has_cell_pixels) rs.cell_pixels.w else 8, .little); + try w.writeInt(u16, if (comptime has_cell_pixels) rs.cell_pixels.h else 16, .little); try putMetrics(&w, rs.row_metrics); }, - .paste => |b| try w.putSlice32(b), - .command => |line| try w.putSlice16(line), + .paste => |b| try putSlice32(&w, b), + .command => |line| try putSlice16(&w, line), .pdf_scroll => |s| { - try w.putByte(s.pane); - try w.putF32(s.delta_pixels); + try w.writeByte(s.pane); + try w.writeInt(u32, @bitCast(s.delta_pixels), .little); + try w.writeByte(@intFromBool(s.glide)); }, - .pinch => |v| try w.putF32(v), - .touch_scroll => |v| try w.putF32(v), + .pinch => |v| try w.writeInt(u32, @bitCast(v), .little), + .touch_scroll => |v| try w.writeInt(u32, @bitCast(v), .little), .pointer_leave => {}, + .focus => |focused| try w.writeByte(@intFromBool(focused)), // See `clientTag`: no tag, so nothing to encode. - .output, .eof, .lsp_resp, .pipe_resp, .file_changed, .tick, .fs_req => unreachable, + .output, .eof, .exited, .lsp_resp, .pipe_resp, .search, .file_changed, .handed, .tick => unreachable, }, } try finishMessage(&w, at); - return w.written(); + return w.buffered(); } pub fn decodeClient(tag: u8, payload: []const u8) Error!ClientMsg { - var r: Reader = .init(payload); + var r: std.Io.Reader = .fixed(payload); const msg: ClientMsg = switch (std.enums.fromInt(ClientTag, tag) orelse return error.BadTag) { .hello => .{ .hello = .{ - .version = try r.getU16(), - .cols = try r.getCols(), - .rows = try r.getRows(), + .version = try r.takeInt(u16, .little), + .cols = try getCols(&r), + .rows = try getRows(&r), } }, .bye => .bye, .key => blk: { - const cp = try r.getU32(); + const cp = try r.takeInt(u32, .little); // `Key.cp` is a u21, and the specials live in the private-use // plane below this bound. A larger number is not a codepoint and // @intCast of it would panic in a release build's own decoder. if (cp > 0x10FFFF) return error.BadValue; break :blk .{ .event = .{ .key = .{ .cp = @intCast(cp), - .text = try r.getSlice16(), - .ctrl = try r.getBool(), - .alt = try r.getBool(), - .shift = try r.getBool(), + .text = try r.take(try r.takeInt(u16, .little)), + .ctrl = try getBool(&r), + .alt = try getBool(&r), + .shift = try getBool(&r), } } }; }, .mouse => .{ .event = .{ .mouse = .{ - .button = switch (try r.getTag(ButtonTag)) { + .button = switch (try getTag(&r, ButtonTag)) { inline else => |t| @field(pardes.Mouse.Button, @tagName(t)), }, - .kind = switch (try r.getTag(KindTag)) { + .kind = switch (try getTag(&r, KindTag)) { inline else => |t| @field(pardes.Mouse.Kind, @tagName(t)), }, - .col = try r.getU16(), - .row = try r.getU16(), - .ctrl = try r.getBool(), + .col = try r.takeInt(u16, .little), + .row = try r.takeInt(u16, .little), + .ctrl = try getBool(&r), + .shift = try getBool(&r), + .alt = try getBool(&r), .body_hit = try getBodyHit(&r), .tag_hit = try getTagHit(&r), } } }, .resize => blk: { - var ev: pardes.Event = .{ .resize = .{ .cols = try r.getCols(), .rows = try r.getRows() } }; - const px_w = try r.getU16(); - const px_h = try r.getU16(); + var ev: pardes.Event = .{ .resize = .{ .cols = try getCols(&r), .rows = try getRows(&r) } }; + const px_w = try r.takeInt(u16, .little); + const px_h = try r.takeInt(u16, .little); // Read either way — the bytes are on the wire — and kept only by a // build that has somewhere to keep them. if (comptime has_cell_pixels) ev.resize.cell_pixels = .{ .w = px_w, .h = px_h }; ev.resize.row_metrics = try getMetrics(&r); break :blk .{ .event = ev }; }, - .paste => .{ .event = .{ .paste = try r.getSlice32() } }, - .command => .{ .event = .{ .command = try r.getSlice16() } }, - .pdf_scroll => .{ .event = .{ .pdf_scroll = .{ .pane = try r.getPane(), .delta_pixels = try r.getF32() } } }, - .pinch => .{ .event = .{ .pinch = try r.getF32() } }, - .touch_scroll => .{ .event = .{ .touch_scroll = try r.getF32() } }, + .paste => .{ .event = .{ .paste = try getSlice32(&r) } }, + .command => .{ .event = .{ .command = try r.take(try r.takeInt(u16, .little)) } }, + .pdf_scroll => .{ .event = .{ .pdf_scroll = .{ .pane = try getPane(&r), .delta_pixels = try getF32(&r), .glide = try getBool(&r) } } }, + .pinch => .{ .event = .{ .pinch = try getF32(&r) } }, + .touch_scroll => .{ .event = .{ .touch_scroll = try getF32(&r) } }, .pointer_leave => .{ .event = .pointer_leave }, + .focus => .{ .event = .{ .focus = try getBool(&r) } }, }; - try r.end(); + try end(&r); return msg; } @@ -1019,29 +1066,42 @@ fn serverTag(msg: ServerMsg) ServerTag { } /// Every server message EXCEPT a frame, which has its own encoder because its -/// payload is a walk of two grids rather than a value (see `encodeFrame`). +/// payload is a walk of two grids rather than a value (see `encodeFrameLayers`). pub fn encodeServer(out: []u8, msg: ServerMsg) Error![]const u8 { - var w: Writer = .init(out); - const at = try beginMessage(&w, @intFromEnum(serverTag(msg))); + var w: std.Io.Writer = .fixed(out); + const at = try beginMessage(&w, @backingInt(serverTag(msg))); switch (msg) { .welcome => |v| { - try w.putU16(v.version); - try w.putByte(v.slot); - try w.putU16(v.cols); - try w.putU16(v.rows); + try w.writeInt(u16, v.version, .little); + try w.writeByte(v.slot); + try w.writeInt(u16, v.cols, .little); + try w.writeInt(u16, v.rows, .little); }, - .refuse => |why| try w.putByte(@intFromEnum(why)), + .refuse => |why| try w.writeByte(@backingInt(why)), // A frame's runs are not a value this union can hold; the server calls - // encodeFrame directly and this arm exists so the switch stays + // encodeFrameLayers directly and this arm exists so the switch stays // exhaustive over ServerMsg. .frame => return error.BadValue, .quit, .detach => {}, - .set_clipboard => |t| try w.putSlice32(t), + .set_clipboard => |t| try putSlice32(&w, t), .read_clipboard => {}, - .open_link => |u| try w.putSlice16(u), + .open_link => |u| try putSlice16(&w, u), + .post => |p| { + try w.writeByte(@backingInt(p.animation)); + try w.writeByte(p.len); + for (p.list()) |pass| { + // 0 a file, else a bundled scene and one. + try w.writeByte(if (pass.scene) |scene| @as(u8, @backingInt(scene)) + 1 else 0); + try w.writeByte(pass.level); + try w.writeByte(@intFromBool(pass.animated)); + try w.writeInt(u32, pass.revision, .little); + try putSlice16(&w, pass.path); + try putSlice32(&w, pass.spirv); + } + }, } try finishMessage(&w, at); - return w.written(); + return w.buffered(); } /// Slack over a message's variable payload, covering every fixed field any @@ -1060,6 +1120,11 @@ pub fn serverBound(msg: ServerMsg) usize { .frame => |f| frameBound(f.cols, f.rows), .set_clipboard => |t| t.len, .open_link => |u| u.len, + .post => |p| blk: { + var n: usize = 0; + for (p.list()) |pass| n += 13 + pass.path.len + pass.spirv.len; + break :blk n; + }, }; } @@ -1068,44 +1133,44 @@ pub fn clientBound(msg: ClientMsg) usize { return msg_slack + switch (msg) { .hello, .bye => 0, .event => |ev| switch (ev) { - .mouse, .resize, .pdf_scroll, .pinch, .touch_scroll, .pointer_leave => 0, + .mouse, .resize, .pdf_scroll, .pinch, .touch_scroll, .pointer_leave, .focus => 0, .key => |k| k.text.len, .paste => |b| b.len, .command => |line| line.len, // See `clientTag`: not on this wire in this direction. - .output, .eof, .lsp_resp, .pipe_resp, .file_changed, .tick, .fs_req => unreachable, + .output, .eof, .exited, .lsp_resp, .pipe_resp, .search, .file_changed, .handed, .tick => unreachable, }, }; } pub fn decodeServer(tag: u8, payload: []const u8) Error!ServerMsg { - var r: Reader = .init(payload); + var r: std.Io.Reader = .fixed(payload); const msg: ServerMsg = switch (std.enums.fromInt(ServerTag, tag) orelse return error.BadTag) { .welcome => .{ .welcome = .{ - .version = try r.getU16(), - .slot = try r.getByte(), - .cols = try r.getCols(), - .rows = try r.getRows(), + .version = try r.takeInt(u16, .little), + .slot = try r.takeByte(), + .cols = try getCols(&r), + .rows = try getRows(&r), } }, - .refuse => .{ .refuse = try r.getTag(Refusal) }, + .refuse => .{ .refuse = try getTag(&r, Refusal) }, .frame => blk: { - const header = try r.getTag(FrameHeader); + const header = try getTag(&r, FrameHeader); const kind: FrameKind = switch (header) { .full, .full_link => .full, .diff, .diff_link => .diff, }; - const cols = try r.getCols(); - const rows = try r.getRows(); + const cols = try getCols(&r); + const rows = try getRows(&r); const cursor = try getCursor(&r, cols, rows); - const layers = try r.getSlice32(); - const nruns = try r.getU32(); + const layers = try getSlice32(&r); + const nruns = try r.takeInt(u32, .little); // One run per cell is the worst an encoder emits, so a bigger // count cannot be describing this grid. Checked HERE rather than // in `apply`'s loop so the number is refused before it is used to // bound anything. if (nruns > @as(u32, cols) * @as(u32, rows)) return error.Overlong; - const runs = r.bytes[r.i..]; - r.i = r.bytes.len; + const runs = r.buffered(); + r.tossBuffered(); break :blk .{ .frame = .{ .layers = layers, .kind = kind, @@ -1119,11 +1184,32 @@ pub fn decodeServer(tag: u8, payload: []const u8) Error!ServerMsg { }, .quit => .quit, .detach => .detach, - .set_clipboard => .{ .set_clipboard = try r.getSlice32() }, + .set_clipboard => .{ .set_clipboard = try getSlice32(&r) }, .read_clipboard => .read_clipboard, - .open_link => .{ .open_link = try r.getSlice16() }, + .open_link => .{ .open_link = try r.take(try r.takeInt(u16, .little)) }, + .post => blk: { + var p: Post = .{ .animation = try getTag(&r, ShaderAnimation) }; + p.len = try r.takeByte(); + if (p.len > ShaderBuild.max) return error.Overlong; + for (p.passes[0..p.len]) |*pass| { + const kind = try r.takeByte(); + pass.* = .{ + .scene = if (kind == 0) null else std.enums.fromInt(Scene, kind - 1) orelse return error.BadValue, + .level = try r.takeByte(), + .animated = switch (try r.takeByte()) { + 0 => false, + 1 => true, + else => return error.BadValue, + }, + .revision = try r.takeInt(u32, .little), + .path = try r.take(try r.takeInt(u16, .little)), + .spirv = try getSlice32(&r), + }; + } + break :blk .{ .post = p }; + }, }; - try r.end(); + try end(&r); return msg; } @@ -1160,9 +1246,9 @@ test "detached wire: every Event variant round-trips" { // The tag space is the protocol's own, so assert the numbers themselves: // a renumbering here breaks every deployed frontend and must be a diff // somebody reads, not a silent change. - try testing.expectEqual(@as(u8, 0x01), @intFromEnum(ClientTag.hello)); - try testing.expectEqual(@as(u8, 0x10), @intFromEnum(ClientTag.key)); - try testing.expectEqual(@as(u8, 0x1d), @intFromEnum(ClientTag.pointer_leave)); + try testing.expectEqual(@as(u8, 0x01), @backingInt(ClientTag.hello)); + try testing.expectEqual(@as(u8, 0x10), @backingInt(ClientTag.key)); + try testing.expectEqual(@as(u8, 0x1d), @backingInt(ClientTag.pointer_leave)); { const got = try roundClient(&buf, .{ .hello = .{ .cols = 80, .rows = 24 } }); @@ -1186,13 +1272,15 @@ test "detached wire: every Event variant round-trips" { // the only place a value can be mistranslated and still decode. for (std.enums.values(pardes.Mouse.Button)) |button| { for (std.enums.values(pardes.Mouse.Kind)) |kind| { - const m: pardes.Mouse = .{ .button = button, .kind = kind, .col = 4200, .row = 7, .ctrl = true }; + const m: pardes.Mouse = .{ .button = button, .kind = kind, .col = 4200, .row = 7, .ctrl = true, .shift = true, .alt = true }; const got = (try roundClient(&buf, .{ .event = .{ .mouse = m } })).event.mouse; try testing.expectEqual(m.button, got.button); try testing.expectEqual(m.kind, got.kind); try testing.expectEqual(m.col, got.col); try testing.expectEqual(m.row, got.row); try testing.expectEqual(m.ctrl, got.ctrl); + try testing.expectEqual(m.shift, got.shift); + try testing.expectEqual(m.alt, got.alt); } } } @@ -1210,9 +1298,10 @@ test "detached wire: every Event variant round-trips" { try testing.expectEqualStrings("clip", (try roundClient(&buf, .{ .event = .{ .paste = "clip" } })).event.paste); try testing.expectEqualStrings("Look /x", (try roundClient(&buf, .{ .event = .{ .command = "Look /x" } })).event.command); { - const got = (try roundClient(&buf, .{ .event = .{ .pdf_scroll = .{ .pane = 2, .delta_pixels = -12.5 } } })).event.pdf_scroll; + const got = (try roundClient(&buf, .{ .event = .{ .pdf_scroll = .{ .pane = 2, .delta_pixels = -12.5, .glide = false } } })).event.pdf_scroll; try testing.expectEqual(@as(u8, 2), got.pane); try testing.expectEqual(@as(f32, -12.5), got.delta_pixels); + try testing.expect(!got.glide); } try testing.expectEqual(@as(f32, 1.25), (try roundClient(&buf, .{ .event = .{ .pinch = 1.25 } })).event.pinch); try testing.expectEqual(@as(f32, -0.75), (try roundClient(&buf, .{ .event = .{ .touch_scroll = -0.75 } })).event.touch_scroll); @@ -1239,6 +1328,19 @@ test "detached wire: every server message round-trips" { try testing.expectEqualStrings("yank", (try roundServer(&buf, .{ .set_clipboard = "yank" })).set_clipboard); try testing.expectEqual(ServerMsg.read_clipboard, try roundServer(&buf, .read_clipboard)); try testing.expectEqualStrings("https://x", (try roundServer(&buf, .{ .open_link = "https://x" })).open_link); + var chain: Post = .{ .animation = .always, .len = 2 }; + chain.passes[0] = .{ .scene = .bloom, .level = 3 }; + chain.passes[1] = .{ .path = "~/wave.glsl", .spirv = "\x03\x02\x23\x07spirv", .revision = 7, .animated = true }; + const back = (try roundServer(&buf, .{ .post = chain })).post; + try testing.expectEqual(ShaderAnimation.always, back.animation); + try testing.expectEqual(@as(u8, 2), back.len); + try testing.expectEqual(Scene.bloom, back.passes[0].scene.?); + try testing.expectEqual(@as(u8, 3), back.passes[0].level); + try testing.expect(back.passes[1].scene == null); + try testing.expectEqualStrings("~/wave.glsl", back.passes[1].path); + try testing.expectEqualStrings("\x03\x02\x23\x07spirv", back.passes[1].spirv); + try testing.expectEqual(@as(u32, 7), back.passes[1].revision); + try testing.expect(back.passes[1].animated and !back.passes[0].animated); } test "detached wire: only the display's own effects are on the wire" { @@ -1247,9 +1349,9 @@ test "detached wire: only the display's own effects are on the wire" { // is the direction that matters: it would hand a frontend work that must // outlive it. The count fails if one of the three is dropped, which would // silently leave a clipboard or a link unanswered on every frontend. - try testing.expectEqual(@as(usize, 8), std.enums.values(ServerTag).len); + try testing.expectEqual(@as(usize, 9), std.enums.values(ServerTag).len); for (std.enums.values(ServerTag)) |t| switch (t) { - .welcome, .refuse, .frame, .quit, .detach, .set_clipboard, .read_clipboard, .open_link => {}, + .welcome, .refuse, .frame, .quit, .detach, .set_clipboard, .read_clipboard, .open_link, .post => {}, }; } @@ -1265,7 +1367,7 @@ test "detached wire: a session is never told to do a frontend's remembering" { // Adding a name here is meant to be an ARGUMENT, not a formality, and the // bar is one sentence: A HUMAN DID IT. A keystroke, a click, a pinch, a // window resized, a paste, a command line executed, a pointer leaving the - // window — plus the two session words that say who is speaking. A pty's + // window, the window's focus — plus the two session words that say who is speaking. A pty's // output, a worker's answer, a watched file's new bytes and an animation // tick all fail that bar the same way: nobody did them, a machine reported // them, and the machine that reports them is the one already holding the @@ -1278,7 +1380,7 @@ test "detached wire: a session is never told to do a frontend's remembering" { "resize", "paste", "command", "pdf_scroll", "pinch", "touch_scroll", - "pointer_leave", + "pointer_leave", "focus", }; // One: the tag set is exactly that, named rather than counted, so @@ -1302,7 +1404,7 @@ test "detached wire: a session is never told to do a frontend's remembering" { for (0..256) |i| { const tag: u8 = @intCast(i); // Empty payloads on purpose: what is asked is whether the TAG is known. - // A known one fails later (`Truncated`) or succeeds, never with + // A known one fails later (`EndOfStream`) or succeeds, never with // `BadTag`. if (decodeClient(tag, &.{})) |_| accepted += 1 else |err| switch (err) { error.BadTag => continue, @@ -1310,7 +1412,7 @@ test "detached wire: a session is never told to do a frontend's remembering" { } const named = for (allowed) |ok| { const want = std.meta.stringToEnum(ClientTag, ok).?; - if (@intFromEnum(want) == tag) break true; + if (@backingInt(want) == tag) break true; } else false; if (!named) { std.debug.print("tag 0x{x:0>2} is decodable by a session and is not something a human did\n", .{tag}); @@ -1382,7 +1484,7 @@ test "detached wire: a full frame carries the grid, a diff carries the change" { // FULL: nothing on the far side is comparable, which is the late joiner // and the resize both. - const full_bytes = try encodeFrame(buf, cols, rows, .{ .x = 3, .y = 4, .bar = true }, cells, &.{}); + const full_bytes = try encodeFrameLayers(buf, cols, rows, .{ .x = 3, .y = 4, .bar = true }, .arrow, cells, &.{}, &.{}, &.{}, &.{}, .{}); { const f = (try framed(full_bytes)).?; const msg = (try decodeServer(f.tag, f.payload)).frame; @@ -1402,7 +1504,7 @@ test "detached wire: a full frame carries the grid, a diff carries the change" { defer gpa.free(before); cells[100] = .{ .text = "q".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; cells[0] = .{}; // ...and one goes back to unpainted, which a diff must say - const diff_bytes = try encodeFrame(buf, cols, rows, null, cells, before); + const diff_bytes = try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, before, &.{}, &.{}, &.{}, .{}); { const f = (try framed(diff_bytes)).?; const msg = (try decodeServer(f.tag, f.payload)).frame; @@ -1416,7 +1518,7 @@ test "detached wire: a full frame carries the grid, a diff carries the change" { // An unchanged frame is the head and nothing else: no runs, and the // receiver keeps what it has. This is what makes an idle session silent. { - const idle = try encodeFrame(buf, cols, rows, null, cells, cells); + const idle = try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, cells, &.{}, &.{}, &.{}, .{}); try testing.expectEqual(@as(usize, header_len + frame_head), idle.len); const f = (try framed(idle)).?; const msg = (try decodeServer(f.tag, f.payload)).frame; @@ -1452,7 +1554,7 @@ test "detached wire: the largest grid is one cell past a run, and survives it" { for (cells) |*c| c.* = .{ .text = "a".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; @memset(mirror, .{}); - const bytes = try encodeFrame(buf, cols, rows, null, cells, &.{}); + const bytes = try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, &.{}, &.{}, &.{}, &.{}, .{}); const f = (try framed(bytes)).?; const msg = (try decodeServer(f.tag, f.payload)).frame; try testing.expectEqual(FrameKind.full, msg.kind); @@ -1462,7 +1564,7 @@ test "detached wire: the largest grid is one cell past a run, and survives it" { try expectGridEqual(cells, mirror); // ...at exactly the two headers the split costs and not one byte more. // `bytes.len <= frameBound(...)` would prove nothing here — the buffer IS - // `frameBound` bytes, so an over-run is `NoSpace` above, not a false + // `frameBound` bytes, so an over-run is `WriteFailed` above, not a false // assertion here — and what wants pinning is that the second run is the // whole of the cost. try testing.expectEqual( @@ -1472,7 +1574,7 @@ test "detached wire: the largest grid is one cell past a run, and survives it" { } test "detached wire: the diff is worth having, in bytes, on the board's grid" { - // The numbers quoted in `encodeFrame`'s comment, asserted so the claim + // The numbers quoted in `encodeFrameLayers`'s comment, asserted so the claim // cannot rot. 56x14 is the ESP32-P4 board's default grid (esp32p4.zig). const cols: u16 = 56; const rows: u16 = 14; @@ -1487,7 +1589,7 @@ test "detached wire: the diff is worth having, in bytes, on the board's grid" { // Every cell painted with a plain ASCII glyph and default colors, which is // what a pardes frame overwhelmingly is: eight bytes a cell. for (cells) |*c| c.* = .{ .text = "a".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; - const full = (try encodeFrame(buf, cols, rows, null, cells, &.{})).len; + const full = (try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, &.{}, &.{}, &.{}, &.{}, .{})).len; try testing.expectEqual(@as(usize, header_len + frame_head + run_header + n * 8), full); try testing.expectEqual(@as(usize, 6302), full); @@ -1498,7 +1600,7 @@ test "detached wire: the diff is worth having, in bytes, on the board's grid" { cells[300] = .{ .text = "b".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; cells[301] = .{ .text = "c".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; cells[500] = .{ .text = "d".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; - const diff = (try encodeFrame(buf, cols, rows, null, cells, before)).len; + const diff = (try encodeFrameLayers(buf, cols, rows, null, .arrow, cells, before, &.{}, &.{}, &.{}, .{})).len; try testing.expectEqual(@as(usize, header_len + frame_head + 2 * run_header + 3 * 8), diff); try testing.expectEqual(@as(usize, 60), diff); // The whole reason this codec exists rather than shipping the Surface. @@ -1517,7 +1619,7 @@ test "detached wire: a run is coalesced across a gap only when that is cheaper" cells[0] = .{ .text = "a".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; cells[4] = .{ .text = "b".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; { - const f = (try framed(try encodeFrame(&buf, cols, rows, null, &cells, &prev))).?; + const f = (try framed(try encodeFrameLayers(&buf, cols, rows, null, .arrow, &cells, &prev, &.{}, &.{}, &.{}, .{}))).?; try testing.expectEqual(@as(u32, 1), (try decodeServer(f.tag, f.payload)).frame.nruns); } // Now put a PAINTED cell in the gap that both sides already agree about. @@ -1526,12 +1628,12 @@ test "detached wire: a run is coalesced across a gap only when that is cheaper" cells[2] = painted; prev[2] = painted; { - const f = (try framed(try encodeFrame(&buf, cols, rows, null, &cells, &prev))).?; + const f = (try framed(try encodeFrameLayers(&buf, cols, rows, null, .arrow, &cells, &prev, &.{}, &.{}, &.{}, .{}))).?; try testing.expectEqual(@as(u32, 2), (try decodeServer(f.tag, f.payload)).frame.nruns); } // Whichever it chose, the receiver ends up with the same grid. var mirror: [8]pardes.Cell = prev; - const f = (try framed(try encodeFrame(&buf, cols, rows, null, &cells, &prev))).?; + const f = (try framed(try encodeFrameLayers(&buf, cols, rows, null, .arrow, &cells, &prev, &.{}, &.{}, &.{}, .{}))).?; try (try decodeServer(f.tag, f.payload)).frame.apply(&mirror); try expectGridEqual(&cells, &mirror); } @@ -1550,14 +1652,14 @@ test "detached wire: a truncated frame is refused at every length" { // ...and the same bytes handed to the decoder with the header's length // left claiming the whole message, which is how a decoder is walked // off the end of its buffer. - try testing.expectError(error.Truncated, decodeClient(copy[0], copy[header_len..cut])); + try testing.expectError(error.EndOfStream, decodeClient(copy[0], copy[header_len..cut])); } // Shorter than the header itself is not yet a message at all. for (0..header_len + 1) |cut| try testing.expectEqual(@as(?Framed, null), try framed(copy[0..cut])); // A payload with bytes LEFT OVER is refused too: it is not this message. - try testing.expectError(error.Trailing, decodeClient(@intFromEnum(ClientTag.pointer_leave), "x")); - try testing.expectError(error.Trailing, decodeServer(@intFromEnum(ServerTag.quit), "x")); + try testing.expectError(error.Trailing, decodeClient(@backingInt(ClientTag.pointer_leave), "x")); + try testing.expectError(error.Trailing, decodeServer(@backingInt(ServerTag.quit), "x")); } test "detached wire: an unknown tag is refused, never guessed" { @@ -1569,9 +1671,9 @@ test "detached wire: an unknown tag is refused, never guessed" { } // A tag NESTED in a payload gets the same treatment: a color, an // underline style, a mouse button, a refusal reason. - try testing.expectError(error.BadTag, decodeServer(@intFromEnum(ServerTag.refuse), &.{0x7f})); + try testing.expectError(error.BadTag, decodeServer(@backingInt(ServerTag.refuse), &.{0x7f})); try testing.expectError(error.BadTag, decodeClient( - @intFromEnum(ClientTag.mouse), + @backingInt(ClientTag.mouse), &.{ 0xff, 0x00, 0, 0, 0, 0, 0 }, )); } @@ -1579,7 +1681,7 @@ test "detached wire: an unknown tag is refused, never guessed" { test "detached wire: an over-long length prefix is refused before it is believed" { // The prefix a hostile or corrupt peer sends to make the receiver allocate // or index by it. `framed` must refuse rather than wait for 4 GiB. - var head: [header_len]u8 = .{ @intFromEnum(ClientTag.paste), 0, 0, 0, 0 }; + var head: [header_len]u8 = .{ @backingInt(ClientTag.paste), 0, 0, 0, 0 }; std.mem.writeInt(u32, head[1..5], max_payload + 1, .little); try testing.expectError(error.Overlong, framed(&head)); std.mem.writeInt(u32, head[1..5], std.math.maxInt(u32), .little); @@ -1593,10 +1695,10 @@ test "detached wire: an over-long length prefix is refused before it is believed var paste: [8]u8 = undefined; std.mem.writeInt(u32, paste[0..4], 4096, .little); @memcpy(paste[4..8], "abcd"); - try testing.expectError(error.Truncated, decodeClient(@intFromEnum(ClientTag.paste), &paste)); + try testing.expectError(error.EndOfStream, decodeClient(@backingInt(ClientTag.paste), &paste)); // ...and past the cap, which is refused rather than read. std.mem.writeInt(u32, paste[0..4], max_payload + 1, .little); - try testing.expectError(error.Overlong, decodeClient(@intFromEnum(ClientTag.paste), &paste)); + try testing.expectError(error.Overlong, decodeClient(@backingInt(ClientTag.paste), &paste)); } test "detached wire: a frame that lies about its runs cannot walk out of the grid" { @@ -1640,14 +1742,14 @@ test "detached wire: a frame that lies about its runs cannot walk out of the gri // A run count larger than the grid has cells is refused at DECODE, before // it is used to bound the walk. var head: [frame_head]u8 = undefined; - var w: Writer = .init(&head); - try w.putByte(@intFromEnum(FrameKind.diff)); - try w.putU16(cols); - try w.putU16(rows); + var w: std.Io.Writer = .fixed(&head); + try w.writeByte(@backingInt(FrameKind.diff)); + try w.writeInt(u16, cols, .little); + try w.writeInt(u16, rows, .little); try putCursor(&w, null, cols, rows); - try w.putU32(0); // no body layers - try w.putU32(9); - try testing.expectError(error.Overlong, decodeServer(@intFromEnum(ServerTag.frame), w.written())); + try w.writeInt(u32, 0, .little); // no body layers + try w.writeInt(u32, 9, .little); + try testing.expectError(error.Overlong, decodeServer(@backingInt(ServerTag.frame), w.buffered())); // ...and a grid of the wrong size is the receiver's own bug, not a frame // it should paint half of. @@ -1667,7 +1769,7 @@ test "detached wire: link pointer survives full and unchanged grid frames" { var buffer: [256]u8 = undefined; for ([_]pardes.Surface.PointerShape{ .link, .arrow, .link }) |shape| { for ([_]bool{ true, false }) |full| { - const bytes = try encodeFramePointer(&buffer, 1, 1, null, shape, &cells, if (full) &.{} else &cells); + const bytes = try encodeFrameLayers(&buffer, 1, 1, null, shape, &cells, if (full) &.{} else &cells, &.{}, &.{}, &.{}, .{}); const packet = (try framed(bytes)).?; const frame = (try decodeServer(packet.tag, packet.payload)).frame; try std.testing.expectEqual(shape, frame.pointer_shape); @@ -1688,32 +1790,32 @@ test "detached wire: a cursor outside the grid is refused, not painted" { const rows: u16 = 2; var head: [frame_head]u8 = undefined; for ([_][2]u16{ .{ cols, 0 }, .{ 0, rows }, .{ 0xffff, 0xffff } }) |xy| { - var w: Writer = .init(&head); - try w.putByte(@intFromEnum(FrameKind.diff)); - try w.putU16(cols); - try w.putU16(rows); + var w: std.Io.Writer = .fixed(&head); + try w.writeByte(@backingInt(FrameKind.diff)); + try w.writeInt(u16, cols, .little); + try w.writeInt(u16, rows, .little); // Written by hand: `putCursor` now refuses this too, which is the // other half of the same fix and is asserted below. - try w.putBool(true); - try w.putU16(xy[0]); - try w.putU16(xy[1]); - try w.putBool(false); - try w.putU32(0); + try w.writeByte(@intFromBool(true)); + try w.writeInt(u16, xy[0], .little); + try w.writeInt(u16, xy[1], .little); + try w.writeByte(@intFromBool(false)); + try w.writeInt(u32, 0, .little); try testing.expectError( error.BadValue, - decodeServer(@intFromEnum(ServerTag.frame), w.written()), + decodeServer(@backingInt(ServerTag.frame), w.buffered()), ); } // The last cell IS in the grid, and a frame carrying it decodes. { - var w: Writer = .init(&head); - try w.putByte(@intFromEnum(FrameKind.diff)); - try w.putU16(cols); - try w.putU16(rows); + var w: std.Io.Writer = .fixed(&head); + try w.writeByte(@backingInt(FrameKind.diff)); + try w.writeInt(u16, cols, .little); + try w.writeInt(u16, rows, .little); try putCursor(&w, .{ .x = cols - 1, .y = rows - 1, .bar = true }, cols, rows); - try w.putU32(0); // no body layers - try w.putU32(0); - const got = (try decodeServer(@intFromEnum(ServerTag.frame), w.written())).frame; + try w.writeInt(u32, 0, .little); // no body layers + try w.writeInt(u32, 0, .little); + const got = (try decodeServer(@backingInt(ServerTag.frame), w.buffered())).frame; try testing.expectEqual(@as(u16, cols - 1), got.cursor.?.x); try testing.expectEqual(@as(u16, rows - 1), got.cursor.?.y); } @@ -1723,13 +1825,13 @@ test "detached wire: a cursor outside the grid is refused, not painted" { var buf: [512]u8 = undefined; try testing.expectError( error.BadValue, - encodeFrame(&buf, cols, rows, .{ .x = cols, .y = 0, .bar = false }, &cells, &.{}), + encodeFrameLayers(&buf, cols, rows, .{ .x = cols, .y = 0, .bar = false }, .arrow, &cells, &.{}, &.{}, &.{}, &.{}, .{}), ); // A grid past the protocol's own ceiling is refused by the encoder for the // same reason: `max_payload` is derived from it, so the decoder would. try testing.expectError( error.Overlong, - encodeFrame(&buf, max_cols + 1, 1, null, cells[0..0], &.{}), + encodeFrameLayers(&buf, max_cols + 1, 1, null, .arrow, cells[0..0], &.{}, &.{}, &.{}, &.{}, .{}), ); } @@ -1737,25 +1839,25 @@ test "detached wire: values a field cannot mean are refused" { // A bool is 0 or 1. `2` used to be "true" in every hand-written codec that // ever silently accepted a corrupt stream. try testing.expectError(error.BadValue, decodeClient( - @intFromEnum(ClientTag.key), + @backingInt(ClientTag.key), &.{ 'a', 0, 0, 0, 0, 0, 2, 0, 0 }, )); // A codepoint past Unicode's last: @intCast into Key.cp's u21 would panic. try testing.expectError(error.BadValue, decodeClient( - @intFromEnum(ClientTag.key), + @backingInt(ClientTag.key), &.{ 0x00, 0x00, 0x11, 0x00, 0, 0, 0, 0, 0 }, )); // A pane the core cannot index. `pdf_scroll` reads its pane byte before the // f32 that follows, so a one-byte payload reaches the check this is about - // rather than tripping `Truncated` first. + // rather than tripping `EndOfStream` first. try testing.expectError(error.BadValue, decodeClient( - @intFromEnum(ClientTag.pdf_scroll), + @backingInt(ClientTag.pdf_scroll), &.{pardes.MAX_PANES}, )); // A zero-column grid would collapse a shared session; an over-wide one is // past what this protocol carries. try testing.expectError(error.BadValue, decodeClient( - @intFromEnum(ClientTag.hello), + @backingInt(ClientTag.hello), &.{ 1, 0, 0, 0, 24, 0 }, )); { @@ -1763,15 +1865,15 @@ test "detached wire: values a field cannot mean are refused" { std.mem.writeInt(u16, hello[0..2], version, .little); std.mem.writeInt(u16, hello[2..4], max_cols + 1, .little); std.mem.writeInt(u16, hello[4..6], 24, .little); - try testing.expectError(error.BadValue, decodeClient(@intFromEnum(ClientTag.hello), &hello)); + try testing.expectError(error.BadValue, decodeClient(@backingInt(ClientTag.hello), &hello)); } // A NaN scroll distance. `pinch` multiplies into a zoom the pane keeps. { var pinch: [4]u8 = undefined; std.mem.writeInt(u32, &pinch, @bitCast(std.math.nan(f32)), .little); - try testing.expectError(error.BadValue, decodeClient(@intFromEnum(ClientTag.pinch), &pinch)); + try testing.expectError(error.BadValue, decodeClient(@backingInt(ClientTag.pinch), &pinch)); std.mem.writeInt(u32, &pinch, @bitCast(std.math.inf(f32)), .little); - try testing.expectError(error.BadValue, decodeClient(@intFromEnum(ClientTag.touch_scroll), &pinch)); + try testing.expectError(error.BadValue, decodeClient(@backingInt(ClientTag.touch_scroll), &pinch)); } // A cell with the reserved attribute bit set, and one with an impossible // grapheme length. Both are bytes this protocol has no meaning for. @@ -1806,10 +1908,10 @@ test "detached wire: max_payload bounds every message this protocol can build" { const room = try gpa.alloc(u8, huge.len + header_len + 2); defer gpa.free(room); try testing.expectError(error.Overlong, encodeClient(room, .{ .event = .{ .command = huge } })); - // ...and a buffer the caller sized too small is NoSpace, which is the + // ...and a buffer the caller sized too small is WriteFailed, which is the // server's signal to drop that one message rather than the client. var small: [8]u8 = undefined; - try testing.expectError(error.NoSpace, encodeClient(&small, .{ .event = .{ .paste = "0123456789" } })); + try testing.expectError(error.WriteFailed, encodeClient(&small, .{ .event = .{ .paste = "0123456789" } })); } test "detached wire carries compact body rows and exact pointer metrics" { @@ -1817,22 +1919,29 @@ test "detached wire carries compact body rows and exact pointer metrics" { var cells: [8]pardes.Cell = @splat(.{}); var logical: [12]pardes.Cell = @splat(.{}); logical[10] = .{ .text = "z".* ++ @as([6]u8, @splat(0)), .len = 1, .default = false }; - var layer: pardes.BodyLayer = .{ .pane = 0, .serial = 42, .viewport = .{ .x = 0, .y = 0, .w = 2, .h = 4 }, .cols = 2, .rows = 6, .context_rows = 2, .cells = &logical, .cursor = .{ .x = 0, .y = 5, .bar = true } }; + var layer: pardes.Layer = .{ .id = 0, .serial = 42, .viewport = .{ .x = 0, .y = 0, .w = 2, .h = 4 }, .cols = 2, .rows = 6, .context_rows = 2, .cells = &logical, .cursor = .{ .x = 0, .y = 5, .bar = true } }; layer.context_separators.set(0); var tag_cells: [3]pardes.Cell = @splat(.{}); tag_cells[2] = logical[10]; - const tag: pardes.TagLayer = .{ .kind = .column, .id = 1, .viewport = .{ .x = 0, .y = 0, .w = 2, .h = 1 }, .cols = 3, .bg = .{ 11, 22, 33 }, .cells = &tag_cells, .cursor = .{ .col = 2, .bar = true } }; - const out = try gpa.alloc(u8, frameBound(2, 4) + layersBound(&.{layer}, &.{tag})); + const tag: pardes.Layer = .{ .kind = .column, .id = 1, .viewport = .{ .x = 0, .y = 0, .w = 2, .h = 1 }, .cols = 3, .rows = 1, .bg = .{ 11, 22, 33 }, .cells = &tag_cells, .cursor = .{ .x = 2, .y = 0, .bar = true } }; + const placed = [_]pardes.Region{.{ .kind = .rail, .owner = 3, .serial = 42, .rect = .{ .x = 0, .y = 1, .w = 2, .h = 3 }, .active = true, .dirty = true, .thumb_y = 1, .thumb_h = 2, .clip = 1, .lift = 0.5 }}; + const out = try gpa.alloc(u8, frameBound(2, 4) + layersBound(&.{layer}, &.{tag}, &placed)); defer gpa.free(out); - const encoded = try encodeFrameLayers(out, 2, 4, null, .link, &cells, &cells, &.{layer}, &.{tag}); + const palette: pardes.Chrome = .{ .page = .{ 1, 2, 3 }, .border = .{ 4, 5, 6 }, .tag_focus_bg = .{ 7, 8, 9 }, .scroll_thumb = .{ 10, 11, 12 }, .rule_px = 3, .tag_rule = .{ 13, 14, 15 }, .rail_px = 12, .grip_border = .{ 16, 17, 18 }, .grip_focus_ring = .{ 19, 20, 21 }, .grip_dirty = .{ 22, 23, 24 }, .lift_style = 2, .cursor_glide = 3, .cursor_alpha = 0.5, .cursor_idle_ms = 1234, .cursor_quad = .{ 1, 2, 3.5, 2, 3.5, 3, 1, 3 } }; + const encoded = try encodeFrameLayers(out, 2, 4, null, .link, &cells, &cells, &.{layer}, &.{tag}, &placed, palette); const packet = (try framed(encoded)).?; const frame = (try decodeServer(packet.tag, packet.payload)).frame; - var decoded: [pardes.MAX_PANES]pardes.BodyLayer = @splat(.{}); - var tags: [pardes.MAX_TAG_LAYERS]pardes.TagLayer = @splat(.{}); + var decoded: [pardes.MAX_PANES]pardes.Layer = @splat(.{}); + var tags: [pardes.MAX_TAG_LAYERS]pardes.Layer = @splat(.{}); defer for (&tags) |*item| gpa.free(item.cells); defer for (&decoded) |*item| gpa.free(item.cells); try frame.apply(&cells); - try frame.applyLayers(gpa, &decoded, &tags); + var regions: std.ArrayListUnmanaged(pardes.Region) = .empty; + defer regions.deinit(gpa); + var chrome: pardes.Chrome = .{}; + try frame.applyLayers(gpa, &decoded, &tags, ®ions, &chrome); + try std.testing.expectEqualDeep(placed[0..], regions.items); + try std.testing.expectEqualDeep(palette, chrome); try std.testing.expectEqual(@as(u16, 6), decoded[0].rows); try std.testing.expect(decoded[0].context_separators.isSet(0)); try std.testing.expect(!decoded[0].context_separators.isSet(1)); @@ -1844,10 +1953,10 @@ test "detached wire carries compact body rows and exact pointer metrics" { try std.testing.expectEqual(tag.id, tags[0].id); try std.testing.expectEqual(tag.bg, tags[0].bg); try std.testing.expectEqual(tag.cols, tags[0].cols); - try std.testing.expectEqual(@as(u16, 2), tags[0].cursor.?.col); + try std.testing.expectEqual(@as(u16, 2), tags[0].cursor.?.x); try std.testing.expectEqualStrings("z", tags[0].cells[2].grapheme()); - const pointer = layer.hitAt(4, 27, 8, 16, 6, 8).?; - const tag_pointer = tag.hitAt(11, 8, 8, 16, 4, 8).?; + const pointer = layer.bodyHit(4, 27, 8, 16, 6, 8).?; + const tag_pointer = tag.tagHit(11, 8, 8, 16, 4, 8).?; const message: ClientMsg = .{ .event = .{ .mouse = .{ .col = 0, .row = 1, .button = .left, .kind = .press, .body_hit = pointer, .tag_hit = tag_pointer } } }; var mouse_bytes: [256]u8 = undefined; const mouse_encoded = try encodeClient(&mouse_bytes, message); @@ -1858,19 +1967,20 @@ test "detached wire carries compact body rows and exact pointer metrics" { try std.testing.expect(mouse_encoded.len <= clientBound(message)); var truncated = frame; truncated.layers = frame.layers[0 .. frame.layers.len - 1]; - try std.testing.expectError(error.Truncated, truncated.applyLayers(gpa, &decoded, &tags)); + try std.testing.expectError(error.EndOfStream, truncated.applyLayers(gpa, &decoded, &tags, ®ions, &chrome)); for (decoded) |item| { try std.testing.expectEqual(@as(u16, 0), item.rows); try std.testing.expectEqual(@as(usize, 0), item.cells.len); try std.testing.expectEqual(@as(usize, 0), item.context_separators.count()); } for (tags) |item| { - try std.testing.expectEqual(@as(u16, 0), item.cols); + try std.testing.expectEqual(@as(u16, 0), item.rows); try std.testing.expectEqual(@as(usize, 0), item.cells.len); } - const no_layers = try encodeFramePointer(out, 2, 4, null, .arrow, &cells, &cells); + try std.testing.expectEqual(@as(usize, 0), regions.items.len); + const no_layers = try encodeFrameLayers(out, 2, 4, null, .arrow, &cells, &cells, &.{}, &.{}, &.{}, .{}); const cleared_packet = (try framed(no_layers)).?; const cleared = (try decodeServer(cleared_packet.tag, cleared_packet.payload)).frame; - try cleared.applyLayers(gpa, &decoded, &tags); + try cleared.applyLayers(gpa, &decoded, &tags, ®ions, &chrome); try std.testing.expectEqual(@as(u16, 0), decoded[0].rows); } |
