const std = @import("std");const io_mod = @import("../shared/io.zig"); const Allocator = std.mem.Allocator;const session_id_random_bytes: usize = 8; pub fn sessionDirPath(alloc: Allocator, sessions_dir: []const u8, session_id: []const u8) ![]u8 {    try validateSessionId(session_id);    return std.fs.path.join(alloc, &.{ sessions_dir, session_id });} pub fn validateSessionId(session_id: []const u8) !void {    if (session_id.len == 0 or session_id.len > 255 or        std.mem.eql(u8, session_id, ".") or std.mem.eql(u8, session_id, ".."))    {        return error.InvalidSessionId;    }    for (session_id) |byte| {        if (!std.ascii.isAlphanumeric(byte) and byte != '.' and byte != '_' and byte != '-') {            return error.InvalidSessionId;        }    }} pub fn generateSessionId(alloc: Allocator) ![]u8 {    var random_bytes: [session_id_random_bytes]u8 = undefined;    io_mod.getIo().random(&random_bytes);    const random_hex = std.fmt.bytesToHex(random_bytes, .lower);    return std.fmt.allocPrint(alloc, "{d}-{d}-{s}", .{ io_mod.milliTimestamp(), io_mod.nanoTimestamp(), random_hex });} fn isLowerHex(text: []const u8) bool {    for (text) |c| {        if (!((c >= '0' and c <= '9') or (c >= 'a' and c <= 'f'))) return false;    }    return true;} test "generated session id includes random hex suffix" {    const id = try generateSessionId(std.testing.allocator);    defer std.testing.allocator.free(id);     var segments = std.mem.splitScalar(u8, id, '-');    const millis = segments.next() orelse return error.TestExpectedEqual;    const nanos = segments.next() orelse return error.TestExpectedEqual;    const suffix = segments.next() orelse return error.TestExpectedEqual;     try std.testing.expect(segments.next() == null);    try std.testing.expect(millis.len > 0);    try std.testing.expect(nanos.len > 0);    _ = try std.fmt.parseInt(i64, millis, 10);    _ = try std.fmt.parseInt(i128, nanos, 10);    try std.testing.expectEqual(@as(usize, 16), suffix.len);    try std.testing.expect(isLowerHex(suffix));} test "session directory path rejects unsafe ids" {    const alloc = std.testing.allocator;    inline for (.{ "", ".", "..", "../outside", "/tmp/outside", "nested/session", "nested\\session" }) |id| {        try std.testing.expectError(error.InvalidSessionId, sessionDirPath(alloc, "/tmp/sessions", id));    }     const unsupported = [_]u8{ 0xff, 'a' };    try std.testing.expectError(        error.InvalidSessionId,        sessionDirPath(alloc, "/tmp/sessions", &unsupported),    );     var too_long: [256]u8 = undefined;    @memset(&too_long, 'a');    try std.testing.expectError(        error.InvalidSessionId,        sessionDirPath(alloc, "/tmp/sessions", &too_long),    );     const dotted = try sessionDirPath(alloc, "/tmp/sessions", "session.v3");    defer alloc.free(dotted);    try std.testing.expectEqualStrings("/tmp/sessions/session.v3", dotted);    inline for (.{        ".hidden-session",        "session..branch",        "last",        "resume",    }) |id| {        const valid = try sessionDirPath(alloc, "/tmp/sessions", id);        alloc.free(valid);    }     const nul_id = [_]u8{ 'a', 0, 'b' };    try std.testing.expectError(        error.InvalidSessionId,        sessionDirPath(alloc, "/tmp/sessions", &nul_id),    );     var max_id: [255]u8 = undefined;    @memset(&max_id, 'a');    const maximum = try sessionDirPath(alloc, "/tmp/sessions", &max_id);    defer alloc.free(maximum);    try std.testing.expect(std.mem.endsWith(u8, maximum, &max_id));}