gitoriaLog in with ident

tracker

All repositories: gitoria

ReadmeCodePull requestsReleasesTicketsSettingsCommit06b078e306b078e3tracker 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 identicalmre06b078e3/plugins/mpackdb/msgpack.zig

22.6 KB

  1. // MessagePack codec for hl:mpackdb — byte-compatible with npm msgpackr 1.11.5
  2. // as mpackdb v1.0.7 uses it (decision D12).
  3. //
  4. // Measured msgpackr surface (probed against the real library, see
  5. // testdata/gen_corpus.mjs):
  6. // - NO record/shared-structure extensions: the standalone pack() export
  7. // serializes plain objects as ordinary MessagePack maps.
  8. // - Objects ALWAYS encode as map16 (0xde) — even empty — never fixmap/map32.
  9. // Maps with > 65535 keys throw in msgpackr; we mirror with error.MapTooLarge.
  10. // - Numbers: integer-valued f64 in [-2^31, 2^32) uses the smallest
  11. // uint/int family (fixint, cc, cd, ce / negfixint, d0, d1, d2). Everything
  12. // else (non-integers, |v| outside that range, NaN, ±Inf) is float64 (0xcb).
  13. // msgpackr never emits float32 or int64/uint64 for JS numbers.
  14. // - Strings: fixstr ≤31 bytes, str8 ≤255, str16 ≤65535, str32 beyond.
  15. // - Arrays: fixarray ≤15, array16 ≤65535, array32 beyond.
  16. // - Binary: bin8/16/32 by length.
  17. // - undefined: fixext1 type 0x00 data 0x00 (d4 00 00) — kept as a distinct
  18. // Value so re-encode is byte-exact; it surfaces as null in Hybriel.
  19. // - Date: timestamp ext -1 (d6ff / d7ff / c70cff). Kept as a raw ext Value
  20. // for byte-exact round-trips; timestampMs() interprets it.
  21. //
  22. // Decode accepts the FULL MessagePack spec (all int/str/bin/array/map families,
  23. // float32, int64/uint64, all ext forms); encode emits only the canonical
  24. // msgpackr subset above.
  26. const std = @import("std");
  28. pub const Error = error{
  29. Truncated,
  30. InvalidFormat, // 0xc1
  31. MapTooLarge,
  32. OutOfMemory,
  33. };
  35. pub const Ext = struct {
  36. type: i8,
  37. data: []const u8,
  38. };
  40. pub const Entry = struct {
  41. key: Value,
  42. value: Value,
  43. };
  45. pub const Value = union(enum) {
  46. nil,
  47. undef, // msgpackr `undefined` (fixext1 type 0)
  48. boolean: bool,
  49. number: f64,
  50. str: []const u8,
  51. bin: []const u8,
  52. array: []Value,
  53. map: []Entry,
  54. ext: Ext,
  56. /// Interpret a timestamp ext (-1) as milliseconds since epoch.
  57. pub fn timestampMs(self: Value) ?f64 {
  58. if (self != .ext or self.ext.type != -1) return null;
  59. const d = self.ext.data;
  60. switch (d.len) {
  61. 4 => {
  62. const sec = std.mem.readInt(u32, d[0..4], .big);
  63. return @as(f64, @floatFromInt(sec)) * 1000.0;
  64. },
  65. 8 => {
  66. const packed_v = std.mem.readInt(u64, d[0..8], .big);
  67. const ns: f64 = @floatFromInt(packed_v >> 34);
  68. const sec: f64 = @floatFromInt(packed_v & 0x3ffffffff);
  69. return sec * 1000.0 + ns / 1_000_000.0;
  70. },
  71. 12 => {
  72. const ns = std.mem.readInt(u32, d[0..4], .big);
  73. const sec = std.mem.readInt(i64, d[4..12], .big);
  74. return @as(f64, @floatFromInt(sec)) * 1000.0 + @as(f64, @floatFromInt(ns)) / 1_000_000.0;
  75. },
  76. else => return null,
  77. }
  78. }
  80. /// Map field lookup by string key (returns null for missing / non-map).
  81. pub fn get(self: Value, key: []const u8) ?Value {
  82. if (self != .map) return null;
  83. for (self.map) |e| {
  84. if (e.key == .str and std.mem.eql(u8, e.key.str, key)) return e.value;
  85. }
  86. return null;
  87. }
  88. };
  90. pub const Decoded = struct {
  91. value: Value,
  92. len: usize, // bytes consumed
  93. };
  95. /// Decode one MessagePack value from `bytes`. All slices in the returned Value
  96. /// reference memory allocated from `alloc` (str/bin/ext data are duplicated,
  97. /// so the Value outlives `bytes`). Use an arena and free it wholesale.
  98. pub fn decode(alloc: std.mem.Allocator, bytes: []const u8) Error!Decoded {
  99. var d = Decoder{ .alloc = alloc, .bytes = bytes, .pos = 0 };
  100. const v = try d.readValue();
  101. return .{ .value = v, .len = d.pos };
  102. }
  104. const Decoder = struct {
  105. alloc: std.mem.Allocator,
  106. bytes: []const u8,
  107. pos: usize,
  109. fn need(self: *Decoder, n: usize) Error!void {
  110. if (self.pos + n > self.bytes.len) return Error.Truncated;
  111. }
  113. fn take(self: *Decoder, n: usize) Error![]const u8 {
  114. try self.need(n);
  115. const s = self.bytes[self.pos .. self.pos + n];
  116. self.pos += n;
  117. return s;
  118. }
  120. fn readBigInt(self: *Decoder, comptime T: type) Error!T {
  121. const n = @divExact(@typeInfo(T).int.bits, 8);
  122. const s = try self.take(n);
  123. return std.mem.readInt(T, s[0..n], .big);
  124. }
  126. fn dupSlice(self: *Decoder, n: usize) Error![]const u8 {
  127. const s = try self.take(n);
  128. return self.alloc.dupe(u8, s) catch return Error.OutOfMemory;
  129. }
  131. fn readArray(self: *Decoder, n: usize) Error!Value {
  132. const items = self.alloc.alloc(Value, n) catch return Error.OutOfMemory;
  133. for (items) |*it| it.* = try self.readValue();
  134. return .{ .array = items };
  135. }
  137. fn readMap(self: *Decoder, n: usize) Error!Value {
  138. const entries = self.alloc.alloc(Entry, n) catch return Error.OutOfMemory;
  139. for (entries) |*e| {
  140. e.key = try self.readValue();
  141. e.value = try self.readValue();
  142. }
  143. return .{ .map = entries };
  144. }
  146. fn readExt(self: *Decoder, n: usize) Error!Value {
  147. try self.need(1 + n);
  148. const t: i8 = @bitCast(self.bytes[self.pos]);
  149. self.pos += 1;
  150. const data = try self.dupSlice(n);
  151. // msgpackr undefined: fixext1 type 0, data byte 0
  152. if (t == 0 and n == 1 and data[0] == 0) return .undef;
  153. return .{ .ext = .{ .type = t, .data = data } };
  154. }
  156. fn readValue(self: *Decoder) Error!Value {
  157. try self.need(1);
  158. const b = self.bytes[self.pos];
  159. self.pos += 1;
  160. switch (b) {
  161. 0x00...0x7f => return .{ .number = @floatFromInt(b) },
  162. 0x80...0x8f => return self.readMap(b & 0x0f),
  163. 0x90...0x9f => return self.readArray(b & 0x0f),
  164. 0xa0...0xbf => return .{ .str = try self.dupSlice(b & 0x1f) },
  165. 0xc0 => return .nil,
  166. 0xc1 => return Error.InvalidFormat,
  167. 0xc2 => return .{ .boolean = false },
  168. 0xc3 => return .{ .boolean = true },
  169. 0xc4 => return .{ .bin = try self.dupSlice(try self.readBigInt(u8)) },
  170. 0xc5 => return .{ .bin = try self.dupSlice(try self.readBigInt(u16)) },
  171. 0xc6 => return .{ .bin = try self.dupSlice(try self.readBigInt(u32)) },
  172. 0xc7 => return self.readExt(try self.readBigInt(u8)),
  173. 0xc8 => return self.readExt(try self.readBigInt(u16)),
  174. 0xc9 => return self.readExt(try self.readBigInt(u32)),
  175. 0xca => {
  176. const bits = try self.readBigInt(u32);
  177. return .{ .number = @as(f32, @bitCast(bits)) };
  178. },
  179. 0xcb => {
  180. const bits = try self.readBigInt(u64);
  181. return .{ .number = @bitCast(bits) };
  182. },
  183. 0xcc => return .{ .number = @floatFromInt(try self.readBigInt(u8)) },
  184. 0xcd => return .{ .number = @floatFromInt(try self.readBigInt(u16)) },
  185. 0xce => return .{ .number = @floatFromInt(try self.readBigInt(u32)) },
  186. 0xcf => return .{ .number = @floatFromInt(try self.readBigInt(u64)) },
  187. 0xd0 => return .{ .number = @floatFromInt(@as(i8, @bitCast(try self.readBigInt(u8)))) },
  188. 0xd1 => return .{ .number = @floatFromInt(@as(i16, @bitCast(try self.readBigInt(u16)))) },
  189. 0xd2 => return .{ .number = @floatFromInt(@as(i32, @bitCast(try self.readBigInt(u32)))) },
  190. 0xd3 => return .{ .number = @floatFromInt(@as(i64, @bitCast(try self.readBigInt(u64)))) },
  191. 0xd4 => return self.readExt(1),
  192. 0xd5 => return self.readExt(2),
  193. 0xd6 => return self.readExt(4),
  194. 0xd7 => return self.readExt(8),
  195. 0xd8 => return self.readExt(16),
  196. 0xd9 => return .{ .str = try self.dupSlice(try self.readBigInt(u8)) },
  197. 0xda => return .{ .str = try self.dupSlice(try self.readBigInt(u16)) },
  198. 0xdb => return .{ .str = try self.dupSlice(try self.readBigInt(u32)) },
  199. 0xdc => return self.readArray(try self.readBigInt(u16)),
  200. 0xdd => return self.readArray(try self.readBigInt(u32)),
  201. 0xde => return self.readMap(try self.readBigInt(u16)),
  202. 0xdf => return self.readMap(try self.readBigInt(u32)),
  203. 0xe0...0xff => return .{ .number = @floatFromInt(@as(i8, @bitCast(b))) },
  204. }
  205. }
  206. };
  208. /// Encode a Value in the canonical msgpackr form (see header comment).
  209. pub fn encode(alloc: std.mem.Allocator, value: Value) Error![]u8 {
  210. var buf: std.ArrayList(u8) = .empty;
  211. errdefer buf.deinit(alloc);
  212. try encodeInto(alloc, &buf, value);
  213. return buf.toOwnedSlice(alloc) catch Error.OutOfMemory;
  214. }
  216. pub fn encodeInto(alloc: std.mem.Allocator, buf: *std.ArrayList(u8), value: Value) Error!void {
  217. const w = Writer{ .alloc = alloc, .buf = buf };
  218. try w.writeValue(value);
  219. }
  221. const Writer = struct {
  222. alloc: std.mem.Allocator,
  223. buf: *std.ArrayList(u8),
  225. fn byte(self: Writer, b: u8) Error!void {
  226. self.buf.append(self.alloc, b) catch return Error.OutOfMemory;
  227. }
  229. fn raw(self: Writer, s: []const u8) Error!void {
  230. self.buf.appendSlice(self.alloc, s) catch return Error.OutOfMemory;
  231. }
  233. fn big(self: Writer, comptime T: type, v: T) Error!void {
  234. var tmp: [@divExact(@typeInfo(T).int.bits, 8)]u8 = undefined;
  235. std.mem.writeInt(T, &tmp, v, .big);
  236. try self.raw(&tmp);
  237. }
  239. fn writeNumber(self: Writer, v: f64) Error!void {
  240. // msgpackr rule (measured): integer-valued and within [-2^31, 2^32) →
  241. // smallest int family; else float64. -0 encodes as fixint 0.
  242. if (v == @floor(v) and v >= -2147483648.0 and v <= 4294967295.0) {
  243. if (v >= 0) {
  244. const u: u32 = @intFromFloat(v);
  245. if (u < 0x80) return self.byte(@intCast(u));
  246. if (u <= 0xff) {
  247. try self.byte(0xcc);
  248. return self.byte(@intCast(u));
  249. }
  250. if (u <= 0xffff) {
  251. try self.byte(0xcd);
  252. return self.big(u16, @intCast(u));
  253. }
  254. try self.byte(0xce);
  255. return self.big(u32, u);
  256. } else {
  257. const i: i32 = @intFromFloat(v);
  258. if (i >= -32) return self.byte(@bitCast(@as(i8, @intCast(i))));
  259. if (i >= -128) {
  260. try self.byte(0xd0);
  261. return self.byte(@bitCast(@as(i8, @intCast(i))));
  262. }
  263. if (i >= -32768) {
  264. try self.byte(0xd1);
  265. return self.big(u16, @bitCast(@as(i16, @intCast(i))));
  266. }
  267. try self.byte(0xd2);
  268. return self.big(u32, @bitCast(i));
  269. }
  270. }
  271. try self.byte(0xcb);
  272. return self.big(u64, @bitCast(v));
  273. }
  275. fn writeStr(self: Writer, s: []const u8) Error!void {
  276. if (s.len <= 31) {
  277. try self.byte(0xa0 | @as(u8, @intCast(s.len)));
  278. } else if (s.len <= 0xff) {
  279. try self.byte(0xd9);
  280. try self.byte(@intCast(s.len));
  281. } else if (s.len <= 0xffff) {
  282. try self.byte(0xda);
  283. try self.big(u16, @intCast(s.len));
  284. } else {
  285. try self.byte(0xdb);
  286. try self.big(u32, @intCast(s.len));
  287. }
  288. return self.raw(s);
  289. }
  291. fn writeValue(self: Writer, value: Value) Error!void {
  292. switch (value) {
  293. .nil => try self.byte(0xc0),
  294. .undef => try self.raw(&[_]u8{ 0xd4, 0x00, 0x00 }),
  295. .boolean => |b| try self.byte(if (b) 0xc3 else 0xc2),
  296. .number => |n| try self.writeNumber(n),
  297. .str => |s| try self.writeStr(s),
  298. .bin => |s| {
  299. if (s.len <= 0xff) {
  300. try self.byte(0xc4);
  301. try self.byte(@intCast(s.len));
  302. } else if (s.len <= 0xffff) {
  303. try self.byte(0xc5);
  304. try self.big(u16, @intCast(s.len));
  305. } else {
  306. try self.byte(0xc6);
  307. try self.big(u32, @intCast(s.len));
  308. }
  309. try self.raw(s);
  310. },
  311. .array => |items| {
  312. if (items.len <= 15) {
  313. try self.byte(0x90 | @as(u8, @intCast(items.len)));
  314. } else if (items.len <= 0xffff) {
  315. try self.byte(0xdc);
  316. try self.big(u16, @intCast(items.len));
  317. } else {
  318. try self.byte(0xdd);
  319. try self.big(u32, @intCast(items.len));
  320. }
  321. for (items) |it| try self.writeValue(it);
  322. },
  323. .map => |entries| {
  324. // msgpackr: objects are ALWAYS map16, >65535 keys throws.
  325. if (entries.len > 0xffff) return Error.MapTooLarge;
  326. try self.byte(0xde);
  327. try self.big(u16, @intCast(entries.len));
  328. for (entries) |e| {
  329. try self.writeValue(e.key);
  330. try self.writeValue(e.value);
  331. }
  332. },
  333. .ext => |e| {
  334. switch (e.data.len) {
  335. 1 => try self.byte(0xd4),
  336. 2 => try self.byte(0xd5),
  337. 4 => try self.byte(0xd6),
  338. 8 => try self.byte(0xd7),
  339. 16 => try self.byte(0xd8),
  340. else => {
  341. if (e.data.len <= 0xff) {
  342. try self.byte(0xc7);
  343. try self.byte(@intCast(e.data.len));
  344. } else if (e.data.len <= 0xffff) {
  345. try self.byte(0xc8);
  346. try self.big(u16, @intCast(e.data.len));
  347. } else {
  348. try self.byte(0xc9);
  349. try self.big(u32, @intCast(e.data.len));
  350. }
  351. },
  352. }
  353. try self.byte(@bitCast(e.type));
  354. try self.raw(e.data);
  355. },
  356. }
  357. }
  358. };
  360. // =========================================================================
  361. // mpackdb record framing: [4-byte LE total size incl. prefix][msgpack]
  362. // =========================================================================
  364. /// Serialize a value with mpackdb's 4-byte little-endian length prefix.
  365. pub fn serialize(alloc: std.mem.Allocator, value: Value) Error![]u8 {
  366. var buf: std.ArrayList(u8) = .empty;
  367. errdefer buf.deinit(alloc);
  368. buf.appendSlice(alloc, &[_]u8{ 0, 0, 0, 0 }) catch return Error.OutOfMemory;
  369. try encodeInto(alloc, &buf, value);
  370. const total: u32 = @intCast(buf.items.len);
  371. std.mem.writeInt(u32, buf.items[0..4], total, .little);
  372. return buf.toOwnedSlice(alloc) catch Error.OutOfMemory;
  373. }
  375. /// Read the length prefix of a framed record (total size incl. the 4 bytes).
  376. pub fn readSize(bytes: []const u8) Error!u32 {
  377. if (bytes.len < 4) return Error.Truncated;
  378. return std.mem.readInt(u32, bytes[0..4], .little);
  379. }
  381. /// Deserialize a framed record ([4-byte LE size][msgpack]).
  382. pub fn deserializeFramed(alloc: std.mem.Allocator, bytes: []const u8) Error!Value {
  383. const total = try readSize(bytes);
  384. if (total < 5 or total > bytes.len) return Error.Truncated;
  385. const d = try decode(alloc, bytes[4..total]);
  386. return d.value;
  387. }
  389. // =========================================================================
  390. // Tests
  391. // =========================================================================
  393. const testing = std.testing;
  395. /// Linux-syscall file read (plugins avoid std.Io plumbing; same pattern as
  396. /// plugins/fs/fs.zig). Returns null when the file cannot be opened.
  397. fn readFileLinux(alloc: std.mem.Allocator, path: []const u8) ?[]u8 {
  398. const linux = std.os.linux;
  399. const path_z = alloc.dupeZ(u8, path) catch return null;
  400. defer alloc.free(path_z);
  401. const rc = linux.open(path_z, .{}, 0);
  402. const fd: i32 = @bitCast(@as(u32, @truncate(rc)));
  403. if (fd < 0) return null;
  404. defer _ = linux.close(fd);
  405. var content: std.ArrayList(u8) = .empty;
  406. var buf: [65536]u8 = undefined;
  407. while (true) {
  408. const n = linux.read(fd, &buf, buf.len);
  409. if (@as(isize, @bitCast(n)) <= 0) break;
  410. content.appendSlice(alloc, buf[0..n]) catch return null;
  411. }
  412. return content.toOwnedSlice(alloc) catch null;
  413. }
  415. test "corpus: decode + canonical re-encode is byte-identical (msgpackr 1.11.5)" {
  416. var arena = std.heap.ArenaAllocator.init(testing.allocator);
  417. defer arena.deinit();
  418. const alloc = arena.allocator();
  420. // Corpus lives next to this file; zig build test runs with cwd native/.
  421. const candidates = [_][]const u8{
  422. "../plugins/mpackdb/testdata/corpus.json",
  423. "plugins/mpackdb/testdata/corpus.json",
  424. };
  425. var content: ?[]u8 = null;
  426. for (candidates) |p| {
  427. content = readFileLinux(alloc, p) orelse continue;
  428. break;
  429. }
  430. const json = content orelse return error.CorpusNotFound;
  432. const parsed = try std.json.parseFromSlice(std.json.Value, alloc, json, .{});
  433. const arr = parsed.value.array;
  434. try testing.expect(arr.items.len >= 70);
  436. var checked: usize = 0;
  437. for (arr.items) |item| {
  438. const obj = item.object;
  439. const hex = obj.get("hex").?.string;
  440. const framed = if (obj.get("framed")) |f| f.bool else false;
  441. const bytes = try alloc.alloc(u8, hex.len / 2);
  442. _ = try std.fmt.hexToBytes(bytes, hex);
  444. if (framed) {
  445. // Frame round-trip: parse prefix, decode, re-serialize, compare all.
  446. const total = try readSize(bytes);
  447. try testing.expectEqual(bytes.len, @as(usize, total));
  448. const v = try deserializeFramed(alloc, bytes);
  449. const re = try serialize(alloc, v);
  450. try testing.expectEqualSlices(u8, bytes, re);
  451. } else {
  452. const d = try decode(alloc, bytes);
  453. try testing.expectEqual(bytes.len, d.len);
  454. const re = try encode(alloc, d.value);
  455. try testing.expectEqualSlices(u8, bytes, re);
  456. }
  457. checked += 1;
  458. }
  459. try testing.expect(checked == arr.items.len);
  460. }
  462. test "decode spot checks" {
  463. var arena = std.heap.ArenaAllocator.init(testing.allocator);
  464. defer arena.deinit();
  465. const alloc = arena.allocator();
  467. // {name:'Alice', age:30} as msgpackr encodes it (map16)
  468. var bytes: [19]u8 = undefined;
  469. _ = try std.fmt.hexToBytes(&bytes, "de0002a46e616d65a5416c696365a36167651e");
  470. const d = try decode(alloc, &bytes);
  471. const name = d.value.get("name").?;
  472. try testing.expectEqualStrings("Alice", name.str);
  473. try testing.expectEqual(@as(f64, 30), d.value.get("age").?.number);
  474. }
  476. test "decode non-canonical families (full spec)" {
  477. var arena = std.heap.ArenaAllocator.init(testing.allocator);
  478. defer arena.deinit();
  479. const alloc = arena.allocator();
  481. // fixmap {a:1}
  482. var b1: [4]u8 = undefined;
  483. _ = try std.fmt.hexToBytes(&b1, "81a16101");
  484. const v1 = try decode(alloc, &b1);
  485. try testing.expectEqual(@as(f64, 1), v1.value.get("a").?.number);
  487. // map32 {a:1}
  488. var b2: [8]u8 = undefined;
  489. _ = try std.fmt.hexToBytes(&b2, "df00000001a16101");
  490. const v2 = try decode(alloc, &b2);
  491. try testing.expectEqual(@as(f64, 1), v2.value.get("a").?.number);
  493. // int64 -1 (d3 ffffffffffffffff)
  494. var b3: [9]u8 = undefined;
  495. _ = try std.fmt.hexToBytes(&b3, "d3ffffffffffffffff");
  496. const v3 = try decode(alloc, &b3);
  497. try testing.expectEqual(@as(f64, -1), v3.value.number);
  499. // uint64 2^32 (cf 0000000100000000)
  500. var b4: [9]u8 = undefined;
  501. _ = try std.fmt.hexToBytes(&b4, "cf0000000100000000");
  502. const v4 = try decode(alloc, &b4);
  503. try testing.expectEqual(@as(f64, 4294967296), v4.value.number);
  505. // float32 0.5 (ca 3f000000)
  506. var b5: [5]u8 = undefined;
  507. _ = try std.fmt.hexToBytes(&b5, "ca3f000000");
  508. const v5 = try decode(alloc, &b5);
  509. try testing.expectEqual(@as(f64, 0.5), v5.value.number);
  511. // 0xc1 is invalid
  512. const bad = [_]u8{0xc1};
  513. try testing.expectError(Error.InvalidFormat, decode(alloc, &bad));
  514. }
  516. test "undefined is distinct and byte-exact" {
  517. var arena = std.heap.ArenaAllocator.init(testing.allocator);
  518. defer arena.deinit();
  519. const alloc = arena.allocator();
  520. const bytes = [_]u8{ 0xd4, 0x00, 0x00 };
  521. const d = try decode(alloc, &bytes);
  522. try testing.expect(d.value == .undef);
  523. const re = try encode(alloc, d.value);
  524. try testing.expectEqualSlices(u8, &bytes, re);
  525. }
  527. test "timestamp ext interpretation" {
  528. var arena = std.heap.ArenaAllocator.init(testing.allocator);
  529. defer arena.deinit();
  530. const alloc = arena.allocator();
  532. // date whole sec: d6 ff 66a39486 → 1721996422000 ms
  533. var b: [6]u8 = undefined;
  534. _ = try std.fmt.hexToBytes(&b, "d6ff66a39486");
  535. const d = try decode(alloc, &b);
  536. try testing.expectEqual(@as(f64, 1721996422000), d.value.timestampMs().?);
  538. // date ms: d7 ff 1d53530066a39486 → 1721996422123 ms
  539. var b2: [10]u8 = undefined;
  540. _ = try std.fmt.hexToBytes(&b2, "d7ff1d53530066a39486");
  541. const d2 = try decode(alloc, &b2);
  542. try testing.expectApproxEqAbs(@as(f64, 1721996422123), d2.value.timestampMs().?, 0.001);
  543. }
  545. test "framing" {
  546. var arena = std.heap.ArenaAllocator.init(testing.allocator);
  547. defer arena.deinit();
  548. const alloc = arena.allocator();
  550. var entries = [_]Entry{
  551. .{ .key = .{ .str = "id" }, .value = .{ .number = 1 } },
  552. };
  553. const v = Value{ .map = &entries };
  554. const framed = try serialize(alloc, v);
  555. try testing.expectEqual(@as(u32, @intCast(framed.len)), try readSize(framed));
  556. const back = try deserializeFramed(alloc, framed);
  557. try testing.expectEqual(@as(f64, 1), back.get("id").?.number);
  558. }
  560. test "encode number boundaries match msgpackr" {
  561. var arena = std.heap.ArenaAllocator.init(testing.allocator);
  562. defer arena.deinit();
  563. const alloc = arena.allocator();
  564. const cases = [_]struct { v: f64, hex: []const u8 }{
  565. .{ .v = 0, .hex = "00" },
  566. .{ .v = 127, .hex = "7f" },
  567. .{ .v = 128, .hex = "cc80" },
  568. .{ .v = 256, .hex = "cd0100" },
  569. .{ .v = 65536, .hex = "ce00010000" },
  570. .{ .v = 2147483648, .hex = "ce80000000" },
  571. .{ .v = 4294967296, .hex = "cb41f0000000000000" },
  572. .{ .v = -1, .hex = "ff" },
  573. .{ .v = -32, .hex = "e0" },
  574. .{ .v = -33, .hex = "d0df" },
  575. .{ .v = -129, .hex = "d1ff7f" },
  576. .{ .v = -32769, .hex = "d2ffff7fff" },
  577. .{ .v = -2147483648, .hex = "d280000000" },
  578. .{ .v = -2147483649, .hex = "cbc1e0000000200000" },
  579. .{ .v = 0.5, .hex = "cb3fe0000000000000" },
  580. };
  581. for (cases) |c| {
  582. const enc = try encode(alloc, Value{ .number = c.v });
  583. const expect_bytes = try alloc.alloc(u8, c.hex.len / 2);
  584. _ = try std.fmt.hexToBytes(expect_bytes, c.hex);
  585. try testing.expectEqualSlices(u8, expect_bytes, enc);
  586. }
  587. }

Branches

Latest commits

  • 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
  • dc40d859tracker#31 (mission 026): duplicate titles merged — the 68 type+tmdbId pairs held by 157 records were the old tracker's (all migrated); merge.hl repair job (own clock, before the TMDB jobs) keeps one keeper per title (follows/watches > old short id > oldest), moves follows, watches, seasons, cast, credits, timelines, tombstones the rest (mergedInto, never deleted), slugs + short ids 301 to the keeper; stray seasons merged into their listed twin (Reacher S3 watches) or linked when watched; search import re-checks before its put; deploy.sh waits up to 90 s for 200; real copy 68 -> 0 dup ids, az5b2 follows/watches equal; gates 342/0, 32/0, 52/0mre
  • 2667da05tracker#30 (mission 025): /my/ pages from slim cached title cards, episode rows and watch sets (after the jobs /my/series 1.8 s -> 0.06 s, /my/unwatched 4.1 -> 0.18 s); timeline page shows its name once; franchise widget under the poster/title; movies with TV leftovers (First Contact) go through the details repair; tools/count-tmdb-ids.hl; gates 327/0, 52/0, 32/0mre
  • 3909810dantcolony#40: mission references in README/STATUS/docs point to the moved missionsmre
  • e63b1d28antcolony#40: history (LOG.md), worker briefs (missions/) and reports moved here from antcolony, numbered per project; old numbers in antcolony docs/mission-map.mdmre
  • 1cda451dtracker: Hybriel master 190aa11d (#127 both shapes, GC correctness fc838894) — conductor adopts despite /my/series 2.4x after jobs (memory 8.0 → 1.7 GB boot); see reports/071mre
  • c1fa2f2etracker (mission 071): Hybriel master 190aa11d measured on the real copy vs the live binary 8590df63 — NOT adopted (after the first-start jobs /my/series 2.4x slower, /series 1.6x, RSS swings 7.4-12.2 GB; fresh it is flat at 1.7-2.2 GB and /my/unwatched faster), vendor stays 8efba065, candidate kept in .scratch/w071/vendor-190aa11d; tests/kinds.mjs: collection seed off (its TMDB request broke check 1 in 1 of 4 runs); tests/realdata-071.sh + realdata-071-bench.mjs + tools/realdata-071-table.py; README + STATUS (numbers, how to repeat); gates 325/0, 32/0, 50/0mre
  • 8081350atracker docs (mission 070): README (summary, Config HL_GC_BYTES — kept at Hybriel's default, the 256 MiB setting is taken out of docker-compose.yml again: the jobs grew to 12+ GB with it too, see STATUS), Test (three gates), Deploy (first start ~50 min: kinds then seed, restart once after collections done, memory numbers), Vendored Hybriel 8efba065 + #48 audit, Files; STATUS mission 070 entry (merges, migrated counts, lambda audit, gates, RSS old vs new, how to repeat, open points); docs/kinds.md + docs/franchises.md job order; tests/realdata-070-*.sh, tools/count-migrated.hl, tools/ref-params.py, tools/lambda-audit.pymre
  • 1ad19c8ctracker: re-vendor Hybriel master 8efba065 (#126 GC by bytes, #48 lambda parameters copy) (mission 070): bin/hybriel sha256 50361e95…, plugins core crypto data fetch fs http http1 mpackdb proc smtp time web; lambda audit: 13 lambdas change a passed record/list (11 through a local alias), no caller relies on it — unchanged; 319 read-only lambda parameters get & (no copy per call: /my/schedule 2.35 → 0.46 s, /my/unwatched 13.7 → 5.7 s on the real copy); /my/unwatched one merge sort instead of n² inserts; docker-compose HL_GC_BYTES=268435456; deploy.sh runs kinds.mjs + franchises.mjs too (default ports 8700–8710); tests/realdata-070.mjs; gates browser 325/0, kinds 32/0, franchises 50/0mre
  • 46b21389tracker (mission 070, conductor): the sync never destroys migrated data — the one-time summary step MOVES a copied summary to migratedSummary (marker summaries-moved.txt) instead of clearing it; a migrated record's first title/genres/homepage/tagline TMDB replaces → migratedTitle/migratedGenres/migratedHomepage/migratedTagline, a migrated season's/episode's title/summary → migratedTitle/migratedSummary (set once); tests/peek-shows.hl prints them; gate 325/0mre
  • 749019b0Merge t19 (tracker#19 franchises + timelines) into main (mission 070): conflicts README/STATUS/show.hl/project.hl/browser.mjs/faketmdb.mjs, both sides kept; franchise/timeline pages get #20's typed heading (Franchise | …, Timeline | …), their title links via titlePath (/movies|/series|/shows); the collection seed waits for repair, kinds and credits too; franchises.mjs URLs + 2 new checks; gates browser 323/0, kinds 32/0, franchises 50/0mre
  • daf49feaMerge t20 (tracker#20 typed headings + #21 series/shows split) into main (mission 070): conflicts README/STATUS/show.hl/project.hl/search.hl/components/search.hl/browser.mjs/faketmdb.mjs, both sides kept; clock order backfill → repair → kinds → credits; withDetailsFields stores tmdbType + kind; gates: browser.mjs URLs → /series|/movies, typed h1 selectors; kinds.mjs repair/credits off, fixture name = seed name; browser 323/0, kinds 32/0mre
  • 20e09d89Merge t18 (tracker#18 delta sync) into main (mission 070): conflicts README/STATUS/show.hl/project.hl/browser.mjs, both sides kept; pageShowOf summary = summaryOfmre
  • f83571c3tracker#18 (mission 067): daily sync by change lists — TMDB /tv|movie/changes (since the stored day, paged) + TVmaze /updates/shows → only our changed titles (followed: full step, unfollowed: light step — changed seasons, no TVmaze), full walk on first run / gap > 14 days / failed list; show record refreshed (title, tmdbSummary, tagline, status, genres …; renamed titles re-indexed); summary = the creator's own text (page: summary > tmdbSummary > tvmazeSummary), one-time clear of copied summaries (9,647 on the live copy); gate 261, tests/realdata-018*.mjs, README + STATUSmre
  • 1ed5457etracker#20 + #21 (mission 068): typed headings "<Type> | <name>" in type colours; TV titles split into Series (/series) and Shows (/shows) by TMDB type + Reality/Talk/News genres — kind stored by sync/import/adult backfill + new kind backfill (resumes), /movies/<slug>, /shows/<slug> of a series/movie → 301, /my/series + /my/shows, home 5 tiles + 3 rows, search/filmography labels; gates kinds 32 + browser 266, tests/realdata-068.mjs, tools/count-kinds.hl, docs/kinds.md, README + STATUSmre