adopt zat library for atproto primitives

- replace hand-rolled TID parsing with zat.internal.Tid
- replace manual AT-URI parsing with zat.internal.AtUri
- cleaner, more correct (zat validates TID first char high bit)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

build.zig

···
         .optimize = optimize,
     });
 
+    const zat = b.dependency("zat", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
     const exe = b.addExecutable(.{
         .name = "zig-bsky-feed",
         .root_module = b.createModule(.{
···
             .imports = &.{
                 .{ .name = "websocket", .module = websocket.module("websocket") },
                 .{ .name = "zqlite", .module = zqlite.module("zqlite") },
+                .{ .name = "zat", .module = zat.module("zat") },
             },
         }),
     });

build.zig.zon

···
             .url = "https://github.com/karlseguin/zqlite.zig/archive/refs/heads/master.tar.gz",
             .hash = "zqlite-0.0.0-RWLaY_y_mADh2LdbDrG_2HT2dBAcsAR8Jig_7-dOJd0B",
         },
+        .zat = .{
+            .url = "https://github.com/zzstoatzz/zat/archive/refs/heads/main.tar.gz",
+            .hash = "zat-0.0.1-alpha-5PuC7liTAAAHY5R9yFiTz2Q51azmq4gLHpJLrzlA6-ms",
+        },
     },
     .paths = .{
         "build.zig",

src/atproto.zig

···
 const net = std.net;
 const tls = std.crypto.tls;
 const Allocator = mem.Allocator;
+const zat = @import("zat");
 
 // =============================================================================
 // atproto utilities

src/db.zig

···
 const std = @import("std");
 const posix = std.posix;
 const zqlite = @import("zqlite");
+const zat = @import("zat");
 const config = @import("config.zig");
 const atproto = @import("atproto.zig");
 
···
     };
 }
 
-/// parse TID (base32-sortable) to get timestamp in milliseconds
-/// TID is 13 chars, first 53 bits are microseconds since epoch
+/// parse TID to get timestamp in milliseconds
 pub fn parseTidTimestamp(rkey: []const u8) i64 {
-    if (rkey.len != 13) return 0;
-
-    const charset = "234567abcdefghijklmnopqrstuvwxyz";
-    var value: u64 = 0;
-    for (rkey) |c| {
-        const idx = std.mem.indexOf(u8, charset, &[_]u8{c}) orelse return 0;
-        value = value * 32 + idx;
-    }
-
-    // top 53 bits are microseconds, convert to milliseconds
-    const micros = value >> 10;
-    return @intCast(micros / 1000);
+    const tid = zat.internal.Tid.parse(rkey) orelse return 0;
+    return @intCast(tid.timestamp() / 1000); // microseconds -> milliseconds
 }
 
 /// parse TID from AT URI to get post timestamp
 fn parseTimestampFromUri(uri: []const u8) ?i64 {
-    const last_slash = std.mem.lastIndexOf(u8, uri, "/") orelse return null;
-    const rkey = uri[last_slash + 1 ..];
+    const at_uri = zat.internal.AtUri.parse(uri) orelse return null;
+    const rkey = at_uri.rkey() orelse return null;
     const ts = parseTidTimestamp(rkey);
     return if (ts > 0) ts else null;
 }
···
 
 /// extract DID from post URI (at://did:plc:xxx/app.bsky.feed.post/yyy)
 fn extractDidFromUri(uri: []const u8) ?[]const u8 {
-    if (!std.mem.startsWith(u8, uri, "at://")) return null;
-    const rest = uri[5..];
-    const end = std.mem.indexOf(u8, rest, "/") orelse return null;
-    return rest[0..end];
+    const at_uri = zat.internal.AtUri.parse(uri) orelse return null;
+    return at_uri.authority();
 }
 
 /// get follows as newline-separated string (caller owns returned memory)