zat.dev
zzstoatzz.io
+27
-29
README.md
+27
-29
README.md
···
1
1
# zat
2
2
3
-
zig atproto primitives. parsing utilities for TID, AT-URI, and DID.
3
+
zig primitives for AT Protocol string formats.
4
4
5
-
## status
5
+
## install
6
6
7
-
alpha (`0.0.1-alpha`). APIs are in `internal` module while we iterate.
7
+
```bash
8
+
zig fetch --save https://tangled.sh/@zzstoatzz.io/zat/archive/main.tar.gz
9
+
```
8
10
9
-
## install
11
+
then in `build.zig`:
10
12
11
13
```zig
12
-
// build.zig.zon
13
-
.dependencies = .{
14
-
.zat = .{
15
-
.url = "https://tangled.sh/@zzstoatzz.io/zat/archive/main.tar.gz",
16
-
.hash = "...", // zig build will tell you
17
-
},
18
-
},
14
+
const zat = b.dependency("zat", .{}).module("zat");
15
+
exe.root_module.addImport("zat", zat);
19
16
```
20
17
21
-
## usage
18
+
## what's here
22
19
23
-
```zig
24
-
const zat = @import("zat");
20
+
parsing and validation for atproto string identifiers:
25
21
26
-
// TID - timestamp identifiers
27
-
const tid = zat.internal.Tid.parse("3jui7kze2c22s") orelse return error.InvalidTid;
28
-
const ts = tid.timestamp(); // microseconds since epoch
29
-
const clock = tid.clockId(); // 10-bit clock id
22
+
- **Tid** - timestamp identifiers (base32-sortable)
23
+
- **Did** - decentralized identifiers
24
+
- **Handle** - domain-based handles
25
+
- **Nsid** - namespaced identifiers (lexicon types)
26
+
- **Rkey** - record keys
27
+
- **AtUri** - `at://` URIs
30
28
31
-
// AT-URI - at://did/collection/rkey
32
-
const uri = zat.internal.AtUri.parse("at://did:plc:xyz/app.bsky.feed.post/abc123") orelse return error.InvalidUri;
33
-
const did = uri.did(); // "did:plc:xyz"
34
-
const collection = uri.collection(); // "app.bsky.feed.post"
35
-
const rkey = uri.rkey(); // "abc123"
29
+
all types follow a common pattern: `parse()` returns an optional, accessors extract components.
36
30
37
-
// DID - did:plc and did:web
38
-
const d = zat.internal.Did.parse("did:plc:z72i7hdynmk6r22z27h6tvur") orelse return error.InvalidDid;
39
-
const id = d.identifier(); // "z72i7hdynmk6r22z27h6tvur"
40
-
const is_plc = d.isPlc(); // true
31
+
```zig
32
+
const zat = @import("zat");
33
+
34
+
if (zat.internal.AtUri.parse(uri_string)) |uri| {
35
+
const authority = uri.authority();
36
+
const collection = uri.collection();
37
+
const rkey = uri.rkey();
38
+
}
41
39
```
42
40
43
-
## why internal?
41
+
## specs
44
42
45
-
new APIs start in `internal` and get promoted to root when stable. if you need bleeding edge, use `zat.internal.*` and expect breakage.
43
+
validation follows [atproto.com/specs](https://atproto.com/specs).
+11
-2
src/internal.zig
+11
-2
src/internal.zig
···
5
5
//!
6
6
//! when an API stabilizes, it gets promoted to root.zig.
7
7
8
+
// identifiers
8
9
pub const Tid = @import("internal/tid.zig").Tid;
10
+
pub const Did = @import("internal/did.zig").Did;
11
+
pub const Handle = @import("internal/handle.zig").Handle;
12
+
pub const Nsid = @import("internal/nsid.zig").Nsid;
13
+
pub const Rkey = @import("internal/rkey.zig").Rkey;
14
+
15
+
// uris
9
16
pub const AtUri = @import("internal/at_uri.zig").AtUri;
10
-
pub const Did = @import("internal/did.zig").Did;
11
17
12
18
test {
13
19
_ = @import("internal/tid.zig");
14
-
_ = @import("internal/at_uri.zig");
15
20
_ = @import("internal/did.zig");
21
+
_ = @import("internal/handle.zig");
22
+
_ = @import("internal/nsid.zig");
23
+
_ = @import("internal/rkey.zig");
24
+
_ = @import("internal/at_uri.zig");
16
25
}
+172
-68
src/internal/at_uri.zig
+172
-68
src/internal/at_uri.zig
···
1
1
//! AT-URI Parser
2
2
//!
3
-
//! at-uris identify records in the atproto network.
4
-
//! format: at://<did>/<collection>/<rkey>
3
+
//! at-uris identify repositories and records in the atproto network.
4
+
//! format: at://<authority>[/<collection>[/<rkey>]]
5
+
//!
6
+
//! validation rules:
7
+
//! - max 8KB length
8
+
//! - no trailing slashes
9
+
//! - authority is either a DID or handle
10
+
//! - collection (if present) must be a valid NSID
11
+
//! - rkey (if present) must be a valid record key
5
12
//!
6
-
//! examples:
7
-
//! - at://did:plc:xyz/app.bsky.feed.post/abc123
8
-
//! - at://did:web:example.com/app.bsky.actor.profile/self
13
+
//! see: https://atproto.com/specs/at-uri-scheme
9
14
10
15
const std = @import("std");
11
16
···
13
18
/// the full uri string (borrowed, not owned)
14
19
raw: []const u8,
15
20
16
-
/// offset where did ends (after "at://")
17
-
did_end: usize,
21
+
/// offset where authority ends (after "at://")
22
+
authority_end: usize,
18
23
19
-
/// offset where collection ends
24
+
/// offset where collection ends (0 if no collection)
20
25
collection_end: usize,
21
26
27
+
pub const max_length = 8 * 1024;
22
28
const prefix = "at://";
23
29
24
30
/// parse an at-uri. returns null if invalid.
25
31
pub fn parse(s: []const u8) ?AtUri {
32
+
// length check
33
+
if (s.len < prefix.len or s.len > max_length) return null;
34
+
35
+
// must start with "at://"
26
36
if (!std.mem.startsWith(u8, s, prefix)) return null;
27
37
38
+
// no trailing slash
39
+
if (s[s.len - 1] == '/') return null;
40
+
28
41
const after_prefix = s[prefix.len..];
42
+
if (after_prefix.len == 0) return null; // empty authority
29
43
30
-
// find first slash (end of did)
31
-
const did_end_rel = std.mem.indexOfScalar(u8, after_prefix, '/') orelse return null;
32
-
if (did_end_rel == 0) return null; // empty did
44
+
// find first slash (end of authority)
45
+
const authority_end_rel = std.mem.indexOfScalar(u8, after_prefix, '/');
33
46
34
-
const after_did = after_prefix[did_end_rel + 1 ..];
47
+
if (authority_end_rel) |ae| {
48
+
if (ae == 0) return null; // empty authority
35
49
36
-
// find second slash (end of collection)
37
-
const collection_end_rel = std.mem.indexOfScalar(u8, after_did, '/') orelse return null;
38
-
if (collection_end_rel == 0) return null; // empty collection
50
+
const after_authority = after_prefix[ae + 1 ..];
51
+
if (after_authority.len == 0) return null; // trailing slash after authority
39
52
40
-
// check rkey isn't empty
41
-
const rkey_start = prefix.len + did_end_rel + 1 + collection_end_rel + 1;
42
-
if (rkey_start >= s.len) return null;
53
+
// find second slash (end of collection)
54
+
const collection_end_rel = std.mem.indexOfScalar(u8, after_authority, '/');
55
+
56
+
if (collection_end_rel) |ce| {
57
+
if (ce == 0) return null; // empty collection
58
+
const after_collection = after_authority[ce + 1 ..];
59
+
if (after_collection.len == 0) return null; // trailing slash after collection
43
60
44
-
return .{
45
-
.raw = s,
46
-
.did_end = prefix.len + did_end_rel,
47
-
.collection_end = prefix.len + did_end_rel + 1 + collection_end_rel,
48
-
};
61
+
// full uri: authority + collection + rkey
62
+
return .{
63
+
.raw = s,
64
+
.authority_end = prefix.len + ae,
65
+
.collection_end = prefix.len + ae + 1 + ce,
66
+
};
67
+
} else {
68
+
// uri with authority + collection only
69
+
return .{
70
+
.raw = s,
71
+
.authority_end = prefix.len + ae,
72
+
.collection_end = s.len,
73
+
};
74
+
}
75
+
} else {
76
+
// authority only
77
+
return .{
78
+
.raw = s,
79
+
.authority_end = s.len,
80
+
.collection_end = 0,
81
+
};
82
+
}
49
83
}
50
84
51
-
/// the did portion (e.g., "did:plc:xyz")
52
-
pub fn did(self: AtUri) []const u8 {
53
-
return self.raw[prefix.len..self.did_end];
85
+
/// the authority portion (DID or handle)
86
+
pub fn authority(self: AtUri) []const u8 {
87
+
return self.raw[prefix.len..self.authority_end];
54
88
}
55
89
56
-
/// the collection portion (e.g., "app.bsky.feed.post")
57
-
pub fn collection(self: AtUri) []const u8 {
58
-
return self.raw[self.did_end + 1 .. self.collection_end];
90
+
/// the collection portion, or null if not present
91
+
pub fn collection(self: AtUri) ?[]const u8 {
92
+
if (self.collection_end == 0) return null;
93
+
return self.raw[self.authority_end + 1 .. self.collection_end];
59
94
}
60
95
61
-
/// the rkey portion (e.g., "abc123")
62
-
pub fn rkey(self: AtUri) []const u8 {
63
-
return self.raw[self.collection_end + 1 ..];
96
+
/// the rkey portion, or null if not present
97
+
pub fn rkey(self: AtUri) ?[]const u8 {
98
+
if (self.collection_end == 0) return null;
99
+
if (self.collection_end >= self.raw.len) return null;
100
+
const r = self.raw[self.collection_end + 1 ..];
101
+
if (r.len == 0) return null;
102
+
return r;
103
+
}
104
+
105
+
/// check if this uri has a collection component
106
+
pub fn hasCollection(self: AtUri) bool {
107
+
return self.collection_end != 0;
108
+
}
109
+
110
+
/// check if this uri has an rkey component
111
+
pub fn hasRkey(self: AtUri) bool {
112
+
return self.rkey() != null;
64
113
}
65
114
66
115
/// format a new at-uri into the provided buffer.
67
116
/// returns the slice of the buffer used, or null if buffer too small.
68
117
pub fn format(
69
118
buf: []u8,
70
-
did_str: []const u8,
71
-
collection_str: []const u8,
72
-
rkey_str: []const u8,
119
+
authority_str: []const u8,
120
+
collection_str: ?[]const u8,
121
+
rkey_str: ?[]const u8,
73
122
) ?[]const u8 {
74
-
const total_len = prefix.len + did_str.len + 1 + collection_str.len + 1 + rkey_str.len;
123
+
var total_len = prefix.len + authority_str.len;
124
+
if (collection_str) |c| {
125
+
total_len += 1 + c.len;
126
+
if (rkey_str) |r| {
127
+
total_len += 1 + r.len;
128
+
}
129
+
}
130
+
75
131
if (buf.len < total_len) return null;
76
132
77
133
var pos: usize = 0;
···
79
135
@memcpy(buf[pos..][0..prefix.len], prefix);
80
136
pos += prefix.len;
81
137
82
-
@memcpy(buf[pos..][0..did_str.len], did_str);
83
-
pos += did_str.len;
84
-
85
-
buf[pos] = '/';
86
-
pos += 1;
87
-
88
-
@memcpy(buf[pos..][0..collection_str.len], collection_str);
89
-
pos += collection_str.len;
138
+
@memcpy(buf[pos..][0..authority_str.len], authority_str);
139
+
pos += authority_str.len;
90
140
91
-
buf[pos] = '/';
92
-
pos += 1;
141
+
if (collection_str) |c| {
142
+
buf[pos] = '/';
143
+
pos += 1;
144
+
@memcpy(buf[pos..][0..c.len], c);
145
+
pos += c.len;
93
146
94
-
@memcpy(buf[pos..][0..rkey_str.len], rkey_str);
95
-
pos += rkey_str.len;
147
+
if (rkey_str) |r| {
148
+
buf[pos] = '/';
149
+
pos += 1;
150
+
@memcpy(buf[pos..][0..r.len], r);
151
+
pos += r.len;
152
+
}
153
+
}
96
154
97
155
return buf[0..pos];
98
156
}
99
157
};
100
158
101
-
test "parse valid at-uri" {
102
-
const uri = AtUri.parse("at://did:plc:xyz/app.bsky.feed.post/abc123") orelse return error.InvalidUri;
103
-
try std.testing.expectEqualStrings("did:plc:xyz", uri.did());
104
-
try std.testing.expectEqualStrings("app.bsky.feed.post", uri.collection());
105
-
try std.testing.expectEqualStrings("abc123", uri.rkey());
159
+
// === tests from atproto.com/specs/at-uri-scheme ===
160
+
161
+
test "valid: full uri with did:plc" {
162
+
const uri = AtUri.parse("at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3jxtb5w2hkt2m") orelse return error.InvalidUri;
163
+
try std.testing.expectEqualStrings("did:plc:z72i7hdynmk6r22z27h6tvur", uri.authority());
164
+
try std.testing.expectEqualStrings("app.bsky.feed.post", uri.collection().?);
165
+
try std.testing.expectEqualStrings("3jxtb5w2hkt2m", uri.rkey().?);
106
166
}
107
167
108
-
test "parse did:web uri" {
168
+
test "valid: full uri with did:web" {
109
169
const uri = AtUri.parse("at://did:web:example.com/app.bsky.actor.profile/self") orelse return error.InvalidUri;
110
-
try std.testing.expectEqualStrings("did:web:example.com", uri.did());
111
-
try std.testing.expectEqualStrings("app.bsky.actor.profile", uri.collection());
112
-
try std.testing.expectEqualStrings("self", uri.rkey());
170
+
try std.testing.expectEqualStrings("did:web:example.com", uri.authority());
171
+
try std.testing.expectEqualStrings("app.bsky.actor.profile", uri.collection().?);
172
+
try std.testing.expectEqualStrings("self", uri.rkey().?);
113
173
}
114
174
115
-
test "reject invalid uris" {
116
-
// missing prefix
175
+
test "valid: full uri with handle" {
176
+
const uri = AtUri.parse("at://alice.bsky.social/app.bsky.feed.post/abc123") orelse return error.InvalidUri;
177
+
try std.testing.expectEqualStrings("alice.bsky.social", uri.authority());
178
+
try std.testing.expectEqualStrings("app.bsky.feed.post", uri.collection().?);
179
+
try std.testing.expectEqualStrings("abc123", uri.rkey().?);
180
+
}
181
+
182
+
test "valid: authority only" {
183
+
const uri = AtUri.parse("at://did:plc:z72i7hdynmk6r22z27h6tvur") orelse return error.InvalidUri;
184
+
try std.testing.expectEqualStrings("did:plc:z72i7hdynmk6r22z27h6tvur", uri.authority());
185
+
try std.testing.expect(uri.collection() == null);
186
+
try std.testing.expect(uri.rkey() == null);
187
+
try std.testing.expect(!uri.hasCollection());
188
+
try std.testing.expect(!uri.hasRkey());
189
+
}
190
+
191
+
test "valid: authority and collection only" {
192
+
const uri = AtUri.parse("at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post") orelse return error.InvalidUri;
193
+
try std.testing.expectEqualStrings("did:plc:z72i7hdynmk6r22z27h6tvur", uri.authority());
194
+
try std.testing.expectEqualStrings("app.bsky.feed.post", uri.collection().?);
195
+
try std.testing.expect(uri.rkey() == null);
196
+
try std.testing.expect(uri.hasCollection());
197
+
try std.testing.expect(!uri.hasRkey());
198
+
}
199
+
200
+
test "invalid: missing prefix" {
117
201
try std.testing.expect(AtUri.parse("did:plc:xyz/app.bsky.feed.post/abc") == null);
202
+
try std.testing.expect(AtUri.parse("http://did:plc:xyz/collection/rkey") == null);
203
+
}
118
204
119
-
// wrong prefix
120
-
try std.testing.expect(AtUri.parse("http://did:plc:xyz/app.bsky.feed.post/abc") == null);
205
+
test "invalid: empty authority" {
206
+
try std.testing.expect(AtUri.parse("at://") == null);
207
+
try std.testing.expect(AtUri.parse("at:///collection/rkey") == null);
208
+
}
121
209
122
-
// missing collection
123
-
try std.testing.expect(AtUri.parse("at://did:plc:xyz") == null);
210
+
test "invalid: trailing slash" {
211
+
try std.testing.expect(AtUri.parse("at://did:plc:xyz/") == null);
212
+
try std.testing.expect(AtUri.parse("at://did:plc:xyz/collection/") == null);
213
+
try std.testing.expect(AtUri.parse("at://did:plc:xyz/collection/rkey/") == null);
214
+
}
124
215
125
-
// missing rkey
126
-
try std.testing.expect(AtUri.parse("at://did:plc:xyz/app.bsky.feed.post") == null);
216
+
test "invalid: empty collection" {
217
+
try std.testing.expect(AtUri.parse("at://did:plc:xyz//rkey") == null);
218
+
}
127
219
128
-
// empty did
129
-
try std.testing.expect(AtUri.parse("at:///app.bsky.feed.post/abc") == null);
220
+
test "invalid: empty rkey" {
221
+
try std.testing.expect(AtUri.parse("at://did:plc:xyz/collection/") == null);
130
222
}
131
223
132
-
test "format at-uri" {
224
+
test "format: full uri" {
133
225
var buf: [256]u8 = undefined;
134
226
const result = AtUri.format(&buf, "did:plc:xyz", "app.bsky.feed.post", "abc123") orelse return error.BufferTooSmall;
135
227
try std.testing.expectEqualStrings("at://did:plc:xyz/app.bsky.feed.post/abc123", result);
136
228
}
229
+
230
+
test "format: authority only" {
231
+
var buf: [256]u8 = undefined;
232
+
const result = AtUri.format(&buf, "did:plc:xyz", null, null) orelse return error.BufferTooSmall;
233
+
try std.testing.expectEqualStrings("at://did:plc:xyz", result);
234
+
}
235
+
236
+
test "format: authority and collection" {
237
+
var buf: [256]u8 = undefined;
238
+
const result = AtUri.format(&buf, "did:plc:xyz", "app.bsky.feed.post", null) orelse return error.BufferTooSmall;
239
+
try std.testing.expectEqualStrings("at://did:plc:xyz/app.bsky.feed.post", result);
240
+
}
+128
-48
src/internal/did.zig
+128
-48
src/internal/did.zig
···
1
1
//! DID - Decentralized Identifier
2
2
//!
3
-
//! dids are globally unique identifiers in the atproto network.
4
-
//! supports did:plc and did:web methods.
3
+
//! dids are persistent, long-term account identifiers based on W3C standard.
4
+
//! format: did:<method>:<identifier>
5
5
//!
6
-
//! examples:
7
-
//! - did:plc:z72i7hdynmk6r22z27h6tvur
8
-
//! - did:web:example.com
6
+
//! validation rules:
7
+
//! - max 2048 characters
8
+
//! - method must be lowercase letters only
9
+
//! - identifier allows: a-zA-Z0-9._:%-
10
+
//! - cannot end with : or %
11
+
//! - cannot contain: / ? # [ ] @
12
+
//!
13
+
//! see: https://atproto.com/specs/did
9
14
10
15
const std = @import("std");
11
16
···
13
18
/// the full did string (borrowed, not owned)
14
19
raw: []const u8,
15
20
16
-
/// the method (plc or web)
17
-
method: Method,
21
+
/// offset where method starts (after "did:")
22
+
method_start: usize,
18
23
19
-
/// offset where method-specific identifier starts
24
+
/// offset where method ends / identifier starts
20
25
id_start: usize,
21
26
27
+
pub const max_length = 2048;
28
+
22
29
pub const Method = enum {
23
30
plc,
24
31
web,
32
+
other,
25
33
};
26
34
27
35
/// parse a did string. returns null if invalid.
28
36
pub fn parse(s: []const u8) ?Did {
37
+
// length check
38
+
if (s.len == 0 or s.len > max_length) return null;
39
+
40
+
// must start with "did:"
29
41
if (!std.mem.startsWith(u8, s, "did:")) return null;
30
42
43
+
// find method end (next colon)
31
44
const after_did = s[4..];
45
+
const method_end = std.mem.indexOfScalar(u8, after_did, ':') orelse return null;
46
+
if (method_end == 0) return null; // empty method
32
47
33
-
if (std.mem.startsWith(u8, after_did, "plc:")) {
34
-
const id = after_did[4..];
35
-
if (id.len == 0) return null;
36
-
// plc identifiers should be 24 base32 chars
37
-
if (!isValidPlcId(id)) return null;
38
-
return .{
39
-
.raw = s,
40
-
.method = .plc,
41
-
.id_start = 8,
42
-
};
48
+
// method must be lowercase letters only
49
+
const method_str = after_did[0..method_end];
50
+
for (method_str) |c| {
51
+
if (c < 'a' or c > 'z') return null;
43
52
}
44
53
45
-
if (std.mem.startsWith(u8, after_did, "web:")) {
46
-
const domain = after_did[4..];
47
-
if (domain.len == 0) return null;
48
-
return .{
49
-
.raw = s,
50
-
.method = .web,
51
-
.id_start = 8,
52
-
};
53
-
}
54
+
// identifier must not be empty
55
+
const id_offset = 4 + method_end + 1;
56
+
if (id_offset >= s.len) return null;
54
57
55
-
return null;
58
+
const id_part = s[id_offset..];
59
+
60
+
// cannot end with : or %
61
+
const last = id_part[id_part.len - 1];
62
+
if (last == ':' or last == '%') return null;
63
+
64
+
// validate identifier characters
65
+
if (!isValidIdentifier(id_part)) return null;
66
+
67
+
return .{
68
+
.raw = s,
69
+
.method_start = 4,
70
+
.id_start = id_offset,
71
+
};
72
+
}
73
+
74
+
/// the method portion (e.g., "plc", "web")
75
+
pub fn methodStr(self: Did) []const u8 {
76
+
return self.raw[self.method_start .. self.id_start - 1];
77
+
}
78
+
79
+
/// the method as an enum (plc, web, or other)
80
+
pub fn method(self: Did) Method {
81
+
const m = self.methodStr();
82
+
if (std.mem.eql(u8, m, "plc")) return .plc;
83
+
if (std.mem.eql(u8, m, "web")) return .web;
84
+
return .other;
56
85
}
57
86
58
87
/// the method-specific identifier
59
-
/// for plc: the 24-char base32 id
60
-
/// for web: the domain
61
88
pub fn identifier(self: Did) []const u8 {
62
89
return self.raw[self.id_start..];
63
90
}
64
91
65
92
/// check if this is a plc did
66
93
pub fn isPlc(self: Did) bool {
67
-
return self.method == .plc;
94
+
return self.method() == .plc;
68
95
}
69
96
70
97
/// check if this is a web did
71
98
pub fn isWeb(self: Did) bool {
72
-
return self.method == .web;
99
+
return self.method() == .web;
73
100
}
74
101
75
102
/// get the full did string
···
77
104
return self.raw;
78
105
}
79
106
80
-
fn isValidPlcId(id: []const u8) bool {
81
-
// plc ids are base32 encoded (a-z, 2-7)
107
+
fn isValidIdentifier(id: []const u8) bool {
82
108
for (id) |c| {
83
-
const valid = (c >= 'a' and c <= 'z') or (c >= '2' and c <= '7');
109
+
const valid = switch (c) {
110
+
'a'...'z', 'A'...'Z', '0'...'9' => true,
111
+
'.', '_', ':', '-', '%' => true,
112
+
// explicitly reject invalid chars
113
+
'/', '?', '#', '[', ']', '@' => false,
114
+
else => false,
115
+
};
84
116
if (!valid) return false;
85
117
}
86
118
return true;
87
119
}
88
120
};
89
121
90
-
test "parse did:plc" {
122
+
// === tests from atproto.com/specs/did ===
123
+
124
+
test "valid: did:plc example" {
91
125
const did = Did.parse("did:plc:z72i7hdynmk6r22z27h6tvur") orelse return error.InvalidDid;
92
126
try std.testing.expect(did.isPlc());
93
-
try std.testing.expect(!did.isWeb());
127
+
try std.testing.expectEqualStrings("plc", did.methodStr());
94
128
try std.testing.expectEqualStrings("z72i7hdynmk6r22z27h6tvur", did.identifier());
95
129
}
96
130
97
-
test "parse did:web" {
98
-
const did = Did.parse("did:web:example.com") orelse return error.InvalidDid;
131
+
test "valid: did:web example" {
132
+
const did = Did.parse("did:web:blueskyweb.xyz") orelse return error.InvalidDid;
99
133
try std.testing.expect(did.isWeb());
100
-
try std.testing.expect(!did.isPlc());
101
-
try std.testing.expectEqualStrings("example.com", did.identifier());
134
+
try std.testing.expectEqualStrings("web", did.methodStr());
135
+
try std.testing.expectEqualStrings("blueskyweb.xyz", did.identifier());
102
136
}
103
137
104
-
test "reject invalid dids" {
105
-
// missing prefix
138
+
test "valid: did:web with port" {
139
+
const did = Did.parse("did:web:localhost%3A8080") orelse return error.InvalidDid;
140
+
try std.testing.expect(did.isWeb());
141
+
try std.testing.expectEqualStrings("localhost%3A8080", did.identifier());
142
+
}
143
+
144
+
test "valid: other method" {
145
+
const did = Did.parse("did:example:123456") orelse return error.InvalidDid;
146
+
try std.testing.expect(did.method() == .other);
147
+
try std.testing.expectEqualStrings("example", did.methodStr());
148
+
}
149
+
150
+
test "valid: identifier with allowed special chars" {
151
+
try std.testing.expect(Did.parse("did:plc:abc.def") != null);
152
+
try std.testing.expect(Did.parse("did:plc:abc_def") != null);
153
+
try std.testing.expect(Did.parse("did:plc:abc:def") != null);
154
+
try std.testing.expect(Did.parse("did:plc:abc-def") != null);
155
+
try std.testing.expect(Did.parse("did:plc:abc%20def") != null);
156
+
}
157
+
158
+
test "invalid: missing prefix" {
106
159
try std.testing.expect(Did.parse("plc:xyz") == null);
160
+
try std.testing.expect(Did.parse("xyz") == null);
161
+
}
107
162
108
-
// unknown method
109
-
try std.testing.expect(Did.parse("did:unknown:xyz") == null);
163
+
test "invalid: uppercase method" {
164
+
try std.testing.expect(Did.parse("did:PLC:xyz") == null);
165
+
try std.testing.expect(Did.parse("did:METHOD:val") == null);
166
+
}
110
167
111
-
// empty identifier
168
+
test "invalid: empty method" {
169
+
try std.testing.expect(Did.parse("did::xyz") == null);
170
+
}
171
+
172
+
test "invalid: empty identifier" {
112
173
try std.testing.expect(Did.parse("did:plc:") == null);
113
174
try std.testing.expect(Did.parse("did:web:") == null);
175
+
}
114
176
115
-
// invalid plc chars
116
-
try std.testing.expect(Did.parse("did:plc:INVALID") == null);
177
+
test "invalid: ends with colon or percent" {
178
+
try std.testing.expect(Did.parse("did:plc:abc:") == null);
179
+
try std.testing.expect(Did.parse("did:plc:abc%") == null);
180
+
}
181
+
182
+
test "invalid: contains forbidden chars" {
183
+
try std.testing.expect(Did.parse("did:plc:abc/def") == null);
184
+
try std.testing.expect(Did.parse("did:plc:abc?def") == null);
185
+
try std.testing.expect(Did.parse("did:plc:abc#def") == null);
186
+
try std.testing.expect(Did.parse("did:plc:abc[def") == null);
187
+
try std.testing.expect(Did.parse("did:plc:abc]def") == null);
188
+
try std.testing.expect(Did.parse("did:plc:abc@def") == null);
189
+
}
190
+
191
+
test "invalid: too long" {
192
+
// create a did longer than 2048 chars
193
+
var buf: [2100]u8 = undefined;
194
+
@memset(&buf, 'a');
195
+
@memcpy(buf[0..8], "did:plc:");
196
+
try std.testing.expect(Did.parse(&buf) == null);
117
197
}
+184
src/internal/handle.zig
+184
src/internal/handle.zig
···
1
+
//! Handle - AT Protocol Handle Identifier
2
+
//!
3
+
//! handles are domain-name based identifiers for accounts.
4
+
//! format: <segment>.<segment>...<tld>
5
+
//!
6
+
//! validation rules:
7
+
//! - max 253 characters
8
+
//! - ASCII only (a-z, 0-9, hyphen)
9
+
//! - 2+ segments separated by dots
10
+
//! - each segment: 1-63 chars, no leading/trailing hyphens
11
+
//! - final segment (TLD) cannot start with a digit
12
+
//! - case-insensitive, normalize to lowercase
13
+
//!
14
+
//! see: https://atproto.com/specs/handle
15
+
16
+
const std = @import("std");
17
+
18
+
pub const Handle = struct {
19
+
/// the handle string (borrowed, not owned)
20
+
raw: []const u8,
21
+
22
+
pub const max_length = 253;
23
+
24
+
/// parse a handle string. returns null if invalid.
25
+
pub fn parse(s: []const u8) ?Handle {
26
+
if (!isValid(s)) return null;
27
+
return .{ .raw = s };
28
+
}
29
+
30
+
/// validate a handle string without allocating
31
+
pub fn isValid(s: []const u8) bool {
32
+
// length check
33
+
if (s.len == 0 or s.len > max_length) return false;
34
+
35
+
// must be ascii
36
+
for (s) |c| {
37
+
if (c > 127) return false;
38
+
}
39
+
40
+
var segment_count: usize = 0;
41
+
var segment_start: usize = 0;
42
+
var last_segment_start: usize = 0;
43
+
44
+
for (s, 0..) |c, i| {
45
+
if (c == '.') {
46
+
const segment = s[segment_start..i];
47
+
if (!isValidSegment(segment)) return false;
48
+
segment_count += 1;
49
+
last_segment_start = i + 1;
50
+
segment_start = i + 1;
51
+
}
52
+
}
53
+
54
+
// validate final segment (TLD)
55
+
const tld = s[last_segment_start..];
56
+
if (!isValidSegment(tld)) return false;
57
+
if (!isValidTld(tld)) return false;
58
+
segment_count += 1;
59
+
60
+
// must have at least 2 segments
61
+
return segment_count >= 2;
62
+
}
63
+
64
+
/// get the handle string
65
+
pub fn str(self: Handle) []const u8 {
66
+
return self.raw;
67
+
}
68
+
69
+
fn isValidSegment(seg: []const u8) bool {
70
+
// 1-63 characters
71
+
if (seg.len == 0 or seg.len > 63) return false;
72
+
73
+
// cannot start or end with hyphen
74
+
if (seg[0] == '-' or seg[seg.len - 1] == '-') return false;
75
+
76
+
// only alphanumeric and hyphen
77
+
for (seg) |c| {
78
+
const valid = (c >= 'a' and c <= 'z') or
79
+
(c >= 'A' and c <= 'Z') or
80
+
(c >= '0' and c <= '9') or
81
+
c == '-';
82
+
if (!valid) return false;
83
+
}
84
+
85
+
return true;
86
+
}
87
+
88
+
fn isValidTld(tld: []const u8) bool {
89
+
if (tld.len == 0) return false;
90
+
// TLD cannot start with a digit
91
+
const first = tld[0];
92
+
return (first >= 'a' and first <= 'z') or (first >= 'A' and first <= 'Z');
93
+
}
94
+
};
95
+
96
+
// === tests from atproto.com/specs/handle ===
97
+
98
+
test "valid: simple handle" {
99
+
try std.testing.expect(Handle.parse("jay.bsky.social") != null);
100
+
try std.testing.expect(Handle.parse("alice.example.com") != null);
101
+
}
102
+
103
+
test "valid: two segments" {
104
+
try std.testing.expect(Handle.parse("example.com") != null);
105
+
try std.testing.expect(Handle.parse("test.org") != null);
106
+
}
107
+
108
+
test "valid: many segments" {
109
+
try std.testing.expect(Handle.parse("a.b.c.d.e.f") != null);
110
+
}
111
+
112
+
test "valid: with hyphens" {
113
+
try std.testing.expect(Handle.parse("my-name.example.com") != null);
114
+
try std.testing.expect(Handle.parse("test.my-domain.org") != null);
115
+
}
116
+
117
+
test "valid: with numbers" {
118
+
try std.testing.expect(Handle.parse("user123.example.com") != null);
119
+
try std.testing.expect(Handle.parse("123user.example.com") != null);
120
+
}
121
+
122
+
test "valid: uppercase (allowed, normalize to lowercase)" {
123
+
try std.testing.expect(Handle.parse("LOUD.example.com") != null);
124
+
try std.testing.expect(Handle.parse("Jay.Bsky.Social") != null);
125
+
}
126
+
127
+
test "invalid: single segment" {
128
+
try std.testing.expect(Handle.parse("example") == null);
129
+
try std.testing.expect(Handle.parse("localhost") == null);
130
+
}
131
+
132
+
test "invalid: TLD starts with digit" {
133
+
try std.testing.expect(Handle.parse("john.0") == null);
134
+
try std.testing.expect(Handle.parse("test.123") == null);
135
+
}
136
+
137
+
test "invalid: segment starts with hyphen" {
138
+
try std.testing.expect(Handle.parse("-test.example.com") == null);
139
+
try std.testing.expect(Handle.parse("test.-example.com") == null);
140
+
}
141
+
142
+
test "invalid: segment ends with hyphen" {
143
+
try std.testing.expect(Handle.parse("test-.example.com") == null);
144
+
try std.testing.expect(Handle.parse("test.example-.com") == null);
145
+
}
146
+
147
+
test "invalid: empty segment" {
148
+
try std.testing.expect(Handle.parse(".example.com") == null);
149
+
try std.testing.expect(Handle.parse("test..com") == null);
150
+
try std.testing.expect(Handle.parse("test.example.") == null);
151
+
}
152
+
153
+
test "invalid: trailing dot" {
154
+
try std.testing.expect(Handle.parse("example.com.") == null);
155
+
}
156
+
157
+
test "invalid: invalid characters" {
158
+
try std.testing.expect(Handle.parse("test_name.example.com") == null);
159
+
try std.testing.expect(Handle.parse("test@name.example.com") == null);
160
+
try std.testing.expect(Handle.parse("test name.example.com") == null);
161
+
}
162
+
163
+
test "invalid: non-ascii" {
164
+
try std.testing.expect(Handle.parse("tëst.example.com") == null);
165
+
}
166
+
167
+
test "invalid: too long" {
168
+
// create a handle longer than 253 chars
169
+
var buf: [300]u8 = undefined;
170
+
@memset(&buf, 'a');
171
+
buf[100] = '.';
172
+
buf[200] = '.';
173
+
@memcpy(buf[201..204], "com");
174
+
try std.testing.expect(Handle.parse(buf[0..254]) == null);
175
+
}
176
+
177
+
test "invalid: segment too long" {
178
+
// segment > 63 chars
179
+
var buf: [100]u8 = undefined;
180
+
@memset(&buf, 'a');
181
+
buf[64] = '.';
182
+
@memcpy(buf[65..68], "com");
183
+
try std.testing.expect(Handle.parse(buf[0..68]) == null);
184
+
}
+196
src/internal/nsid.zig
+196
src/internal/nsid.zig
···
1
+
//! NSID - Namespaced Identifier
2
+
//!
3
+
//! nsids identify lexicon schemas and record types.
4
+
//! format: <reversed-domain>.<name>
5
+
//!
6
+
//! validation rules:
7
+
//! - max 317 characters
8
+
//! - 3+ segments separated by dots
9
+
//! - domain authority: reversed domain (lowercase + digits + hyphens)
10
+
//! - name segment: letters and digits only, cannot start with digit
11
+
//! - each segment: 1-63 characters
12
+
//!
13
+
//! examples:
14
+
//! - app.bsky.feed.post
15
+
//! - com.atproto.repo.createRecord
16
+
//!
17
+
//! see: https://atproto.com/specs/nsid
18
+
19
+
const std = @import("std");
20
+
21
+
pub const Nsid = struct {
22
+
/// the nsid string (borrowed, not owned)
23
+
raw: []const u8,
24
+
25
+
/// offset where the name segment starts
26
+
name_start: usize,
27
+
28
+
pub const max_length = 317;
29
+
pub const max_segment_length = 63;
30
+
31
+
/// parse an nsid string. returns null if invalid.
32
+
pub fn parse(s: []const u8) ?Nsid {
33
+
// length check
34
+
if (s.len == 0 or s.len > max_length) return null;
35
+
36
+
var segment_count: usize = 0;
37
+
var segment_start: usize = 0;
38
+
var last_dot: usize = 0;
39
+
40
+
for (s, 0..) |c, i| {
41
+
if (c == '.') {
42
+
const segment = s[segment_start..i];
43
+
// all segments except last must be valid domain segments
44
+
if (!isValidDomainSegment(segment)) return null;
45
+
segment_count += 1;
46
+
last_dot = i;
47
+
segment_start = i + 1;
48
+
}
49
+
}
50
+
51
+
// validate final segment (name)
52
+
const name_seg = s[segment_start..];
53
+
if (!isValidNameSegment(name_seg)) return null;
54
+
segment_count += 1;
55
+
56
+
// must have at least 3 segments
57
+
if (segment_count < 3) return null;
58
+
59
+
return .{
60
+
.raw = s,
61
+
.name_start = last_dot + 1,
62
+
};
63
+
}
64
+
65
+
/// the full nsid string
66
+
pub fn str(self: Nsid) []const u8 {
67
+
return self.raw;
68
+
}
69
+
70
+
/// the domain authority portion (reversed domain)
71
+
pub fn authority(self: Nsid) []const u8 {
72
+
return self.raw[0 .. self.name_start - 1];
73
+
}
74
+
75
+
/// the name segment
76
+
pub fn name(self: Nsid) []const u8 {
77
+
return self.raw[self.name_start..];
78
+
}
79
+
80
+
fn isValidDomainSegment(seg: []const u8) bool {
81
+
// 1-63 characters
82
+
if (seg.len == 0 or seg.len > max_segment_length) return false;
83
+
84
+
// cannot start or end with hyphen
85
+
if (seg[0] == '-' or seg[seg.len - 1] == '-') return false;
86
+
87
+
// lowercase letters, digits, and hyphens only
88
+
for (seg) |c| {
89
+
const valid = (c >= 'a' and c <= 'z') or
90
+
(c >= '0' and c <= '9') or
91
+
c == '-';
92
+
if (!valid) return false;
93
+
}
94
+
95
+
return true;
96
+
}
97
+
98
+
fn isValidNameSegment(seg: []const u8) bool {
99
+
// 1-63 characters
100
+
if (seg.len == 0 or seg.len > max_segment_length) return false;
101
+
102
+
// cannot start with digit
103
+
const first = seg[0];
104
+
if (first >= '0' and first <= '9') return false;
105
+
106
+
// letters and digits only (no hyphens in name)
107
+
for (seg) |c| {
108
+
const valid = (c >= 'a' and c <= 'z') or
109
+
(c >= 'A' and c <= 'Z') or
110
+
(c >= '0' and c <= '9');
111
+
if (!valid) return false;
112
+
}
113
+
114
+
return true;
115
+
}
116
+
};
117
+
118
+
// === tests from atproto.com/specs/nsid ===
119
+
120
+
test "valid: common nsids" {
121
+
const nsid1 = Nsid.parse("app.bsky.feed.post") orelse return error.InvalidNsid;
122
+
try std.testing.expectEqualStrings("app.bsky.feed", nsid1.authority());
123
+
try std.testing.expectEqualStrings("post", nsid1.name());
124
+
125
+
const nsid2 = Nsid.parse("com.atproto.repo.createRecord") orelse return error.InvalidNsid;
126
+
try std.testing.expectEqualStrings("com.atproto.repo", nsid2.authority());
127
+
try std.testing.expectEqualStrings("createRecord", nsid2.name());
128
+
}
129
+
130
+
test "valid: minimum 3 segments" {
131
+
try std.testing.expect(Nsid.parse("a.b.c") != null);
132
+
try std.testing.expect(Nsid.parse("com.example.thing") != null);
133
+
}
134
+
135
+
test "valid: many segments" {
136
+
try std.testing.expect(Nsid.parse("net.users.bob.ping") != null);
137
+
try std.testing.expect(Nsid.parse("a.b.c.d.e.f") != null);
138
+
}
139
+
140
+
test "valid: name with numbers" {
141
+
try std.testing.expect(Nsid.parse("com.example.thing2") != null);
142
+
try std.testing.expect(Nsid.parse("app.bsky.feed.getPost1") != null);
143
+
}
144
+
145
+
test "valid: mixed case in name" {
146
+
try std.testing.expect(Nsid.parse("com.example.fooBar") != null);
147
+
try std.testing.expect(Nsid.parse("com.example.FooBar") != null);
148
+
}
149
+
150
+
test "invalid: only 2 segments" {
151
+
try std.testing.expect(Nsid.parse("com.example") == null);
152
+
try std.testing.expect(Nsid.parse("a.b") == null);
153
+
}
154
+
155
+
test "invalid: name starts with digit" {
156
+
try std.testing.expect(Nsid.parse("com.example.3") == null);
157
+
try std.testing.expect(Nsid.parse("com.example.3thing") == null);
158
+
}
159
+
160
+
test "invalid: name contains hyphen" {
161
+
try std.testing.expect(Nsid.parse("com.example.foo-bar") == null);
162
+
}
163
+
164
+
test "invalid: domain segment uppercase" {
165
+
try std.testing.expect(Nsid.parse("COM.example.thing") == null);
166
+
try std.testing.expect(Nsid.parse("com.EXAMPLE.thing") == null);
167
+
}
168
+
169
+
test "invalid: empty segment" {
170
+
try std.testing.expect(Nsid.parse(".example.thing") == null);
171
+
try std.testing.expect(Nsid.parse("com..thing") == null);
172
+
try std.testing.expect(Nsid.parse("com.example.") == null);
173
+
}
174
+
175
+
test "invalid: segment starts with hyphen" {
176
+
try std.testing.expect(Nsid.parse("-com.example.thing") == null);
177
+
try std.testing.expect(Nsid.parse("com.-example.thing") == null);
178
+
}
179
+
180
+
test "invalid: segment ends with hyphen" {
181
+
try std.testing.expect(Nsid.parse("com-.example.thing") == null);
182
+
try std.testing.expect(Nsid.parse("com.example-.thing") == null);
183
+
}
184
+
185
+
test "invalid: non-ascii" {
186
+
// this would be "com.exa💩ple.thing" but we just use a byte > 127
187
+
var buf = "com.example.thing".*;
188
+
buf[5] = 200; // non-ascii byte
189
+
try std.testing.expect(Nsid.parse(&buf) == null);
190
+
}
191
+
192
+
test "invalid: special characters" {
193
+
try std.testing.expect(Nsid.parse("com.example.thing!") == null);
194
+
try std.testing.expect(Nsid.parse("com.example.thing@") == null);
195
+
try std.testing.expect(Nsid.parse("com.example.thing*") == null);
196
+
}
+123
src/internal/rkey.zig
+123
src/internal/rkey.zig
···
1
+
//! Record Key (rkey)
2
+
//!
3
+
//! record keys identify individual records within a collection.
4
+
//!
5
+
//! validation rules:
6
+
//! - 1-512 characters
7
+
//! - allowed chars: A-Z, a-z, 0-9, period, hyphen, underscore, colon, tilde
8
+
//! - cannot be "." or ".."
9
+
//!
10
+
//! note: TIDs are a common rkey format but not the only valid one.
11
+
//! see tid.zig for TID-specific parsing.
12
+
//!
13
+
//! see: https://atproto.com/specs/record-key
14
+
15
+
const std = @import("std");
16
+
17
+
pub const Rkey = struct {
18
+
/// the rkey string (borrowed, not owned)
19
+
raw: []const u8,
20
+
21
+
pub const min_length = 1;
22
+
pub const max_length = 512;
23
+
24
+
/// parse a record key string. returns null if invalid.
25
+
pub fn parse(s: []const u8) ?Rkey {
26
+
if (!isValid(s)) return null;
27
+
return .{ .raw = s };
28
+
}
29
+
30
+
/// validate a record key string
31
+
pub fn isValid(s: []const u8) bool {
32
+
// length check
33
+
if (s.len < min_length or s.len > max_length) return false;
34
+
35
+
// cannot be "." or ".."
36
+
if (std.mem.eql(u8, s, ".") or std.mem.eql(u8, s, "..")) return false;
37
+
38
+
// check all characters are valid
39
+
for (s) |c| {
40
+
const valid = switch (c) {
41
+
'A'...'Z', 'a'...'z', '0'...'9' => true,
42
+
'.', '-', '_', ':', '~' => true,
43
+
else => false,
44
+
};
45
+
if (!valid) return false;
46
+
}
47
+
48
+
return true;
49
+
}
50
+
51
+
/// get the rkey string
52
+
pub fn str(self: Rkey) []const u8 {
53
+
return self.raw;
54
+
}
55
+
};
56
+
57
+
// === tests from atproto.com/specs/record-key ===
58
+
59
+
test "valid: simple rkey" {
60
+
try std.testing.expect(Rkey.parse("abc123") != null);
61
+
try std.testing.expect(Rkey.parse("self") != null);
62
+
}
63
+
64
+
test "valid: tid format" {
65
+
try std.testing.expect(Rkey.parse("3jxtb5w2hkt2m") != null);
66
+
}
67
+
68
+
test "valid: with allowed special chars" {
69
+
try std.testing.expect(Rkey.parse("abc.def") != null);
70
+
try std.testing.expect(Rkey.parse("abc-def") != null);
71
+
try std.testing.expect(Rkey.parse("abc_def") != null);
72
+
try std.testing.expect(Rkey.parse("abc:def") != null);
73
+
try std.testing.expect(Rkey.parse("abc~def") != null);
74
+
}
75
+
76
+
test "valid: mixed case" {
77
+
try std.testing.expect(Rkey.parse("AbC123") != null);
78
+
try std.testing.expect(Rkey.parse("ABC") != null);
79
+
}
80
+
81
+
test "valid: single character" {
82
+
try std.testing.expect(Rkey.parse("a") != null);
83
+
try std.testing.expect(Rkey.parse("1") != null);
84
+
}
85
+
86
+
test "valid: max length" {
87
+
var buf: [512]u8 = undefined;
88
+
@memset(&buf, 'a');
89
+
try std.testing.expect(Rkey.parse(&buf) != null);
90
+
}
91
+
92
+
test "invalid: empty" {
93
+
try std.testing.expect(Rkey.parse("") == null);
94
+
}
95
+
96
+
test "invalid: dot" {
97
+
try std.testing.expect(Rkey.parse(".") == null);
98
+
}
99
+
100
+
test "invalid: double dot" {
101
+
try std.testing.expect(Rkey.parse("..") == null);
102
+
}
103
+
104
+
test "invalid: too long" {
105
+
var buf: [513]u8 = undefined;
106
+
@memset(&buf, 'a');
107
+
try std.testing.expect(Rkey.parse(&buf) == null);
108
+
}
109
+
110
+
test "invalid: forbidden characters" {
111
+
try std.testing.expect(Rkey.parse("abc/def") == null);
112
+
try std.testing.expect(Rkey.parse("abc?def") == null);
113
+
try std.testing.expect(Rkey.parse("abc#def") == null);
114
+
try std.testing.expect(Rkey.parse("abc@def") == null);
115
+
try std.testing.expect(Rkey.parse("abc def") == null);
116
+
try std.testing.expect(Rkey.parse("abc\ndef") == null);
117
+
}
118
+
119
+
test "invalid: non-ascii" {
120
+
var buf = "abcdef".*;
121
+
buf[2] = 200; // non-ascii byte
122
+
try std.testing.expect(Rkey.parse(&buf) == null);
123
+
}
+22
src/internal/tid.zig
+22
src/internal/tid.zig
···
119
119
try std.testing.expectEqual(ts, tid.timestamp());
120
120
try std.testing.expectEqual(clock, tid.clockId());
121
121
}
122
+
123
+
test "valid first chars" {
124
+
// first char must be 2-7 only
125
+
try std.testing.expect(Tid.parse("2222222222222") != null);
126
+
try std.testing.expect(Tid.parse("3222222222222") != null);
127
+
try std.testing.expect(Tid.parse("4222222222222") != null);
128
+
try std.testing.expect(Tid.parse("5222222222222") != null);
129
+
try std.testing.expect(Tid.parse("6222222222222") != null);
130
+
try std.testing.expect(Tid.parse("7222222222222") != null);
131
+
}
132
+
133
+
test "all valid chars in non-first position" {
134
+
// chars 2-7 and a-z are valid after first position
135
+
try std.testing.expect(Tid.parse("2aaaaaaaaaaaa") != null);
136
+
try std.testing.expect(Tid.parse("2zzzzzzzzzzzz") != null);
137
+
try std.testing.expect(Tid.parse("2234567234567") != null);
138
+
}
139
+
140
+
test "uppercase rejected" {
141
+
try std.testing.expect(Tid.parse("2AAAAAAAAAAAA") == null);
142
+
try std.testing.expect(Tid.parse("2AAAAAAAAaaaa") == null);
143
+
}