gitoriaLog in with ident

tracker

All repositories: gitoria

ReadmeCodePull requestsReleasesTicketsSettingsCommit93dfb0ba93dfb0batracker#40 (mission 034): the curated franchises — data/franchises.json (17 franchises, 31 timelines, 285 TMDB titles, movies + series, in-universe/release order, 12 TMDB collections attached); lib/franchiseseed.hl + jobs.hl franchiseSeedTick (last start job, imports missing titles via details.hl importWithCredits = the search's Add, one per step paced, then one build; franchiseseed.db: editor changes win, the creator's same-name franchise adopted / timeline left alone, 404 remembered, resumable, idempotent); timeline heads 'N titles · in-universe order' (orderKind) and wrap on a phone; series pages show the widget; new gate tests/franchiseseed.mjs (5th in deploy.sh), the others run with TRACKER_FRANCHISE_SEED=0; gates 365/0, 32/0, 52/0, 24/0, check-theme 0; real copy 196 imported, 0 failed, 7 min, restart unchanged=31mre93dfb0ba/plugins/http/ws_common.zig

21.4 KB

  1. // Shared WebSocket core — RFC 6455 framing, transport-agnostic (decision D8).
  2. // Compiled into each HTTP plugin like http_common.zig; NOT a standalone .so.
  3. //
  4. // Responsibilities:
  5. // - Sec-WebSocket-Accept computation (SHA1 + base64 of key + RFC GUID)
  6. // - Frame encoding (unmasked, server → client) via a write callback
  7. // - Frame decoding + message assembly (client-masked inbound), fragmentation,
  8. // ping/pong surfacing, close handshake with codes, UTF-8 validation
  9. //
  10. // The per-protocol handshakes stay in each plugin: h1 = Upgrade/101 (http1.zig),
  11. // h2 = RFC 8441 extended CONNECT (future), h3 = RFC 9220 (future). Everything
  12. // after the handshake — the byte stream — goes through this module unchanged.
  13. //
  14. // Transport neutrality: encoding writes through `WriteFn` callbacks and decoding
  15. // consumes raw bytes via `Decoder.feed()`; the module never touches a socket.
  17. const std = @import("std");
  19. pub const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
  21. /// Write callback: return false on transport failure (peer gone).
  22. pub const WriteFn = *const fn (ctx: ?*anyopaque, data: []const u8) bool;
  24. pub const Opcode = enum(u4) {
  25. continuation = 0x0,
  26. text = 0x1,
  27. binary = 0x2,
  28. close = 0x8,
  29. ping = 0x9,
  30. pong = 0xA,
  31. _,
  33. pub fn isControl(self: Opcode) bool {
  34. return @intFromEnum(self) >= 0x8;
  35. }
  36. };
  38. // Close codes used by the core
  39. pub const CLOSE_NORMAL: u16 = 1000;
  40. pub const CLOSE_GOING_AWAY: u16 = 1001;
  41. pub const CLOSE_PROTOCOL_ERROR: u16 = 1002;
  42. pub const CLOSE_INVALID_PAYLOAD: u16 = 1007;
  43. pub const CLOSE_TOO_BIG: u16 = 1009;
  44. pub const CLOSE_NO_STATUS: u16 = 1005; // synthesized when close frame has no code — never sent on the wire
  46. /// Sec-WebSocket-Accept: base64(SHA1(key ++ GUID)). Output is always 28 chars.
  47. pub fn computeAcceptKey(key: []const u8, out: *[28]u8) []const u8 {
  48. var sha = std.crypto.hash.Sha1.init(.{});
  49. sha.update(key);
  50. sha.update(GUID);
  51. var digest: [20]u8 = undefined;
  52. sha.final(&digest);
  53. return std.base64.standard.Encoder.encode(out, &digest);
  54. }
  56. /// Encode a frame header into `buf` (needs >= 10 bytes). Returns header length.
  57. /// Server frames are unmasked (RFC 6455 §5.1).
  58. pub fn encodeFrameHeader(buf: *[10]u8, opcode: Opcode, payload_len: usize, fin: bool) usize {
  59. buf[0] = (if (fin) @as(u8, 0x80) else 0) | @as(u8, @intFromEnum(opcode));
  60. if (payload_len <= 125) {
  61. buf[1] = @intCast(payload_len);
  62. return 2;
  63. } else if (payload_len <= 65535) {
  64. buf[1] = 126;
  65. std.mem.writeInt(u16, buf[2..4], @intCast(payload_len), .big);
  66. return 4;
  67. } else {
  68. buf[1] = 127;
  69. std.mem.writeInt(u64, buf[2..10], payload_len, .big);
  70. return 10;
  71. }
  72. }
  74. /// Write one complete unmasked frame through the callback. True on success.
  75. pub fn writeFrame(write: WriteFn, ctx: ?*anyopaque, opcode: Opcode, payload: []const u8) bool {
  76. var hdr: [10]u8 = undefined;
  77. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, true);
  78. if (!write(ctx, hdr[0..hlen])) return false;
  79. if (payload.len > 0 and !write(ctx, payload)) return false;
  80. return true;
  81. }
  83. /// Write a close frame with a code and optional reason (reason truncated to 123).
  84. pub fn writeClose(write: WriteFn, ctx: ?*anyopaque, code: u16, reason: []const u8) bool {
  85. var payload: [125]u8 = undefined;
  86. std.mem.writeInt(u16, payload[0..2], code, .big);
  87. const rlen = @min(reason.len, 123);
  88. @memcpy(payload[2 .. 2 + rlen], reason[0..rlen]);
  89. return writeFrame(write, ctx, .close, payload[0 .. 2 + rlen]);
  90. }
  92. /// Write one complete MASKED frame — the client's half of RFC 6455 §5.1 ("a
  93. /// client MUST mask all frames"). The mask is fresh per frame from the kernel
  94. /// CSPRNG (`getrandom(2)`, not a seeded generator: a predictable mask is not
  95. /// a security property this module is willing to guess wrong about — same
  96. /// reasoning as hl:http1's session-token `randomToken`). A getrandom() short
  97. /// read is vanishingly rare for 4 bytes; the leftover is zeroed rather than
  98. /// left uninitialized, which only ever makes the mask weaker, never wrong.
  99. /// Masking is applied through a small stack buffer so a large payload needs
  100. /// no allocation.
  101. pub fn writeFrameMasked(write: WriteFn, ctx: ?*anyopaque, opcode: Opcode, payload: []const u8) bool {
  102. var hdr: [10]u8 = undefined;
  103. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, true);
  104. hdr[1] |= 0x80; // mask bit
  105. var mask: [4]u8 = .{ 0, 0, 0, 0 };
  106. _ = std.os.linux.getrandom(&mask, mask.len, 0);
  107. if (!write(ctx, hdr[0..hlen])) return false;
  108. if (!write(ctx, &mask)) return false;
  109. if (payload.len == 0) return true;
  111. var buf: [4096]u8 = undefined;
  112. var i: usize = 0;
  113. while (i < payload.len) {
  114. const n = @min(buf.len, payload.len - i);
  115. for (0..n) |j| buf[j] = payload[i + j] ^ mask[(i + j) % 4];
  116. if (!write(ctx, buf[0..n])) return false;
  117. i += n;
  118. }
  119. return true;
  120. }
  122. /// Masked `writeClose` — see `writeFrameMasked`.
  123. pub fn writeCloseMasked(write: WriteFn, ctx: ?*anyopaque, code: u16, reason: []const u8) bool {
  124. var payload: [125]u8 = undefined;
  125. std.mem.writeInt(u16, payload[0..2], code, .big);
  126. const rlen = @min(reason.len, 123);
  127. @memcpy(payload[2 .. 2 + rlen], reason[0..rlen]);
  128. return writeFrameMasked(write, ctx, .close, payload[0 .. 2 + rlen]);
  129. }
  131. /// A decoded inbound event. Payload slices are allocated with the decoder's
  132. /// allocator and owned by the CALLER (free after use).
  133. pub const Event = union(enum) {
  134. text: []u8,
  135. binary: []u8,
  136. ping: []u8, // payload to echo in the pong
  137. pong: []u8,
  138. close: Close,
  139. /// Protocol violation — caller should send a close frame with this code
  140. /// and drop the connection.
  141. protocol_error: u16,
  143. pub const Close = struct {
  144. code: u16, // CLOSE_NO_STATUS when the frame carried no code
  145. reason: []u8,
  146. };
  148. pub fn deinitPayload(self: *Event, alloc: std.mem.Allocator) void {
  149. switch (self.*) {
  150. .text, .binary, .ping, .pong => |p| alloc.free(p),
  151. .close => |cl| alloc.free(cl.reason),
  152. .protocol_error => {},
  153. }
  154. }
  155. };
  157. fn validCloseCode(code: u16) bool {
  158. return switch (code) {
  159. 1000...1003, 1007...1011 => true,
  160. 3000...4999 => true,
  161. else => false,
  162. };
  163. }
  165. /// Streaming frame decoder + message assembler. One per connection.
  166. /// feed() raw transport bytes, then loop next() until it returns null.
  167. pub const Decoder = struct {
  168. alloc: std.mem.Allocator,
  169. /// Client frames must be masked (server side). Set false for client use.
  170. require_masked: bool = true,
  171. max_message_size: usize = 16 * 1024 * 1024,
  173. buf: std.ArrayListUnmanaged(u8) = .empty, // raw incoming bytes
  174. read_pos: usize = 0,
  175. msg: std.ArrayListUnmanaged(u8) = .empty, // fragmented-message assembly
  176. msg_opcode: ?Opcode = null,
  177. failed: bool = false, // after a protocol error the stream is dead
  179. pub fn init(alloc: std.mem.Allocator) Decoder {
  180. return .{ .alloc = alloc };
  181. }
  183. pub fn deinit(self: *Decoder) void {
  184. self.buf.deinit(self.alloc);
  185. self.msg.deinit(self.alloc);
  186. }
  188. pub fn feed(self: *Decoder, bytes: []const u8) !void {
  189. // Compact consumed prefix before growing
  190. if (self.read_pos > 0) {
  191. const remaining = self.buf.items.len - self.read_pos;
  192. std.mem.copyForwards(u8, self.buf.items[0..remaining], self.buf.items[self.read_pos..]);
  193. self.buf.shrinkRetainingCapacity(remaining);
  194. self.read_pos = 0;
  195. }
  196. try self.buf.appendSlice(self.alloc, bytes);
  197. }
  199. fn fail(self: *Decoder, code: u16) Event {
  200. self.failed = true;
  201. return .{ .protocol_error = code };
  202. }
  204. /// Pop the next complete event, or null if more bytes are needed.
  205. pub fn next(self: *Decoder) !?Event {
  206. if (self.failed) return null;
  207. const data = self.buf.items[self.read_pos..];
  208. if (data.len < 2) return null;
  210. const b0 = data[0];
  211. const b1 = data[1];
  212. const fin = (b0 & 0x80) != 0;
  213. const rsv = b0 & 0x70;
  214. const opcode: Opcode = @enumFromInt(@as(u4, @truncate(b0 & 0x0F)));
  215. const masked = (b1 & 0x80) != 0;
  216. const len7: u8 = b1 & 0x7F;
  218. if (rsv != 0) return self.fail(CLOSE_PROTOCOL_ERROR); // no extensions negotiated
  219. switch (@intFromEnum(opcode)) {
  220. 0x0, 0x1, 0x2, 0x8, 0x9, 0xA => {},
  221. else => return self.fail(CLOSE_PROTOCOL_ERROR),
  222. }
  223. if (self.require_masked and !masked) return self.fail(CLOSE_PROTOCOL_ERROR);
  224. if (opcode.isControl() and (!fin or len7 > 125)) return self.fail(CLOSE_PROTOCOL_ERROR);
  226. var offset: usize = 2;
  227. var payload_len: u64 = len7;
  228. if (len7 == 126) {
  229. if (data.len < offset + 2) return null;
  230. payload_len = std.mem.readInt(u16, data[offset..][0..2], .big);
  231. offset += 2;
  232. if (payload_len <= 125) return self.fail(CLOSE_PROTOCOL_ERROR); // non-minimal encoding
  233. } else if (len7 == 127) {
  234. if (data.len < offset + 8) return null;
  235. payload_len = std.mem.readInt(u64, data[offset..][0..8], .big);
  236. offset += 8;
  237. if (payload_len <= 65535) return self.fail(CLOSE_PROTOCOL_ERROR);
  238. if (payload_len > (1 << 62)) return self.fail(CLOSE_PROTOCOL_ERROR); // MSB must be 0
  239. }
  240. if (payload_len > self.max_message_size or
  241. self.msg.items.len + payload_len > self.max_message_size)
  242. return self.fail(CLOSE_TOO_BIG);
  244. var mask: [4]u8 = .{ 0, 0, 0, 0 };
  245. if (masked) {
  246. if (data.len < offset + 4) return null;
  247. mask = data[offset..][0..4].*;
  248. offset += 4;
  249. }
  251. const plen: usize = @intCast(payload_len);
  252. if (data.len < offset + plen) return null; // frame incomplete
  254. // Unmask into an owned copy
  255. const payload = try self.alloc.alloc(u8, plen);
  256. errdefer self.alloc.free(payload);
  257. for (0..plen) |i| {
  258. payload[i] = data[offset + i] ^ mask[i % 4];
  259. }
  260. self.read_pos += offset + plen;
  262. switch (opcode) {
  263. .ping => return .{ .ping = payload },
  264. .pong => return .{ .pong = payload },
  265. .close => {
  266. if (plen == 0) return .{ .close = .{ .code = CLOSE_NO_STATUS, .reason = payload } };
  267. if (plen == 1) {
  268. self.alloc.free(payload);
  269. return self.fail(CLOSE_PROTOCOL_ERROR);
  270. }
  271. const code = std.mem.readInt(u16, payload[0..2], .big);
  272. if (!validCloseCode(code)) {
  273. self.alloc.free(payload);
  274. return self.fail(CLOSE_PROTOCOL_ERROR);
  275. }
  276. if (!std.unicode.utf8ValidateSlice(payload[2..])) {
  277. self.alloc.free(payload);
  278. return self.fail(CLOSE_INVALID_PAYLOAD);
  279. }
  280. const reason = try self.alloc.alloc(u8, plen - 2);
  281. @memcpy(reason, payload[2..]);
  282. self.alloc.free(payload);
  283. return .{ .close = .{ .code = code, .reason = reason } };
  284. },
  285. .text, .binary => {
  286. if (self.msg_opcode != null) {
  287. self.alloc.free(payload);
  288. return self.fail(CLOSE_PROTOCOL_ERROR); // new data frame while assembling
  289. }
  290. if (fin) {
  291. if (opcode == .text and !std.unicode.utf8ValidateSlice(payload)) {
  292. self.alloc.free(payload);
  293. return self.fail(CLOSE_INVALID_PAYLOAD);
  294. }
  295. return if (opcode == .text) .{ .text = payload } else .{ .binary = payload };
  296. }
  297. // First fragment
  298. self.msg_opcode = opcode;
  299. try self.msg.appendSlice(self.alloc, payload);
  300. self.alloc.free(payload);
  301. return self.next(); // more frames may already be buffered
  302. },
  303. .continuation => {
  304. const start_op = self.msg_opcode orelse {
  305. self.alloc.free(payload);
  306. return self.fail(CLOSE_PROTOCOL_ERROR); // continuation without a message
  307. };
  308. try self.msg.appendSlice(self.alloc, payload);
  309. self.alloc.free(payload);
  310. if (!fin) return self.next();
  311. // Message complete
  312. const full = try self.msg.toOwnedSlice(self.alloc);
  313. self.msg_opcode = null;
  314. if (start_op == .text and !std.unicode.utf8ValidateSlice(full)) {
  315. self.alloc.free(full);
  316. return self.fail(CLOSE_INVALID_PAYLOAD);
  317. }
  318. return if (start_op == .text) .{ .text = full } else .{ .binary = full };
  319. },
  320. _ => return self.fail(CLOSE_PROTOCOL_ERROR), // unreachable — filtered above
  321. }
  322. }
  323. };
  325. // ===========================================================================
  326. // Tests
  327. // ===========================================================================
  329. const t = std.testing;
  331. test "computeAcceptKey RFC 6455 sample" {
  332. var out: [28]u8 = undefined;
  333. const accept = computeAcceptKey("dGhlIHNhbXBsZSBub25jZQ==", &out);
  334. try t.expectEqualStrings("s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", accept);
  335. }
  337. fn maskedFrame(alloc: std.mem.Allocator, fin: bool, opcode: Opcode, payload: []const u8, mask: [4]u8) ![]u8 {
  338. var out = std.ArrayListUnmanaged(u8).empty;
  339. var hdr: [10]u8 = undefined;
  340. const hlen = encodeFrameHeader(&hdr, opcode, payload.len, fin);
  341. hdr[1] |= 0x80; // set mask bit
  342. try out.appendSlice(alloc, hdr[0..hlen]);
  343. try out.appendSlice(alloc, &mask);
  344. for (payload, 0..) |b, i| try out.append(alloc, b ^ mask[i % 4]);
  345. return out.toOwnedSlice(alloc);
  346. }
  348. test "decode masked text frame" {
  349. var dec = Decoder.init(t.allocator);
  350. defer dec.deinit();
  351. const frame = try maskedFrame(t.allocator, true, .text, "Hello", .{ 0x37, 0xfa, 0x21, 0x3d });
  352. defer t.allocator.free(frame);
  353. try dec.feed(frame);
  354. var ev = (try dec.next()).?;
  355. defer ev.deinitPayload(t.allocator);
  356. try t.expectEqualStrings("Hello", ev.text);
  357. try t.expectEqual(@as(?Event, null), try dec.next());
  358. }
  360. test "decode split across feeds" {
  361. var dec = Decoder.init(t.allocator);
  362. defer dec.deinit();
  363. const frame = try maskedFrame(t.allocator, true, .text, "chunked delivery", .{ 1, 2, 3, 4 });
  364. defer t.allocator.free(frame);
  365. try dec.feed(frame[0..3]);
  366. try t.expectEqual(@as(?Event, null), try dec.next());
  367. try dec.feed(frame[3..]);
  368. var ev = (try dec.next()).?;
  369. defer ev.deinitPayload(t.allocator);
  370. try t.expectEqualStrings("chunked delivery", ev.text);
  371. }
  373. test "fragmented message assembly" {
  374. var dec = Decoder.init(t.allocator);
  375. defer dec.deinit();
  376. const f1 = try maskedFrame(t.allocator, false, .text, "Hel", .{ 9, 8, 7, 6 });
  377. defer t.allocator.free(f1);
  378. const f2 = try maskedFrame(t.allocator, false, .continuation, "lo ", .{ 5, 4, 3, 2 });
  379. defer t.allocator.free(f2);
  380. const f3 = try maskedFrame(t.allocator, true, .continuation, "WS", .{ 1, 1, 1, 1 });
  381. defer t.allocator.free(f3);
  382. try dec.feed(f1);
  383. try dec.feed(f2);
  384. try t.expectEqual(@as(?Event, null), try dec.next());
  385. try dec.feed(f3);
  386. var ev = (try dec.next()).?;
  387. defer ev.deinitPayload(t.allocator);
  388. try t.expectEqualStrings("Hello WS", ev.text);
  389. }
  391. test "control frame interleaved with fragments" {
  392. var dec = Decoder.init(t.allocator);
  393. defer dec.deinit();
  394. const f1 = try maskedFrame(t.allocator, false, .text, "par", .{ 2, 2, 2, 2 });
  395. defer t.allocator.free(f1);
  396. const ping = try maskedFrame(t.allocator, true, .ping, "hb", .{ 3, 3, 3, 3 });
  397. defer t.allocator.free(ping);
  398. const f2 = try maskedFrame(t.allocator, true, .continuation, "tial", .{ 4, 4, 4, 4 });
  399. defer t.allocator.free(f2);
  400. try dec.feed(f1);
  401. try dec.feed(ping);
  402. var ev1 = (try dec.next()).?;
  403. defer ev1.deinitPayload(t.allocator);
  404. try t.expectEqualStrings("hb", ev1.ping);
  405. try dec.feed(f2);
  406. var ev2 = (try dec.next()).?;
  407. defer ev2.deinitPayload(t.allocator);
  408. try t.expectEqualStrings("partial", ev2.text);
  409. }
  411. test "unmasked client frame is a protocol error" {
  412. var dec = Decoder.init(t.allocator);
  413. defer dec.deinit();
  414. var hdr: [10]u8 = undefined;
  415. const hlen = encodeFrameHeader(&hdr, .text, 2, true);
  416. try dec.feed(hdr[0..hlen]);
  417. try dec.feed("hi");
  418. const ev = (try dec.next()).?;
  419. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  420. try t.expectEqual(@as(?Event, null), try dec.next()); // stream dead
  421. }
  423. test "invalid UTF-8 in text is 1007" {
  424. var dec = Decoder.init(t.allocator);
  425. defer dec.deinit();
  426. const bad = [_]u8{ 0xC3, 0x28 }; // invalid 2-byte sequence
  427. const frame = try maskedFrame(t.allocator, true, .text, &bad, .{ 7, 7, 7, 7 });
  428. defer t.allocator.free(frame);
  429. try dec.feed(frame);
  430. const ev = (try dec.next()).?;
  431. try t.expectEqual(CLOSE_INVALID_PAYLOAD, ev.protocol_error);
  432. }
  434. test "close with code and reason" {
  435. var dec = Decoder.init(t.allocator);
  436. defer dec.deinit();
  437. var payload: [7]u8 = undefined;
  438. std.mem.writeInt(u16, payload[0..2], 1000, .big);
  439. @memcpy(payload[2..], "done!");
  440. const frame = try maskedFrame(t.allocator, true, .close, &payload, .{ 6, 6, 6, 6 });
  441. defer t.allocator.free(frame);
  442. try dec.feed(frame);
  443. var ev = (try dec.next()).?;
  444. defer ev.deinitPayload(t.allocator);
  445. try t.expectEqual(@as(u16, 1000), ev.close.code);
  446. try t.expectEqualStrings("done!", ev.close.reason);
  447. }
  449. test "close with invalid code is 1002" {
  450. var dec = Decoder.init(t.allocator);
  451. defer dec.deinit();
  452. var payload: [2]u8 = undefined;
  453. std.mem.writeInt(u16, payload[0..2], 1006, .big); // 1006 must never appear on the wire
  454. const frame = try maskedFrame(t.allocator, true, .close, &payload, .{ 1, 2, 3, 4 });
  455. defer t.allocator.free(frame);
  456. try dec.feed(frame);
  457. const ev = (try dec.next()).?;
  458. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  459. }
  461. test "fragmented control frame is 1002" {
  462. var dec = Decoder.init(t.allocator);
  463. defer dec.deinit();
  464. const frame = try maskedFrame(t.allocator, false, .ping, "x", .{ 1, 2, 3, 4 });
  465. defer t.allocator.free(frame);
  466. try dec.feed(frame);
  467. const ev = (try dec.next()).?;
  468. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  469. }
  471. test "continuation without message is 1002" {
  472. var dec = Decoder.init(t.allocator);
  473. defer dec.deinit();
  474. const frame = try maskedFrame(t.allocator, true, .continuation, "x", .{ 1, 2, 3, 4 });
  475. defer t.allocator.free(frame);
  476. try dec.feed(frame);
  477. const ev = (try dec.next()).?;
  478. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  479. }
  481. test "new data frame while assembling is 1002" {
  482. var dec = Decoder.init(t.allocator);
  483. defer dec.deinit();
  484. const f1 = try maskedFrame(t.allocator, false, .text, "a", .{ 1, 2, 3, 4 });
  485. defer t.allocator.free(f1);
  486. const f2 = try maskedFrame(t.allocator, true, .text, "b", .{ 1, 2, 3, 4 });
  487. defer t.allocator.free(f2);
  488. try dec.feed(f1);
  489. try dec.feed(f2);
  490. const ev = (try dec.next()).?;
  491. try t.expectEqual(CLOSE_PROTOCOL_ERROR, ev.protocol_error);
  492. }
  494. test "oversize message is 1009" {
  495. var dec = Decoder.init(t.allocator);
  496. defer dec.deinit();
  497. dec.max_message_size = 8;
  498. const frame = try maskedFrame(t.allocator, true, .text, "123456789", .{ 1, 2, 3, 4 });
  499. defer t.allocator.free(frame);
  500. try dec.feed(frame);
  501. const ev = (try dec.next()).?;
  502. try t.expectEqual(CLOSE_TOO_BIG, ev.protocol_error);
  503. }
  505. test "16-bit extended length round trip" {
  506. var dec = Decoder.init(t.allocator);
  507. defer dec.deinit();
  508. const big = try t.allocator.alloc(u8, 300);
  509. defer t.allocator.free(big);
  510. @memset(big, 'A');
  511. const frame = try maskedFrame(t.allocator, true, .binary, big, .{ 9, 9, 9, 9 });
  512. defer t.allocator.free(frame);
  513. try dec.feed(frame);
  514. var ev = (try dec.next()).?;
  515. defer ev.deinitPayload(t.allocator);
  516. try t.expectEqual(@as(usize, 300), ev.binary.len);
  517. try t.expectEqual(@as(u8, 'A'), ev.binary[150]);
  518. }
  520. test "writeFrame emits parseable frame" {
  521. const Sink = struct {
  522. var buf: std.ArrayListUnmanaged(u8) = .empty;
  523. fn write(_: ?*anyopaque, data: []const u8) bool {
  524. buf.appendSlice(t.allocator, data) catch return false;
  525. return true;
  526. }
  527. };
  528. defer Sink.buf.deinit(t.allocator);
  529. try t.expect(writeFrame(&Sink.write, null, .text, "server says hi"));
  530. // Parse it back with an unmasked-tolerant decoder (client role)
  531. var dec = Decoder.init(t.allocator);
  532. dec.require_masked = false;
  533. defer dec.deinit();
  534. try dec.feed(Sink.buf.items);
  535. var ev = (try dec.next()).?;
  536. defer ev.deinitPayload(t.allocator);
  537. try t.expectEqualStrings("server says hi", ev.text);
  538. }
  540. test "writeClose encodes code and reason" {
  541. const Sink = struct {
  542. var buf: std.ArrayListUnmanaged(u8) = .empty;
  543. fn write(_: ?*anyopaque, data: []const u8) bool {
  544. buf.appendSlice(t.allocator, data) catch return false;
  545. return true;
  546. }
  547. };
  548. defer Sink.buf.deinit(t.allocator);
  549. try t.expect(writeClose(&Sink.write, null, 1000, "bye"));
  550. var dec = Decoder.init(t.allocator);
  551. dec.require_masked = false;
  552. defer dec.deinit();
  553. try dec.feed(Sink.buf.items);
  554. var ev = (try dec.next()).?;
  555. defer ev.deinitPayload(t.allocator);
  556. try t.expectEqual(@as(u16, 1000), ev.close.code);
  557. try t.expectEqualStrings("bye", ev.close.reason);
  558. }

Branches

Latest commits

  • 93dfb0batracker#40 (mission 034): the curated franchises — data/franchises.json (17 franchises, 31 timelines, 285 TMDB titles, movies + series, in-universe/release order, 12 TMDB collections attached); lib/franchiseseed.hl + jobs.hl franchiseSeedTick (last start job, imports missing titles via details.hl importWithCredits = the search's Add, one per step paced, then one build; franchiseseed.db: editor changes win, the creator's same-name franchise adopted / timeline left alone, 404 remembered, resumable, idempotent); timeline heads 'N titles · in-universe order' (orderKind) and wrap on a phone; series pages show the widget; new gate tests/franchiseseed.mjs (5th in deploy.sh), the others run with TRACKER_FRANCHISE_SEED=0; gates 365/0, 32/0, 52/0, 24/0, check-theme 0; real copy 196 imported, 0 failed, 7 min, restart unchanged=31mre
  • 96ba683adeploy.sh: a gate without a 'passed,' line (check-theme) no longer ends the scriptmre
  • eb3b9205tracker: report 031mre
  • 9b5d2e89tracker mission 031: README (What it does, Test: four gates + the #32 checks, Files: theme/, new pages), STATUS (real copy, A/B load, how to repeat, open points), LOGmre
  • 39950e4ctracker#32 (mission 031): the WorldAPI theme (theme/ vendored verbatim from layouts.worldapi.org 85b5654; styles.hl inherits it: accent green-dark, type colours 1-6; own base/header rules, row lines, genre-pill and inverted-button frames removed, the season foldable keeps its line; check-theme 21 -> 0, 4th deploy gate; main actions class primary) and the #32 header (theme AppHeader/MainMenu/UserMenu/Sidebar/ContentFirst: desktop brand, search, Series|Shows|Movies|Genres|People, user icon with Unwatched..Settings, Logout; signed out the ident selector, phone the iD icon dropdown; phone menu in the sidebar overlay; marked entry by :has); /find -> /search/<q>, /genres, /people(/<letter>), /settings; main { ContentFirst { slot } } works around the hl:web one-line slot bug; gates 365/0, 32/0, 52/0, check-theme 0mre
  • a386dc92tracker: reports 029 + 030mre
  • 71e0fd7dtracker missions 029 + 030: README (What it does, Files, gate count), STATUS (real-copy numbers, how to repeat, open points), LOGmre
  • d36ea6eatracker#34 + #35 (mission 030): Follow directly under the poster, as wide as the poster (show.hl, styles.hl); the status pill next to a series' title — TVmaze's status (new tvmazeStatus, stored by the sync's TVmaze merge) else TMDB's, TVmaze Ended + TMDB Canceled = Canceled, inverted (filled, dark text, no border), green running / yellow pending / red canceled / muted ended (shows.hl statusOf); the daily delta asks TVmaze's status of an unfollowed series TVmaze's change list names (dailysync.hl syncRunStep, sync.hl syncTvmazeStatus); the status backfill after the details repair (backfill.hl, jobs.hl statusTick; resumable, 550 ms per TVmaze request); gates 354/0, 32/0, 52/0mre
  • 7d7d4487tracker#33 (mission 029): reduced titles — every title TMDB's details never went through this app (no detailsAt, no tmdbSync) is incomplete (shows.hl isIncomplete; the old tracker's migrated rows passed #26's test: 5,697 non-adult on the live copy, 691 series without seasons); the repair job does the visibly reduced first (shows.hl missingParts), the page completes one on open; a title TMDB has no poster for (The Remaining) shows the placeholder; tools/count-incomplete.hl; gate fixtures stand for synced titles (tmdbSync), tests/seed-reduced.hl + #33 checks; gates 347/0, 32/0, 52/0mre
  • 661c2592tracker: report 028mre
  • 27c916fatracker mission 028: README ("Code order", the new file map), STATUS (counts before/after, tests, how to repeat, open), LOGmre
  • d924f398tracker mission 028: comments name the new files (sync.hl, dailysync.hl, backfill.hl, credits.hl, jobs.hl, images.hl …); tools/ref-params.py + tools/lambda-audit.py also scan lib/ (they globbed the root only), lambda-audit counts a plain `x = p` alias like `let x = p`mre
  • 2e89b968tracker mission 028 (code order) 5/5 let: `let` only where a variable is reassigned — 667 never-reassigned lets became plain declarations (project.hl, lib/, components/, tools/, tests/); kept: 264 in loop bodies (a plain declaration there is 'Cannot reassign' on the 2nd pass), 234 reassigned, 27 whose name is also a member/outer/free name (a plain write would rebind it); tools/let-audit.py decides and fixes (README 'Code order'); tests/realdata-m028.{sh,mjs} = the page-output diff on a real copy; gates 342/0, 32/0, 52/0, real-copy pages identicalmre
  • 54796ff2tracker mission 028 (code order) 4/5 thin faces + last copies: the show page's check/follow faces call lib/watches.hl toggleWatched / toggleSeasonWatched (seasonAllWatched moved there) and lib/follows.hl toggleFollowed; both logins (header selector face, /login/callback) share lib/users.hl userOfCode; todayStr/listOf copies in components and the export readers copied into tools/migrate.hl + tools/old-short-ids.hl now once (lib/util.hl, lib/export.hl); gates 342/0, 32/0, 52/0; old-short-ids output byte-identical, migrate output identicalmre
  • 06b078e3tracker mission 028 (code order) 3/5 project.hl is the map: config, routes, wiring and a feature → file index (914 → 258 lines); the background jobs (daily sync run, backfills, details repair, credits job, merge, short ids, collection seed) moved unchanged into lib/jobs.hl (a class: their state is reassigned every step, a static cannot be; one instance made after the server), the login callback into lib/users.hl, poster/photo serving into lib/images.hl, the /shows/<slug> rule into lib/shows.hl showsMovedPath; route handlers are thin wrappers; gates 342/0, 32/0, 52/0, real-copy pages identicalmre
  • 94716fd2tracker mission 028 (code order) 2/5 util + topics: lib/util.hl holds envOr, storageDir, postersDir, profilesDir, newId, hexDigits, todayStr, dateOr, textOr, hasId, listOr, firstOf, sortDesc once (were copied into up to 5 files); tmdbsync.hl split into tmdb.hl (TMDB/TVmaze requests), sync.hl (one title's sync), sync-helpers.hl, backfill.hl; details.hl split into details.hl, credits.hl, credits-helpers.hl (isIncomplete to shows.hl); search-helpers.hl (words, query, ranking, slugs); collections.hl (the TMDB collection seed, out of franchises.hl); deltasync.hl renamed dailysync.hl; no behaviour change: gates 342/0, 32/0, 52/0, real-copy pages identicalmre
  • 186079b0tracker mission 028 (code order) 1/5 move: every root .hl except project.hl into lib/ (styles.hl into components/), import paths only; gates 342/0, 32/0, 52/0; real-copy pages identicalmre
  • 4f47f181tracker: report 027mre
  • dc1d4be4tracker mission 027: Hybriel master 06617221 vendored (plugin allocator fixes 3a781359 + 413f60e4); real copy RSS through first-start jobs + 400 loads flat ~2.55 GB (190aa11d 2.3 -> 5.6 GB), page times <= 1.1x; gates 342/0, 32/0, 52/0mre
  • 84e1b3e1tracker: reports 025 + 026mre