const std = @import("std");const session_layout = @import("session_layout.zig"); const Allocator = std.mem.Allocator; /// Cache file holding the per-workspace "latest session" summary list.pub const session_list_json_file = "list.json"; /// Cache file holding the aggregate session-count / latest-id summary.pub const session_summary_file = "summary.json"; /// Validates a session id against the shared layout rules (length, charset,/// path safety). Errors propagate from `session_layout` unchanged.pub fn validateSessionId(session_id: []const u8) !void {    return session_layout.validateSessionId(session_id);} /// Builds the absolute directory path for a session, for display, transitional/// legacy facades, and tests. Caller owns the returned slice.pub fn sessionDirPath(alloc: Allocator, sessions_dir: []const u8, session_id: []const u8) ![]u8 {    return session_layout.sessionDirPath(alloc, sessions_dir, session_id);} /// Generates a fresh, layout-valid session id. Caller owns the returned slice.pub fn generateSessionId(alloc: Allocator) ![]u8 {    return session_layout.generateSessionId(alloc);} /// Path to the aggregate summary cache under `sessions_dir`. Caller owns it.pub fn summaryPath(alloc: Allocator, sessions_dir: []const u8) Allocator.Error![]u8 {    return std.fs.path.join(alloc, &.{ sessions_dir, session_summary_file });} /// Path to a session's primary `session.json` under `sessions_dir`. Caller owns it.pub fn sessionJsonPath(alloc: Allocator, sessions_dir: []const u8, session_id: []const u8) ![]u8 {    const session_dir = try sessionDirPath(alloc, sessions_dir, session_id);    defer alloc.free(session_dir);    return std.fs.path.join(alloc, &.{ session_dir, "session.json" });} /// Strips trailing slashes from a workspace root (keeping at least one char), so/// equivalent roots compare equal. Returns a borrowed sub-slice of the input.pub fn normalizeWorkspaceRoot(workspace_root: []const u8) []const u8 {    var end = workspace_root.len;    while (end > 1 and workspace_root[end - 1] == '/') {        end -= 1;    }    return workspace_root[0..end];} /// Rejects a workspace root that is empty, too long, not valid UTF-8, or not/// absolute. The only failure is `error.InvalidDurableField`.pub fn validateWorkspaceRoot(workspace_root: []const u8) error{InvalidDurableField}!void {    if (workspace_root.len == 0 or        workspace_root.len > std.Io.Dir.max_path_bytes or        !std.unicode.utf8ValidateSlice(workspace_root) or        !std.Io.Dir.path.isAbsolute(workspace_root))    {        return error.InvalidDurableField;    }}