aboutsummaryrefslogtreecommitdiff
path: root/vendor/libghostty-vt/src/terminal/apc/glyph/response.zig
diff options
context:
space:
mode:
authorOgulcan Celik <ogulcancelik@gmail.com>2026-07-16 23:28:05 +0300
committerOgulcan Celik <ogulcancelik@gmail.com>2026-07-16 23:29:28 +0300
commit4a3302d19a2baa3a33e910e0088c24e780905b90 (patch)
treedcaf76fae1c82102d933c9225b17ca7ac5d3a847 /vendor/libghostty-vt/src/terminal/apc/glyph/response.zig
parent550e9f8cc085f428429f5cf2da0bb2dba897e8b8 (diff)
chore: update vendored libghostty-vt
refs #276
Diffstat (limited to 'vendor/libghostty-vt/src/terminal/apc/glyph/response.zig')
-rw-r--r--vendor/libghostty-vt/src/terminal/apc/glyph/response.zig346
1 files changed, 346 insertions, 0 deletions
diff --git a/vendor/libghostty-vt/src/terminal/apc/glyph/response.zig b/vendor/libghostty-vt/src/terminal/apc/glyph/response.zig
new file mode 100644
index 00000000..9e40f0ea
--- /dev/null
+++ b/vendor/libghostty-vt/src/terminal/apc/glyph/response.zig
@@ -0,0 +1,346 @@
+const std = @import("std");
+
+/// Query response coverage state for a codepoint.
+pub const Coverage = packed struct(u2) {
+ /// A system font covers the codepoint.
+ system: bool = false,
+
+ /// A session glyph registration covers the codepoint.
+ glossary: bool = false,
+
+ /// No system font or registered glyph covers the codepoint.
+ pub const free: Coverage = .{};
+
+ /// Parse the query response coverage list from its comma-separated form.
+ /// Unknown coverage names are ignored for forward compatibility.
+ pub fn init(value: []const u8) ?Coverage {
+ var result: Coverage = .free;
+ var it = std.mem.splitScalar(u8, value, ',');
+ while (it.next()) |name| {
+ if (std.mem.eql(u8, name, "system")) {
+ result.system = true;
+ } else if (std.mem.eql(u8, name, "glossary")) {
+ result.glossary = true;
+ }
+ }
+
+ return result;
+ }
+};
+
+/// Response to a glyph APC request, formatted for the wire protocol.
+pub const Response = union(enum) {
+ /// Recommended fixed buffer size for formatting a Glyph Protocol response.
+ ///
+ /// Glyph Protocol responses contain only framing plus bounded scalar fields:
+ /// a u21 codepoint as hex, a decimal u8 status, a small fixed set of
+ /// supported format names, coverage names, and the reason names produced by
+ /// the executor. 1024 bytes is therefore far above the longest response we
+ /// can emit today, while still being small enough for stack allocation in
+ /// stream handlers. If callers construct responses with arbitrary `.other`
+ /// or clear reason strings, they must ensure those strings fit or handle the
+ /// writer error from `formatWire`.
+ pub const max_wire_bytes = 1024;
+
+ /// Support query response listing supported payload formats.
+ support: Support,
+
+ /// Codepoint coverage query response.
+ query: Query,
+
+ /// Glyph registration response (success or error).
+ register: Register,
+
+ /// Registration clear response.
+ clear: Clear,
+
+ /// Support query response fields.
+ pub const Support = struct {
+ /// Supported payload formats.
+ fmt: Formats,
+
+ pub const Formats = packed struct(u8) {
+ /// TrueType simple glyph outlines (required in v1).
+ glyf: bool = false,
+
+ /// COLR v0 layered flat-colour glyphs.
+ colrv0: bool = false,
+
+ /// COLR v1 paint-graph glyphs.
+ colrv1: bool = false,
+
+ _padding: u5 = 0,
+ };
+ };
+
+ /// Codepoint query response fields.
+ pub const Query = struct {
+ /// The queried codepoint.
+ cp: u21,
+
+ /// Coverage status for the codepoint.
+ status: Coverage,
+ };
+
+ /// Register response fields.
+ pub const Register = struct {
+ /// The target codepoint of the registration.
+ cp: u21,
+
+ /// Result status of the registration encoded as a decimal u8.
+ status: Status = .ok,
+
+ /// Optional symbolic error reason.
+ reason: ?Reason = null,
+
+ /// Register error reason codes defined by Glyph Protocol §6.2.
+ pub const Reason = union(enum) {
+ /// `cp` is not in any PUA range.
+ out_of_namespace,
+
+ /// Payload contains composite glyphs.
+ composite_unsupported,
+
+ /// Payload contains hinting instructions.
+ hinting_unsupported,
+
+ /// Payload failed to parse as the declared `fmt`.
+ malformed_payload,
+
+ /// Payload exceeds 64 KiB after base64 decoding.
+ payload_too_large,
+
+ /// A reason code not known by this version of Ghostty.
+ other: []const u8,
+
+ /// Return the wire-format reason name.
+ pub fn name(self: Reason) []const u8 {
+ return switch (self) {
+ .out_of_namespace => "out_of_namespace",
+ .composite_unsupported => "composite_unsupported",
+ .hinting_unsupported => "hinting_unsupported",
+ .malformed_payload => "malformed_payload",
+ .payload_too_large => "payload_too_large",
+ .other => |value| value,
+ };
+ }
+ };
+ };
+
+ /// Clear response fields.
+ pub const Clear = struct {
+ /// Result status of the clear operation encoded as a decimal u8.
+ status: Status = .ok,
+
+ /// Optional symbolic error reason.
+ reason: ?[]const u8 = null,
+ };
+
+ /// Status code for register and clear responses.
+ pub const Status = enum(u8) {
+ /// The operation completed successfully.
+ ok = 0,
+
+ /// A generic or unspecified error occurred.
+ err = 1,
+
+ _,
+ };
+
+ /// Write the response in the glyph APC wire format to `writer`.
+ ///
+ /// The framing is: `ESC _ 25a1 ; <verb> ; <key=value>* ESC \`
+ pub fn formatWire(
+ self: Response,
+ writer: *std.Io.Writer,
+ ) std.Io.Writer.Error!void {
+ try writer.writeAll("\x1b_25a1;");
+ switch (self) {
+ .support => |r| {
+ // From the spec:
+ // Order is not significant; clients MUST treat the value as a
+ // set. An empty fmt= value means the terminal recognises
+ // Glyph Protocol but currently advertises no payload formats
+ // — every r will be rejected. Clients MUST ignore names they
+ // do not recognise rather than failing the reply, so future
+ // format names are forward- compatible.
+ try writer.writeAll("s;fmt=");
+ var first = true;
+ if (r.fmt.glyf) {
+ first = false;
+ try writer.writeAll("glyf");
+ }
+ if (r.fmt.colrv0) {
+ if (!first) try writer.writeByte(',');
+ first = false;
+ try writer.writeAll("colrv0");
+ }
+ if (r.fmt.colrv1) {
+ if (!first) try writer.writeByte(',');
+ first = false;
+ try writer.writeAll("colrv1");
+ }
+ },
+ .query => |r| {
+ // status is a comma-separated list of coverage names — the
+ // set of sources that can render cp in this session. Order is
+ // not significant; clients MUST treat the value as a set.
+ try writer.print("q;cp={x};status=", .{r.cp});
+ var first = true;
+ if (r.status.system) {
+ first = false;
+ try writer.writeAll("system");
+ }
+ if (r.status.glossary) {
+ if (!first) try writer.writeByte(',');
+ try writer.writeAll("glossary");
+ }
+ },
+ .register => |r| {
+ try writer.print("r;cp={x};status={d}", .{ r.cp, @intFromEnum(r.status) });
+ if (r.reason) |reason| {
+ try writer.writeAll(";reason=");
+ try writer.writeAll(reason.name());
+ }
+ },
+ .clear => |r| {
+ try writer.print("c;status={d}", .{@intFromEnum(r.status)});
+ if (r.reason) |reason| {
+ try writer.writeAll(";reason=");
+ try writer.writeAll(reason);
+ }
+ },
+ }
+ try writer.writeAll("\x1b\\");
+ }
+};
+
+test "support formats default to no advertised formats" {
+ const testing = std.testing;
+ const Formats = Response.Support.Formats;
+
+ try testing.expectEqual(@as(u8, 0), @as(u8, @bitCast(Formats{})));
+}
+
+test "response support formatWire" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .support = .{ .fmt = .{ .glyf = true, .colrv0 = true } } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;s;fmt=glyf,colrv0\x1b\\", writer.buffered());
+}
+
+test "response support formatWire with no formats" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .support = .{ .fmt = .{} } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;s;fmt=\x1b\\", writer.buffered());
+}
+
+test "response query formatWire" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .query = .{ .cp = 0xE0A0, .status = .{ .system = true, .glossary = true } } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;q;cp=e0a0;status=system,glossary\x1b\\", writer.buffered());
+}
+
+test "response query formatWire with no coverage" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .query = .{ .cp = 0xE0A0, .status = .{} } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;q;cp=e0a0;status=\x1b\\", writer.buffered());
+}
+
+test "coverage parses comma-separated names" {
+ const testing = std.testing;
+
+ try testing.expectEqual(Coverage{}, Coverage.init("").?);
+ try testing.expectEqual(Coverage{ .system = true }, Coverage.init("system").?);
+ try testing.expectEqual(Coverage{ .glossary = true }, Coverage.init("glossary").?);
+ try testing.expectEqual(Coverage{ .system = true, .glossary = true }, Coverage.init("system,glossary").?);
+ try testing.expectEqual(Coverage{ .system = true, .glossary = true }, Coverage.init("glossary,system").?);
+ try testing.expectEqual(Coverage{ .system = true }, Coverage.init("system,future").?);
+ try testing.expectEqual(Coverage{}, Coverage.init("future").?);
+}
+
+test "response register success formatWire" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .register = .{ .cp = 0xE0A0 } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;r;cp=e0a0;status=0\x1b\\", writer.buffered());
+}
+
+test "response register error formatWire" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .register = .{ .cp = 0xE0A0, .status = .err, .reason = .out_of_namespace } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;r;cp=e0a0;status=1;reason=out_of_namespace\x1b\\", writer.buffered());
+}
+
+test "response register arbitrary status formatWire" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .register = .{ .cp = 0xE0A0, .status = @enumFromInt(37), .reason = .payload_too_large } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;r;cp=e0a0;status=37;reason=payload_too_large\x1b\\", writer.buffered());
+}
+
+test "register reason names" {
+ const testing = std.testing;
+ const Reason = Response.Register.Reason;
+
+ try testing.expectEqualStrings("out_of_namespace", (Reason{ .out_of_namespace = {} }).name());
+ try testing.expectEqualStrings("composite_unsupported", (Reason{ .composite_unsupported = {} }).name());
+ try testing.expectEqualStrings("hinting_unsupported", (Reason{ .hinting_unsupported = {} }).name());
+ try testing.expectEqualStrings("malformed_payload", (Reason{ .malformed_payload = {} }).name());
+ try testing.expectEqualStrings("payload_too_large", (Reason{ .payload_too_large = {} }).name());
+ try testing.expectEqualStrings("future_reason", (Reason{ .other = "future_reason" }).name());
+}
+
+test "response clear formatWire" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .clear = .{} };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;c;status=0\x1b\\", writer.buffered());
+}
+
+test "response clear error formatWire" {
+ const testing = std.testing;
+
+ var buf: [256]u8 = undefined;
+ var writer: std.Io.Writer = .fixed(&buf);
+
+ const resp: Response = .{ .clear = .{ .status = .err, .reason = "out_of_namespace" } };
+ try resp.formatWire(&writer);
+ try testing.expectEqualStrings("\x1b_25a1;c;status=1;reason=out_of_namespace\x1b\\", writer.buffered());
+}