diff --git a/src/atom.zig b/src/atom.zig
index ef836c5..4394d08 100644
--- a/src/atom.zig
+++ b/src/atom.zig
@@ -201,7 +201,13 @@ pub fn generateFeed(allocator: Allocator, releases: []const Release) ![]u8 {
         try writer.writeAll("</id>\n");
 
         try writer.writeAll("  <updated>");
-        try escapeXml(writer, release.published_at);
+        const published = zeit.Instant{
+            .timestamp = release.published_at * std.time.ns_per_s,
+            .timezone = &zeit.utc,
+        };
+        // try escapeXml(writer, release.published_at);
+        // try std.testing.expect(std.mem.indexOf(u8, atom_content, "<updated>2024-01-01T00:00:00Z</updated>") != null);
+        try published.time().strftime(writer, "%Y-%m-%dT%H:%M:%SZ");
         try writer.writeAll("</updated>\n");
 
         try writer.writeAll("  <author><name>");
@@ -276,7 +282,10 @@ test "Atom feed generation with markdown" {
         Release{
             .repo_name = "test/repo",
             .tag_name = "v1.0.0",
-            .published_at = "2024-01-01T00:00:00Z",
+            .published_at = @intCast(@divTrunc(
+                (try zeit.instant(.{ .source = .{ .iso8601 = "2024-01-01T00:00:00Z" } })).timestamp,
+                std.time.ns_per_s,
+            )),
             .html_url = "https://github.com/test/repo/releases/tag/v1.0.0",
             .description = "## What's Changed\n* Fixed bug\n* Added feature",
             .provider = "github",
@@ -301,7 +310,10 @@ test "Atom feed with fallback markdown" {
         Release{
             .repo_name = "test/repo",
             .tag_name = "v1.0.0",
-            .published_at = "2024-01-01T00:00:00Z",
+            .published_at = @intCast(@divTrunc(
+                (try zeit.instant(.{ .source = .{ .iso8601 = "2024-01-01T00:00:00Z" } })).timestamp,
+                std.time.ns_per_s,
+            )),
             .html_url = "https://github.com/test/repo/releases/tag/v1.0.0",
             .description = "```javascript\nconst x = 1;\n```",
             .provider = "github",
@@ -323,7 +335,10 @@ test "Atom feed with special characters" {
         Release{
             .repo_name = "test/repo<script>",
             .tag_name = "v1.0.0 & more",
-            .published_at = "2024-01-01T00:00:00Z",
+            .published_at = @intCast(@divTrunc(
+                (try zeit.instant(.{ .source = .{ .iso8601 = "2024-01-01T00:00:00Z" } })).timestamp,
+                std.time.ns_per_s,
+            )),
             .html_url = "https://github.com/test/repo/releases/tag/v1.0.0",
             .description = "Test \"release\" with <special> chars & symbols",
             .provider = "github",
diff --git a/src/main.zig b/src/main.zig
index d2b4700..feca0f0 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -10,8 +10,8 @@ const Codeberg = @import("providers/Codeberg.zig");
 const SourceHut = @import("providers/SourceHut.zig");
 const atom = @import("atom.zig");
 const config = @import("config.zig");
-const xml_parser = @import("xml_parser.zig");
 const zeit = @import("zeit");
+const utils = @import("utils.zig");
 
 const Provider = @import("Provider.zig");
 
@@ -56,13 +56,13 @@ fn printInfo(comptime fmt: []const u8, args: anytype) void {
         stderr.print(fmt, args) catch {};
 }
 
-// Configuration: Only include releases from the last 6 months
-const RELEASE_AGE_LIMIT_SECONDS: i64 = 365 * 24 * 60 * 60 / 2; // 6 months in seconds
+// Configuration: Only include releases from the last 365 days
+const RELEASE_AGE_LIMIT_SECONDS: i64 = 365 * std.time.s_per_day; // Get from last 365 days
 
 pub const Release = struct {
     repo_name: []const u8,
     tag_name: []const u8,
-    published_at: []const u8,
+    published_at: i64,
     html_url: []const u8,
     description: []const u8,
     provider: []const u8,
@@ -70,7 +70,6 @@ pub const Release = struct {
     pub fn deinit(self: Release, allocator: Allocator) void {
         allocator.free(self.repo_name);
         allocator.free(self.tag_name);
-        allocator.free(self.published_at);
         allocator.free(self.html_url);
         allocator.free(self.description);
         allocator.free(self.provider);
@@ -86,7 +85,6 @@ const ProviderResult = struct {
 
 const ThreadContext = struct {
     provider: Provider,
-    latest_release_date: i64,
     result: *ProviderResult,
     allocator: Allocator,
 };
@@ -123,22 +121,8 @@ pub fn main() !u8 {
     };
     defer app_config.deinit();
 
-    // Load existing releases to determine last check time per provider
-    var existing_releases = loadExistingReleases(allocator, output_file) catch ArrayList(Release).init(allocator);
-    defer {
-        for (existing_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        existing_releases.deinit();
-    }
-
-    var new_releases = ArrayList(Release).init(allocator);
-    defer {
-        for (new_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        new_releases.deinit();
-    }
+    var all_releases = ArrayList(Release).init(allocator);
+    defer all_releases.deinit();
 
     printInfo("Fetching releases from all providers concurrently...\n", .{});
 
@@ -170,20 +154,22 @@ pub fn main() !u8 {
     };
 
     // Fetch releases from all providers concurrently using thread pool
-    const provider_results = try fetchReleasesFromAllProviders(allocator, providers.items, existing_releases.items);
+    const provider_results = try fetchReleasesFromAllProviders(allocator, providers.items);
     defer {
         for (provider_results) |*result| {
-            // Don't free the releases here - they're transferred to new_releases
-            result.releases.deinit();
             // Free error messages if they exist
-            if (result.error_msg) |error_msg| {
+            if (result.error_msg) |error_msg|
                 allocator.free(error_msg);
-            }
+            for (result.releases.items) |release|
+                release.deinit(allocator);
+            result.releases.deinit();
         }
         allocator.free(provider_results);
     }
 
-    // Check for provider errors and report them
+    const now = std.time.timestamp();
+    const cutoff_time = now - RELEASE_AGE_LIMIT_SECONDS;
+
     var has_errors = false;
     for (provider_results) |result| {
         if (result.error_msg) |error_msg| {
@@ -198,41 +184,26 @@ pub fn main() !u8 {
         return 1;
     }
 
-    // Combine all new releases from threaded providers
+    var original_count: usize = 0;
+    // Combine all releases from threaded providers
     for (provider_results) |result| {
-        try new_releases.appendSlice(result.releases.items);
+        original_count += result.releases.items.len;
+        // Results should be sorted already...we will find the oldest applicable release,
+        // then copy into all_releases
+
+        var last_index: usize = 0;
+        for (result.releases.items) |release| {
+            if (release.published_at >= cutoff_time) {
+                last_index += 1;
+            } else break;
+        }
+        // Total releases in feed: 1170 of 3591 total in last 365 days
+        std.log.debug("last_index: {} : {s}", .{ last_index, result.provider_name });
+        try all_releases.appendSlice(result.releases.items[0..last_index]);
     }
 
-    // Combine all releases (existing and new)
-    var all_releases = ArrayList(Release).init(allocator);
-    defer all_releases.deinit();
-
-    // Add new releases
-    try all_releases.appendSlice(new_releases.items);
-
-    // Add all existing releases
-    try all_releases.appendSlice(existing_releases.items);
-
     // Sort all releases by published date (most recent first)
-    std.mem.sort(Release, all_releases.items, {}, compareReleasesByDate);
-
-    // Filter releases by age in-place - zero extra allocations
-    const now = std.time.timestamp();
-    const cutoff_time = now - RELEASE_AGE_LIMIT_SECONDS;
-
-    var write_index: usize = 0;
-    const original_count = all_releases.items.len;
-
-    for (all_releases.items) |release| {
-        const release_time = parseReleaseTimestamp(release.published_at) catch 0;
-        if (release_time >= cutoff_time) {
-            all_releases.items[write_index] = release;
-            write_index += 1;
-        }
-    }
-
-    // Shrink the array to only include filtered items
-    all_releases.shrinkRetainingCapacity(write_index);
+    std.mem.sort(Release, all_releases.items, {}, utils.compareReleasesByDate);
 
     // Generate Atom feed from filtered releases
     const atom_content = try atom.generateFeed(allocator, all_releases.items);
@@ -247,88 +218,12 @@ pub fn main() !u8 {
     _ = checkFileSizeAndWarn(atom_content.len);
 
     // Log to stderr for user feedback
-    printInfo("Found {} new releases\n", .{new_releases.items.len});
-    printInfo("Total releases in feed: {} (filtered from {} total, showing last {} days)\n", .{ all_releases.items.len, original_count, @divTrunc(RELEASE_AGE_LIMIT_SECONDS, 24 * 60 * 60) });
+    printInfo("Total releases in feed: {} of {} total in last {} days\n", .{ all_releases.items.len, original_count, @divTrunc(RELEASE_AGE_LIMIT_SECONDS, std.time.s_per_day) });
     printInfo("Updated feed written to: {s}\n", .{output_file});
 
     return 0;
 }
 
-fn loadExistingReleases(allocator: Allocator, filename: []const u8) !ArrayList(Release) {
-    const file = std.fs.cwd().openFile(filename, .{}) catch |err| switch (err) {
-        error.FileNotFound => {
-            printInfo("No existing releases file found, starting fresh\n", .{});
-            return ArrayList(Release).init(allocator);
-        },
-        else => return err,
-    };
-    defer file.close();
-
-    const content = try file.readToEndAlloc(allocator, 10 * 1024 * 1024);
-    defer allocator.free(content);
-
-    printInfo("Loading existing releases from {s}...\n", .{filename});
-    const releases = try parseReleasesFromXml(allocator, content);
-    printInfo("Loaded {} existing releases\n", .{releases.items.len});
-    return releases;
-}
-
-fn parseReleasesFromXml(allocator: Allocator, xml_content: []const u8) !ArrayList(Release) {
-    const releases = xml_parser.parseAtomFeed(allocator, xml_content) catch |err| {
-        printError("Warning: Failed to parse XML content: {}\n", .{err});
-        printInfo("Starting fresh with no existing releases\n", .{});
-        return ArrayList(Release).init(allocator);
-    };
-
-    return releases;
-}
-
-pub fn filterNewReleases(allocator: Allocator, all_releases: []const Release, since_timestamp: i64) !ArrayList(Release) {
-    var new_releases = ArrayList(Release).init(allocator);
-
-    for (all_releases) |release| {
-        // Parse the published_at timestamp
-        const release_time = parseReleaseTimestamp(release.published_at) catch continue;
-
-        if (release_time > since_timestamp) {
-            // This is a new release, duplicate it for our list
-            const new_release = Release{
-                .repo_name = try allocator.dupe(u8, release.repo_name),
-                .tag_name = try allocator.dupe(u8, release.tag_name),
-                .published_at = try allocator.dupe(u8, release.published_at),
-                .html_url = try allocator.dupe(u8, release.html_url),
-                .description = try allocator.dupe(u8, release.description),
-                .provider = try allocator.dupe(u8, release.provider),
-            };
-            try new_releases.append(new_release);
-        }
-    }
-
-    return new_releases;
-}
-
-pub fn parseReleaseTimestamp(date_str: []const u8) !i64 {
-    // Try parsing as direct timestamp first
-    if (std.fmt.parseInt(i64, date_str, 10)) |timestamp| {
-        return timestamp;
-    } else |_| {
-        // Try parsing as ISO 8601 format using Zeit
-        const instant = zeit.instant(.{
-            .source = .{ .iso8601 = date_str },
-        }) catch return 0;
-        // Zeit returns nanoseconds, convert to seconds
-        const seconds = @divTrunc(instant.timestamp, 1_000_000_000);
-        return @intCast(seconds);
-    }
-}
-
-pub fn compareReleasesByDate(context: void, a: Release, b: Release) bool {
-    _ = context;
-    const timestamp_a = parseReleaseTimestamp(a.published_at) catch 0;
-    const timestamp_b = parseReleaseTimestamp(b.published_at) catch 0;
-    return timestamp_a > timestamp_b; // Most recent first
-}
-
 fn formatTimestampForDisplay(allocator: Allocator, timestamp: i64) ![]const u8 {
     if (timestamp == 0) {
         return try allocator.dupe(u8, "beginning of time");
@@ -359,7 +254,6 @@ fn formatTimestampForDisplay(allocator: Allocator, timestamp: i64) ![]const u8 {
 fn fetchReleasesFromAllProviders(
     allocator: Allocator,
     providers: []const Provider,
-    existing_releases: []const Release,
 ) ![]ProviderResult {
     var results = try allocator.alloc(ProviderResult, providers.len);
 
@@ -382,20 +276,8 @@ fn fetchReleasesFromAllProviders(
 
     // Calculate the latest release date for each provider from existing releases
     for (providers, 0..) |provider, i| {
-        // Find the latest release date for this provider
-        var latest_date: i64 = 0;
-        for (existing_releases) |release| {
-            if (std.mem.eql(u8, release.provider, provider.getName())) {
-                const release_time = parseReleaseTimestamp(release.published_at) catch 0;
-                if (release_time > latest_date) {
-                    latest_date = release_time;
-                }
-            }
-        }
-
         contexts[i] = ThreadContext{
             .provider = provider,
-            .latest_release_date = latest_date,
             .result = &results[i],
             .allocator = allocator,
         };
@@ -413,45 +295,23 @@ fn fetchReleasesFromAllProviders(
 
 fn fetchProviderReleases(context: *const ThreadContext) void {
     const provider = context.provider;
-    const latest_release_date = context.latest_release_date;
     const result = context.result;
     const allocator = context.allocator;
 
-    const since_str = formatTimestampForDisplay(allocator, latest_release_date) catch "unknown";
-    defer if (!std.mem.eql(u8, since_str, "unknown")) allocator.free(since_str);
-    printInfo("Fetching releases from {s} (since: {s})...\n", .{ provider.getName(), since_str });
+    printInfo("Fetching releases from {s}...\n", .{provider.getName()});
 
     // Start timing
     const start_time = std.time.milliTimestamp();
 
-    if (provider.fetchReleases(allocator)) |all_releases| {
-        defer {
-            for (all_releases.items) |release| {
-                release.deinit(allocator);
-            }
-            all_releases.deinit();
-        }
+    const releases_or_err = provider.fetchReleases(allocator);
+    const end_time = std.time.milliTimestamp();
+    const duration_ms: u64 = @intCast(end_time - start_time);
+    result.duration_ms = duration_ms;
 
-        // Filter releases newer than latest known release
-        const filtered = filterNewReleases(allocator, all_releases.items, latest_release_date) catch |err| {
-            const error_msg = std.fmt.allocPrint(allocator, "Error filtering releases: {}", .{err}) catch "Unknown filter error";
-            result.error_msg = error_msg;
-            return;
-        };
-
-        // Calculate duration
-        const end_time = std.time.milliTimestamp();
-        const duration_ms: u64 = @intCast(end_time - start_time);
-        result.duration_ms = duration_ms;
-
-        result.releases = filtered;
-        printInfo("✓ {s}: Found {} new releases in {d}ms\n", .{ provider.getName(), filtered.items.len, duration_ms });
+    if (releases_or_err) |all_releases| {
+        result.releases = all_releases;
+        printInfo("✓ {s}: Found {} releases in {d}ms\n", .{ provider.getName(), result.releases.items.len, duration_ms });
     } else |err| {
-        // Calculate duration even for errors
-        const end_time = std.time.milliTimestamp();
-        const duration_ms: u64 = @intCast(end_time - start_time);
-        result.duration_ms = duration_ms;
-
         const error_msg = std.fmt.allocPrint(allocator, "Error fetching releases: {}", .{err}) catch "Unknown fetch error";
         result.error_msg = error_msg;
         // Don't print error here - it will be handled in main function
@@ -498,7 +358,10 @@ test "atom feed generation" {
         Release{
             .repo_name = "test/repo",
             .tag_name = "v1.0.0",
-            .published_at = "2024-01-01T00:00:00Z",
+            .published_at = @intCast(@divTrunc(
+                (try zeit.instant(.{ .source = .{ .iso8601 = "2024-01-01T00:00:00Z" } })).timestamp,
+                std.time.ns_per_s,
+            )),
             .html_url = "https://github.com/test/repo/releases/tag/v1.0.0",
             .description = "Test release",
             .provider = "github",
@@ -535,207 +398,6 @@ test "atom feed generation" {
     try std.testing.expect(std.mem.indexOf(u8, atom_content, "<category term=\"github\"/>") != null);
 }
 
-test "loadExistingReleases with valid XML" {
-    const allocator = std.testing.allocator;
-
-    // Test XML content
-    const test_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<entry>
-        \\  <title>test/repo - v1.0.0</title>
-        \\  <link href="https://github.com/test/repo/releases/tag/v1.0.0"/>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <summary>Test release</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    // Parse releases directly from XML content
-    var releases = try parseReleasesFromXml(allocator, test_xml);
-    defer {
-        for (releases.items) |release| {
-            release.deinit(allocator);
-        }
-        releases.deinit();
-    }
-
-    try std.testing.expectEqual(@as(usize, 1), releases.items.len);
-    try std.testing.expectEqualStrings("test/repo", releases.items[0].repo_name);
-    try std.testing.expectEqualStrings("v1.0.0", releases.items[0].tag_name);
-}
-
-test "loadExistingReleases with nonexistent file" {
-    const allocator = std.testing.allocator;
-
-    var releases = try loadExistingReleases(allocator, "nonexistent_file.xml");
-    defer releases.deinit();
-
-    try std.testing.expectEqual(@as(usize, 0), releases.items.len);
-}
-
-test "loadExistingReleases with malformed XML" {
-    const allocator = std.testing.allocator;
-
-    const malformed_xml = "This is not valid XML at all!";
-
-    // Should handle gracefully and return empty list
-    var releases = try parseReleasesFromXml(allocator, malformed_xml);
-    defer releases.deinit();
-
-    try std.testing.expectEqual(@as(usize, 0), releases.items.len);
-}
-
-test "parseReleaseTimestamp with various formats" {
-    // Test ISO 8601 format
-    const timestamp1 = try parseReleaseTimestamp("2024-01-01T00:00:00Z");
-    try std.testing.expect(timestamp1 > 0);
-
-    // Test direct timestamp
-    const timestamp2 = try parseReleaseTimestamp("1704067200");
-    try std.testing.expectEqual(@as(i64, 1704067200), timestamp2);
-
-    // Test invalid format (should return 0)
-    const timestamp3 = parseReleaseTimestamp("invalid") catch 0;
-    try std.testing.expectEqual(@as(i64, 0), timestamp3);
-
-    // Test empty string
-    const timestamp4 = parseReleaseTimestamp("") catch 0;
-    try std.testing.expectEqual(@as(i64, 0), timestamp4);
-
-    // Test different ISO formats
-    const timestamp5 = try parseReleaseTimestamp("2024-12-25T15:30:45Z");
-    try std.testing.expect(timestamp5 > timestamp1);
-}
-
-test "filterNewReleases correctly filters by timestamp" {
-    const allocator = std.testing.allocator;
-
-    const old_release = Release{
-        .repo_name = "test/old",
-        .tag_name = "v1.0.0",
-        .published_at = "2024-01-01T00:00:00Z",
-        .html_url = "https://github.com/test/old/releases/tag/v1.0.0",
-        .description = "Old release",
-        .provider = "github",
-    };
-
-    const new_release = Release{
-        .repo_name = "test/new",
-        .tag_name = "v2.0.0",
-        .published_at = "2024-06-01T00:00:00Z",
-        .html_url = "https://github.com/test/new/releases/tag/v2.0.0",
-        .description = "New release",
-        .provider = "github",
-    };
-
-    const all_releases = [_]Release{ old_release, new_release };
-
-    // Filter with timestamp between the two releases
-    const march_timestamp = try parseReleaseTimestamp("2024-03-01T00:00:00Z");
-    var filtered = try filterNewReleases(allocator, &all_releases, march_timestamp);
-    defer {
-        for (filtered.items) |release| {
-            release.deinit(allocator);
-        }
-        filtered.deinit();
-    }
-
-    // Should only contain the new release
-    try std.testing.expectEqual(@as(usize, 1), filtered.items.len);
-    try std.testing.expectEqualStrings("test/new", filtered.items[0].repo_name);
-}
-
-test "loadExistingReleases handles various XML structures" {
-    const allocator = std.testing.allocator;
-
-    // Test with minimal valid XML
-    const minimal_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<entry>
-        \\  <title>minimal/repo - v1.0.0</title>
-        \\  <link href="https://github.com/minimal/repo/releases/tag/v1.0.0"/>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\</entry>
-        \\</feed>
-    ;
-
-    // Parse releases directly from XML content
-    var releases = try parseReleasesFromXml(allocator, minimal_xml);
-    defer {
-        for (releases.items) |release| {
-            release.deinit(allocator);
-        }
-        releases.deinit();
-    }
-
-    try std.testing.expectEqual(@as(usize, 1), releases.items.len);
-    try std.testing.expectEqualStrings("minimal/repo", releases.items[0].repo_name);
-    try std.testing.expectEqualStrings("v1.0.0", releases.items[0].tag_name);
-    try std.testing.expectEqualStrings("2024-01-01T00:00:00Z", releases.items[0].published_at);
-}
-
-test "loadExistingReleases with complex XML content" {
-    const allocator = std.testing.allocator;
-
-    // Test with complex XML including escaped characters and multiple entries
-    const complex_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<subtitle>New releases from starred repositories</subtitle>
-        \\<link href="https://github.com" rel="alternate"/>
-        \\<link href="https://example.com/releases.xml" rel="self"/>
-        \\<id>https://example.com/releases</id>
-        \\<updated>2024-01-01T00:00:00Z</updated>
-        \\<entry>
-        \\  <title>complex/repo &amp; more - v1.0.0 &lt;beta&gt;</title>
-        \\  <link href="https://github.com/complex/repo/releases/tag/v1.0.0"/>
-        \\  <id>https://github.com/complex/repo/releases/tag/v1.0.0</id>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <author><n>github</n></author>
-        \\  <summary>Release with &quot;special&quot; characters &amp; symbols</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\<entry>
-        \\  <title>another/repo - v2.0.0</title>
-        \\  <link href="https://gitlab.com/another/repo/-/releases/v2.0.0"/>
-        \\  <id>https://gitlab.com/another/repo/-/releases/v2.0.0</id>
-        \\  <updated>2024-01-02T12:30:45Z</updated>
-        \\  <author><n>gitlab</n></author>
-        \\  <summary>Another release</summary>
-        \\  <category term="gitlab"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    // Parse releases directly from XML content
-    var releases = try parseReleasesFromXml(allocator, complex_xml);
-    defer {
-        for (releases.items) |release| {
-            release.deinit(allocator);
-        }
-        releases.deinit();
-    }
-
-    try std.testing.expectEqual(@as(usize, 2), releases.items.len);
-
-    // Check first release with escaped characters
-    try std.testing.expectEqualStrings("complex/repo & more", releases.items[0].repo_name);
-    try std.testing.expectEqualStrings("v1.0.0 <beta>", releases.items[0].tag_name);
-    try std.testing.expectEqualStrings("Release with \"special\" characters & symbols", releases.items[0].description);
-    try std.testing.expectEqualStrings("github", releases.items[0].provider);
-
-    // Check second release
-    try std.testing.expectEqualStrings("another/repo", releases.items[1].repo_name);
-    try std.testing.expectEqualStrings("v2.0.0", releases.items[1].tag_name);
-    try std.testing.expectEqualStrings("gitlab", releases.items[1].provider);
-}
-
 test "formatTimestampForDisplay produces valid ISO dates" {
     const allocator = std.testing.allocator;
 
@@ -752,87 +414,6 @@ test "formatTimestampForDisplay produces valid ISO dates" {
     try std.testing.expect(std.mem.indexOf(u8, known_result, "T") != null);
 }
 
-test "XML parsing handles malformed entries gracefully" {
-    const allocator = std.testing.allocator;
-
-    // Test with partially malformed XML (missing closing tags, etc.)
-    const malformed_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<entry>
-        \\  <title>good/repo - v1.0.0</title>
-        \\  <link href="https://github.com/good/repo/releases/tag/v1.0.0"/>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\</entry>
-        \\<entry>
-        \\  <title>broken/repo - v2.0.0
-        \\  <link href="https://github.com/broken/repo/releases/tag/v2.0.0"/>
-        \\  <updated>2024-01-02T00:00:00Z</updated>
-        \\</entry>
-        \\<entry>
-        \\  <title>another/good - v3.0.0</title>
-        \\  <link href="https://github.com/another/good/releases/tag/v3.0.0"/>
-        \\  <updated>2024-01-03T00:00:00Z</updated>
-        \\</entry>
-        \\</feed>
-    ;
-
-    var releases = try xml_parser.parseAtomFeed(allocator, malformed_xml);
-    defer {
-        for (releases.items) |release| {
-            release.deinit(allocator);
-        }
-        releases.deinit();
-    }
-
-    // Should parse the good entries and skip/handle the malformed one gracefully
-    try std.testing.expect(releases.items.len >= 2);
-
-    // Check that we got the good entries
-    var found_good = false;
-    var found_another_good = false;
-    for (releases.items) |release| {
-        if (std.mem.eql(u8, release.repo_name, "good/repo")) {
-            found_good = true;
-        }
-        if (std.mem.eql(u8, release.repo_name, "another/good")) {
-            found_another_good = true;
-        }
-    }
-    try std.testing.expect(found_good);
-    try std.testing.expect(found_another_good);
-}
-
-test "compareReleasesByDate" {
-    const release1 = Release{
-        .repo_name = "test/repo1",
-        .tag_name = "v1.0.0",
-        .published_at = "2024-01-01T00:00:00Z",
-        .html_url = "https://github.com/test/repo1/releases/tag/v1.0.0",
-        .description = "First release",
-        .provider = "github",
-    };
-
-    const release2 = Release{
-        .repo_name = "test/repo2",
-        .tag_name = "v2.0.0",
-        .published_at = "2024-01-02T00:00:00Z",
-        .html_url = "https://github.com/test/repo2/releases/tag/v2.0.0",
-        .description = "Second release",
-        .provider = "github",
-    };
-
-    // release2 should come before release1 (more recent first)
-    try std.testing.expect(compareReleasesByDate({}, release2, release1));
-    try std.testing.expect(!compareReleasesByDate({}, release1, release2));
-}
-
-// Import XML parser tests
-test {
-    std.testing.refAllDecls(@import("xml_parser_tests.zig"));
-}
-
 test "Age-based release filtering" {
     const allocator = std.testing.allocator;
 
@@ -844,32 +425,29 @@ test "Age-based release filtering" {
     const recent_release = Release{
         .repo_name = "test/recent",
         .tag_name = "v1.0.0",
-        .published_at = try std.fmt.allocPrint(allocator, "{}", .{now - 86400}), // 1 day ago
+        .published_at = now - std.time.s_per_day, // 1 day ago
         .html_url = "https://github.com/test/recent/releases/tag/v1.0.0",
         .description = "Recent release",
         .provider = "github",
     };
-    defer allocator.free(recent_release.published_at);
 
     const old_release = Release{
         .repo_name = "test/old",
         .tag_name = "v0.1.0",
-        .published_at = try std.fmt.allocPrint(allocator, "{}", .{two_years_ago}),
+        .published_at = two_years_ago,
         .html_url = "https://github.com/test/old/releases/tag/v0.1.0",
         .description = "Old release",
         .provider = "github",
     };
-    defer allocator.free(old_release.published_at);
 
     const borderline_release = Release{
         .repo_name = "test/borderline",
         .tag_name = "v0.5.0",
-        .published_at = try std.fmt.allocPrint(allocator, "{}", .{one_year_ago + 3600}), // 1 hour within limit
+        .published_at = one_year_ago + std.time.s_per_hour, // 1 hour within limit
         .html_url = "https://github.com/test/borderline/releases/tag/v0.5.0",
         .description = "Borderline release",
         .provider = "github",
     };
-    defer allocator.free(borderline_release.published_at);
 
     const releases = [_]Release{ recent_release, old_release, borderline_release };
 
@@ -880,7 +458,7 @@ test "Age-based release filtering" {
     const cutoff_time = now - RELEASE_AGE_LIMIT_SECONDS;
 
     for (releases) |release| {
-        const release_time = parseReleaseTimestamp(release.published_at) catch 0;
+        const release_time = release.published_at;
         if (release_time >= cutoff_time) {
             try filtered.append(release);
         }
@@ -909,7 +487,7 @@ test "Age-based release filtering" {
     try std.testing.expect(!found_old);
 }
 
-// Import timestamp tests
+// Import others
 test {
     std.testing.refAllDecls(@import("timestamp_tests.zig"));
     std.testing.refAllDecls(@import("atom.zig"));
diff --git a/src/providers/Codeberg.zig b/src/providers/Codeberg.zig
index efb66d0..ef9d469 100644
--- a/src/providers/Codeberg.zig
+++ b/src/providers/Codeberg.zig
@@ -3,7 +3,7 @@ const http = std.http;
 const json = std.json;
 const Allocator = std.mem.Allocator;
 const ArrayList = std.ArrayList;
-const zeit = @import("zeit");
+const utils = @import("../utils.zig");
 
 const Release = @import("../main.zig").Release;
 const Provider = @import("../Provider.zig");
@@ -235,7 +235,7 @@ fn getRepoReleases(allocator: Allocator, client: *http.Client, token: []const u8
         const release = Release{
             .repo_name = try allocator.dupe(u8, repo),
             .tag_name = try allocator.dupe(u8, tag_name_value.string),
-            .published_at = try allocator.dupe(u8, published_at_value.string),
+            .published_at = try utils.parseReleaseTimestamp(published_at_value.string),
             .html_url = try allocator.dupe(u8, html_url_value.string),
             .description = try allocator.dupe(u8, body_str),
             .provider = try allocator.dupe(u8, "codeberg"),
@@ -249,31 +249,11 @@ fn getRepoReleases(allocator: Allocator, client: *http.Client, token: []const u8
     }
 
     // Sort releases by date (most recent first)
-    std.mem.sort(Release, releases.items, {}, compareReleasesByDate);
+    std.mem.sort(Release, releases.items, {}, utils.compareReleasesByDate);
 
     return releases;
 }
 
-fn compareReleasesByDate(context: void, a: Release, b: Release) bool {
-    _ = context;
-    const timestamp_a = parseTimestamp(a.published_at) catch 0;
-    const timestamp_b = parseTimestamp(b.published_at) catch 0;
-    return timestamp_a > timestamp_b; // Most recent first
-}
-
-fn parseTimestamp(date_str: []const u8) !i64 {
-    // Try parsing as direct timestamp first
-    if (std.fmt.parseInt(i64, date_str, 10)) |timestamp| {
-        return timestamp;
-    } else |_| {
-        // Try parsing as ISO 8601 format using Zeit
-        const instant = zeit.instant(.{
-            .source = .{ .iso8601 = date_str },
-        }) catch return 0;
-        return @intCast(instant.timestamp);
-    }
-}
-
 test "codeberg provider name" {
     const allocator = std.testing.allocator;
     _ = allocator;
@@ -343,7 +323,7 @@ test "codeberg release parsing with live data snapshot" {
     }
 
     // Sort releases by date (most recent first)
-    std.mem.sort(Release, releases.items, {}, compareReleasesByDate);
+    std.mem.sort(Release, releases.items, {}, utils.compareReleasesByDate);
 
     // Verify parsing and sorting
     try std.testing.expectEqual(@as(usize, 3), releases.items.len);
diff --git a/src/providers/GitHub.zig b/src/providers/GitHub.zig
index f5006a8..b119c41 100644
--- a/src/providers/GitHub.zig
+++ b/src/providers/GitHub.zig
@@ -4,7 +4,7 @@ const json = std.json;
 const Allocator = std.mem.Allocator;
 const ArrayList = std.ArrayList;
 const Thread = std.Thread;
-const zeit = @import("zeit");
+const utils = @import("../utils.zig");
 
 const Release = @import("../main.zig").Release;
 const Provider = @import("../Provider.zig");
@@ -53,8 +53,8 @@ pub fn fetchReleases(self: *Self, allocator: Allocator) !ArrayList(Release) {
     }
 
     const starred_duration: u64 = @intCast(starred_end_time - starred_start_time);
-    std.log.debug("GitHub: Found {} starred repositories in {}ms\n", .{ starred_repos.items.len, starred_duration });
-    std.log.debug("GitHub: Processing {} starred repositories with thread pool...\n", .{starred_repos.items.len});
+    std.log.debug("GitHub: Found {} starred repositories in {}ms", .{ starred_repos.items.len, starred_duration });
+    std.log.debug("GitHub: Processing {} starred repositories with thread pool...", .{starred_repos.items.len});
 
     const thread_start_time = std.time.milliTimestamp();
 
@@ -116,6 +116,9 @@ pub fn fetchReleases(self: *Self, allocator: Allocator) !ArrayList(Release) {
     std.log.debug("GitHub: Thread pool completed in {}ms using {} threads ({} successful, {} failed)\n", .{ thread_duration, thread_count, successful_repos, failed_repos });
     std.log.debug("GitHub: Total time (including pagination): {}ms\n", .{total_duration});
 
+    // Sort releases by date (most recent first)
+    std.mem.sort(Release, releases.items, {}, compareReleasesByDate);
+
     return releases;
 }
 
@@ -394,7 +397,7 @@ fn getRepoReleases(allocator: Allocator, client: *http.Client, token: []const u8
         const release = Release{
             .repo_name = try allocator.dupe(u8, repo),
             .tag_name = try allocator.dupe(u8, obj.get("tag_name").?.string),
-            .published_at = try allocator.dupe(u8, obj.get("published_at").?.string),
+            .published_at = try utils.parseReleaseTimestamp(obj.get("published_at").?.string),
             .html_url = try allocator.dupe(u8, obj.get("html_url").?.string),
             .description = try allocator.dupe(u8, body_str),
             .provider = try allocator.dupe(u8, "github"),
@@ -403,30 +406,12 @@ fn getRepoReleases(allocator: Allocator, client: *http.Client, token: []const u8
         try releases.append(release);
     }
 
-    // Sort releases by date (most recent first)
-    std.mem.sort(Release, releases.items, {}, compareReleasesByDate);
-
     return releases;
 }
 
 fn compareReleasesByDate(context: void, a: Release, b: Release) bool {
     _ = context;
-    const timestamp_a = parseTimestamp(a.published_at) catch 0;
-    const timestamp_b = parseTimestamp(b.published_at) catch 0;
-    return timestamp_a > timestamp_b; // Most recent first
-}
-
-fn parseTimestamp(date_str: []const u8) !i64 {
-    // Try parsing as direct timestamp first
-    if (std.fmt.parseInt(i64, date_str, 10)) |timestamp| {
-        return timestamp;
-    } else |_| {
-        // Try parsing as ISO 8601 format using Zeit
-        const instant = zeit.instant(.{
-            .source = .{ .iso8601 = date_str },
-        }) catch return 0;
-        return @intCast(instant.timestamp);
-    }
+    return a.published_at > b.published_at;
 }
 
 test "github provider" {
@@ -497,7 +482,7 @@ test "github release parsing with live data snapshot" {
         const release = Release{
             .repo_name = try allocator.dupe(u8, "example/repo"),
             .tag_name = try allocator.dupe(u8, obj.get("tag_name").?.string),
-            .published_at = try allocator.dupe(u8, obj.get("published_at").?.string),
+            .published_at = try utils.parseReleaseTimestamp(obj.get("published_at").?.string),
             .html_url = try allocator.dupe(u8, obj.get("html_url").?.string),
             .description = try allocator.dupe(u8, body_str),
             .provider = try allocator.dupe(u8, "github"),
@@ -514,6 +499,6 @@ test "github release parsing with live data snapshot" {
     try std.testing.expectEqualStrings("v1.2.0", releases.items[0].tag_name);
     try std.testing.expectEqualStrings("v1.1.0", releases.items[1].tag_name);
     try std.testing.expectEqualStrings("v1.0.0", releases.items[2].tag_name);
-    try std.testing.expectEqualStrings("2024-01-15T10:30:00Z", releases.items[0].published_at);
+    try std.testing.expectEqual(try @import("zeit").instant(.{ .source = .{ .iso8601 = "2024-01-15T10:30:00Z" } }), releases.items[0].published_at);
     try std.testing.expectEqualStrings("github", releases.items[0].provider);
 }
diff --git a/src/providers/GitLab.zig b/src/providers/GitLab.zig
index 7c254a4..651676a 100644
--- a/src/providers/GitLab.zig
+++ b/src/providers/GitLab.zig
@@ -3,7 +3,7 @@ const http = std.http;
 const json = std.json;
 const Allocator = std.mem.Allocator;
 const ArrayList = std.ArrayList;
-const zeit = @import("zeit");
+const utils = @import("../utils.zig");
 
 const Release = @import("../main.zig").Release;
 const Provider = @import("../Provider.zig");
@@ -222,7 +222,7 @@ fn getProjectReleases(allocator: Allocator, client: *http.Client, token: []const
         const release = Release{
             .repo_name = try allocator.dupe(u8, obj.get("name").?.string),
             .tag_name = try allocator.dupe(u8, obj.get("tag_name").?.string),
-            .published_at = try allocator.dupe(u8, obj.get("created_at").?.string),
+            .published_at = try utils.parseReleaseTimestamp(obj.get("created_at").?.string),
             .html_url = try allocator.dupe(u8, obj.get("_links").?.object.get("self").?.string),
             .description = try allocator.dupe(u8, desc_str),
             .provider = try allocator.dupe(u8, "gitlab"),
@@ -236,31 +236,11 @@ fn getProjectReleases(allocator: Allocator, client: *http.Client, token: []const
     }
 
     // Sort releases by date (most recent first)
-    std.mem.sort(Release, releases.items, {}, compareReleasesByDate);
+    std.mem.sort(Release, releases.items, {}, utils.compareReleasesByDate);
 
     return releases;
 }
 
-fn compareReleasesByDate(context: void, a: Release, b: Release) bool {
-    _ = context;
-    const timestamp_a = parseTimestamp(a.published_at) catch 0;
-    const timestamp_b = parseTimestamp(b.published_at) catch 0;
-    return timestamp_a > timestamp_b; // Most recent first
-}
-
-fn parseTimestamp(date_str: []const u8) !i64 {
-    // Try parsing as direct timestamp first
-    if (std.fmt.parseInt(i64, date_str, 10)) |timestamp| {
-        return timestamp;
-    } else |_| {
-        // Try parsing as ISO 8601 format using Zeit
-        const instant = zeit.instant(.{
-            .source = .{ .iso8601 = date_str },
-        }) catch return 0;
-        return @intCast(instant.timestamp);
-    }
-}
-
 test "gitlab provider" {
     const allocator = std.testing.allocator;
 
@@ -348,7 +328,7 @@ test "gitlab release parsing with live data snapshot" {
     }
 
     // Sort releases by date (most recent first)
-    std.mem.sort(Release, releases.items, {}, compareReleasesByDate);
+    std.mem.sort(Release, releases.items, {}, utils.compareReleasesByDate);
 
     // Verify parsing and sorting
     try std.testing.expectEqual(@as(usize, 3), releases.items.len);
diff --git a/src/providers/SourceHut.zig b/src/providers/SourceHut.zig
index 9529522..bddc564 100644
--- a/src/providers/SourceHut.zig
+++ b/src/providers/SourceHut.zig
@@ -3,7 +3,7 @@ const http = std.http;
 const json = std.json;
 const Allocator = std.mem.Allocator;
 const ArrayList = std.ArrayList;
-const zeit = @import("zeit");
+const utils = @import("../utils.zig");
 
 const Release = @import("../main.zig").Release;
 const Provider = @import("../Provider.zig");
@@ -54,7 +54,7 @@ pub fn fetchReleasesForReposFiltered(self: *Self, allocator: Allocator, reposito
     var latest_date: i64 = 0;
     for (existing_releases) |release| {
         if (std.mem.eql(u8, release.provider, "sourcehut")) {
-            const release_time = parseReleaseTimestamp(release.published_at) catch 0;
+            const release_time = utils.parseReleaseTimestamp(release.published_at) catch 0;
             if (release_time > latest_date) {
                 latest_date = release_time;
             }
@@ -153,7 +153,7 @@ fn fetchReleasesMultiRepo(allocator: Allocator, client: *http.Client, token: []c
         const release = Release{
             .repo_name = try std.fmt.allocPrint(allocator, "~{s}/{s}", .{ tag_data.username, tag_data.reponame }),
             .tag_name = try allocator.dupe(u8, tag_data.tag_name),
-            .published_at = try allocator.dupe(u8, commit_date),
+            .published_at = try utils.parseReleaseTimestamp(commit_date),
             .html_url = try std.fmt.allocPrint(allocator, "https://git.sr.ht/~{s}/{s}/refs/{s}", .{ tag_data.username, tag_data.reponame, tag_data.tag_name }),
             .description = try std.fmt.allocPrint(allocator, "Tag {s} (commit: {s})", .{ tag_data.tag_name, tag_data.commit_id }),
             .provider = try allocator.dupe(u8, "sourcehut"),
@@ -166,7 +166,7 @@ fn fetchReleasesMultiRepo(allocator: Allocator, client: *http.Client, token: []c
     }
 
     // Sort releases by date (most recent first)
-    std.mem.sort(Release, releases.items, {}, compareReleasesByDate);
+    std.mem.sort(Release, releases.items, {}, utils.compareReleasesByDate);
 
     return releases;
 }
@@ -567,30 +567,6 @@ fn makeGraphQLRequest(allocator: Allocator, client: *http.Client, token: []const
     return try req.reader().readAllAlloc(allocator, 10 * 1024 * 1024);
 }
 
-fn compareReleasesByDate(context: void, a: Release, b: Release) bool {
-    _ = context;
-    const timestamp_a = parseTimestamp(a.published_at) catch 0;
-    const timestamp_b = parseTimestamp(b.published_at) catch 0;
-    return timestamp_a > timestamp_b; // Most recent first
-}
-
-fn parseReleaseTimestamp(date_str: []const u8) !i64 {
-    return parseTimestamp(date_str);
-}
-
-fn parseTimestamp(date_str: []const u8) !i64 {
-    // Try parsing as direct timestamp first
-    if (std.fmt.parseInt(i64, date_str, 10)) |timestamp| {
-        return timestamp;
-    } else |_| {
-        // Try parsing as ISO 8601 format using Zeit
-        const instant = zeit.instant(.{
-            .source = .{ .iso8601 = date_str },
-        }) catch return 0;
-        return @intCast(instant.timestamp);
-    }
-}
-
 fn filterNewReleases(allocator: Allocator, all_releases: []const Release, since_timestamp: i64) !ArrayList(Release) {
     var new_releases = ArrayList(Release).init(allocator);
     errdefer {
@@ -602,7 +578,7 @@ fn filterNewReleases(allocator: Allocator, all_releases: []const Release, since_
 
     for (all_releases) |release| {
         // Parse the published_at timestamp
-        const release_time = parseReleaseTimestamp(release.published_at) catch continue;
+        const release_time = utils.parseReleaseTimestamp(release.published_at) catch continue;
 
         if (release_time > since_timestamp) {
             // This is a new release, duplicate it for our list
diff --git a/src/timestamp_tests.zig b/src/timestamp_tests.zig
index 577835a..d9ba5b7 100644
--- a/src/timestamp_tests.zig
+++ b/src/timestamp_tests.zig
@@ -1,7 +1,8 @@
 const std = @import("std");
+const zeit = @import("zeit");
 const main = @import("main.zig");
+const utils = @import("utils.zig");
 const config = @import("config.zig");
-const xml_parser = @import("xml_parser.zig");
 
 const Release = main.Release;
 
@@ -46,7 +47,7 @@ test "parseReleaseTimestamp handles edge cases" {
     };
 
     for (test_cases) |test_case| {
-        const result = main.parseReleaseTimestamp(test_case.input) catch 0;
+        const result = utils.parseReleaseTimestamp(test_case.input) catch 0;
         if (test_case.expected_valid) {
             try std.testing.expect(result > 0);
         } else {
@@ -55,147 +56,26 @@ test "parseReleaseTimestamp handles edge cases" {
     }
 
     // Test the special case of "0" timestamp - this should return 0
-    const zero_result = main.parseReleaseTimestamp("0") catch 0;
+    const zero_result = utils.parseReleaseTimestamp("0") catch 0;
     try std.testing.expectEqual(@as(i64, 0), zero_result);
 
     // Test specific known values
-    const known_timestamp = main.parseReleaseTimestamp("1704067200") catch 0;
+    const known_timestamp = utils.parseReleaseTimestamp("1704067200") catch 0;
     try std.testing.expectEqual(@as(i64, 1704067200), known_timestamp);
 
     // Test that date-only format works
-    const date_only_result = main.parseReleaseTimestamp("2024-01-01") catch 0;
+    const date_only_result = utils.parseReleaseTimestamp("2024-01-01") catch 0;
     try std.testing.expectEqual(@as(i64, 1704067200), date_only_result);
 }
 
-test "filterNewReleases with various timestamp scenarios" {
-    const allocator = std.testing.allocator;
-
-    const releases = [_]Release{
-        Release{
-            .repo_name = "test/very-old",
-            .tag_name = "v0.1.0",
-            .published_at = "2023-01-01T00:00:00Z",
-            .html_url = "https://github.com/test/very-old/releases/tag/v0.1.0",
-            .description = "Very old release",
-            .provider = "github",
-        },
-        Release{
-            .repo_name = "test/old",
-            .tag_name = "v1.0.0",
-            .published_at = "2024-01-01T00:00:00Z",
-            .html_url = "https://github.com/test/old/releases/tag/v1.0.0",
-            .description = "Old release",
-            .provider = "github",
-        },
-        Release{
-            .repo_name = "test/recent",
-            .tag_name = "v2.0.0",
-            .published_at = "2024-06-01T00:00:00Z",
-            .html_url = "https://github.com/test/recent/releases/tag/v2.0.0",
-            .description = "Recent release",
-            .provider = "github",
-        },
-        Release{
-            .repo_name = "test/newest",
-            .tag_name = "v3.0.0",
-            .published_at = "2024-12-01T00:00:00Z",
-            .html_url = "https://github.com/test/newest/releases/tag/v3.0.0",
-            .description = "Newest release",
-            .provider = "github",
-        },
-    };
-
-    // Test filtering from beginning of time (should get all)
-    {
-        var filtered = try main.filterNewReleases(allocator, &releases, 0);
-        defer {
-            for (filtered.items) |release| {
-                release.deinit(allocator);
-            }
-            filtered.deinit();
-        }
-        try std.testing.expectEqual(@as(usize, 4), filtered.items.len);
-    }
-
-    // Test filtering from middle of 2024 (should get recent and newest)
-    {
-        const march_2024 = main.parseReleaseTimestamp("2024-03-01T00:00:00Z") catch 0;
-        var filtered = try main.filterNewReleases(allocator, &releases, march_2024);
-        defer {
-            for (filtered.items) |release| {
-                release.deinit(allocator);
-            }
-            filtered.deinit();
-        }
-        try std.testing.expectEqual(@as(usize, 2), filtered.items.len);
-
-        // Should contain recent and newest
-        var found_recent = false;
-        var found_newest = false;
-        for (filtered.items) |release| {
-            if (std.mem.eql(u8, release.repo_name, "test/recent")) {
-                found_recent = true;
-            }
-            if (std.mem.eql(u8, release.repo_name, "test/newest")) {
-                found_newest = true;
-            }
-        }
-        try std.testing.expect(found_recent);
-        try std.testing.expect(found_newest);
-    }
-
-    // Test filtering from future (should get none)
-    {
-        const future = main.parseReleaseTimestamp("2025-01-01T00:00:00Z") catch 0;
-        var filtered = try main.filterNewReleases(allocator, &releases, future);
-        defer {
-            for (filtered.items) |release| {
-                release.deinit(allocator);
-            }
-            filtered.deinit();
-        }
-        try std.testing.expectEqual(@as(usize, 0), filtered.items.len);
-    }
-}
-
-test "XML parsing preserves timestamp precision" {
-    const allocator = std.testing.allocator;
-
-    const precise_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<entry>
-        \\  <title>precise/repo - v1.0.0</title>
-        \\  <link href="https://github.com/precise/repo/releases/tag/v1.0.0"/>
-        \\  <updated>2024-06-15T14:30:45Z</updated>
-        \\  <summary>Precise timestamp test</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    var releases = try xml_parser.parseAtomFeed(allocator, precise_xml);
-    defer {
-        for (releases.items) |release| {
-            release.deinit(allocator);
-        }
-        releases.deinit();
-    }
-
-    try std.testing.expectEqual(@as(usize, 1), releases.items.len);
-    try std.testing.expectEqualStrings("2024-06-15T14:30:45Z", releases.items[0].published_at);
-
-    // Verify the timestamp can be parsed correctly
-    const parsed_timestamp = main.parseReleaseTimestamp(releases.items[0].published_at) catch 0;
-    try std.testing.expect(parsed_timestamp > 0);
-}
-
 test "compareReleasesByDate with various timestamp formats" {
     const release_iso_early = Release{
         .repo_name = "test/iso-early",
         .tag_name = "v1.0.0",
-        .published_at = "2024-01-01T00:00:00Z",
+        .published_at = @intCast(@divTrunc(
+            (try zeit.instant(.{ .source = .{ .iso8601 = "2024-01-01T00:00:00Z" } })).timestamp,
+            std.time.ns_per_s,
+        )),
         .html_url = "https://github.com/test/iso-early/releases/tag/v1.0.0",
         .description = "Early ISO format",
         .provider = "github",
@@ -204,7 +84,10 @@ test "compareReleasesByDate with various timestamp formats" {
     const release_iso_late = Release{
         .repo_name = "test/iso-late",
         .tag_name = "v2.0.0",
-        .published_at = "2024-12-01T00:00:00Z",
+        .published_at = @intCast(@divTrunc(
+            (try zeit.instant(.{ .source = .{ .iso8601 = "2024-12-01T00:00:00Z" } })).timestamp,
+            std.time.ns_per_s,
+        )),
         .html_url = "https://github.com/test/iso-late/releases/tag/v2.0.0",
         .description = "Late ISO format",
         .provider = "github",
@@ -213,17 +96,17 @@ test "compareReleasesByDate with various timestamp formats" {
     const release_invalid = Release{
         .repo_name = "test/invalid",
         .tag_name = "v3.0.0",
-        .published_at = "invalid-date",
+        .published_at = 0,
         .html_url = "https://github.com/test/invalid/releases/tag/v3.0.0",
         .description = "Invalid format",
         .provider = "github",
     };
 
     // Later date should come before earlier date (more recent first)
-    try std.testing.expect(main.compareReleasesByDate({}, release_iso_late, release_iso_early));
-    try std.testing.expect(!main.compareReleasesByDate({}, release_iso_early, release_iso_late));
+    try std.testing.expect(utils.compareReleasesByDate({}, release_iso_late, release_iso_early));
+    try std.testing.expect(!utils.compareReleasesByDate({}, release_iso_early, release_iso_late));
 
     // Invalid timestamps should be treated as 0 and come last
-    try std.testing.expect(main.compareReleasesByDate({}, release_iso_early, release_invalid));
-    try std.testing.expect(main.compareReleasesByDate({}, release_iso_late, release_invalid));
+    try std.testing.expect(utils.compareReleasesByDate({}, release_iso_early, release_invalid));
+    try std.testing.expect(utils.compareReleasesByDate({}, release_iso_late, release_invalid));
 }
diff --git a/src/utils.zig b/src/utils.zig
new file mode 100644
index 0000000..ba9983b
--- /dev/null
+++ b/src/utils.zig
@@ -0,0 +1,73 @@
+const std = @import("std");
+const zeit = @import("zeit");
+const Release = @import("main.zig").Release;
+
+/// Parse a timestamp string into Unix timestamp (seconds since epoch)
+/// Handles both direct integer timestamps and ISO 8601 date strings
+pub fn parseReleaseTimestamp(date_str: []const u8) !i64 {
+    // Try parsing as direct timestamp first
+    if (std.fmt.parseInt(i64, date_str, 10)) |timestamp| {
+        return timestamp;
+    } else |_| {
+        // Try parsing as ISO 8601 format using Zeit
+        const instant = zeit.instant(.{
+            .source = .{ .iso8601 = date_str },
+        }) catch |err| {
+            if (!@import("builtin").is_test)
+                std.log.err("Error parsing date_str: {s}", .{date_str});
+            return err;
+        };
+        // Zeit returns nanoseconds, convert to seconds
+        const seconds = @divTrunc(instant.timestamp, std.time.ns_per_s);
+        return @intCast(seconds);
+    }
+}
+
+test "parseReleaseTimestamp with various formats" {
+    // Test ISO 8601 format
+    const timestamp1 = try parseReleaseTimestamp("2024-01-01T00:00:00Z");
+    try std.testing.expect(timestamp1 > 0);
+
+    // Test direct timestamp
+    const timestamp2 = try parseReleaseTimestamp("1704067200");
+    try std.testing.expectEqual(@as(i64, 1704067200), timestamp2);
+
+    // Test ISO format with milliseconds
+    const timestamp3 = try parseReleaseTimestamp("2024-01-01T12:30:45.123Z");
+    try std.testing.expect(timestamp3 > timestamp1);
+}
+
+pub fn compareReleasesByDate(context: void, a: Release, b: Release) bool {
+    _ = context;
+    return a.published_at > b.published_at; // Most recent first
+}
+
+test "compareReleasesByDate" {
+    const release1 = Release{
+        .repo_name = "test/repo1",
+        .tag_name = "v1.0.0",
+        .published_at = @intCast(@divTrunc(
+            (try zeit.instant(.{ .source = .{ .iso8601 = "2024-01-01T00:00:00Z" } })).timestamp,
+            std.time.ns_per_s,
+        )),
+        .html_url = "https://github.com/test/repo1/releases/tag/v1.0.0",
+        .description = "First release",
+        .provider = "github",
+    };
+
+    const release2 = Release{
+        .repo_name = "test/repo2",
+        .tag_name = "v2.0.0",
+        .published_at = @intCast(@divTrunc(
+            (try zeit.instant(.{ .source = .{ .iso8601 = "2024-01-02T00:00:00Z" } })).timestamp,
+            std.time.ns_per_s,
+        )),
+        .html_url = "https://github.com/test/repo2/releases/tag/v2.0.0",
+        .description = "Second release",
+        .provider = "github",
+    };
+
+    // release2 should come before release1 (more recent first)
+    try std.testing.expect(compareReleasesByDate({}, release2, release1));
+    try std.testing.expect(!compareReleasesByDate({}, release1, release2));
+}
diff --git a/src/xml_parser.zig b/src/xml_parser.zig
deleted file mode 100644
index 1155d58..0000000
--- a/src/xml_parser.zig
+++ /dev/null
@@ -1,335 +0,0 @@
-const std = @import("std");
-const Allocator = std.mem.Allocator;
-const ArrayList = std.ArrayList;
-
-const Release = @import("main.zig").Release;
-
-pub const ParseError = error{
-    InvalidXml,
-    MalformedEntry,
-    OutOfMemory,
-};
-
-pub fn parseAtomFeed(allocator: Allocator, xml_content: []const u8) !ArrayList(Release) {
-    var releases = ArrayList(Release).init(allocator);
-    errdefer {
-        for (releases.items) |release| {
-            release.deinit(allocator);
-        }
-        releases.deinit();
-    }
-
-    var entry_start: ?usize = null;
-    var pos: usize = 0;
-
-    while (pos < xml_content.len) {
-        // Find next entry
-        if (std.mem.indexOf(u8, xml_content[pos..], "<entry>")) |entry_offset| {
-            entry_start = pos + entry_offset;
-            pos = entry_start.? + 7; // Move past "<entry>"
-
-            // Find the end of this entry
-            if (std.mem.indexOf(u8, xml_content[pos..], "</entry>")) |end_offset| {
-                const entry_end = pos + end_offset;
-                const entry_content = xml_content[entry_start.? .. entry_end + 8]; // Include "</entry>"
-
-                if (parseEntry(allocator, entry_content)) |release| {
-                    try releases.append(release);
-                } else |err| {
-                    const stderr = std.io.getStdErr().writer();
-                    stderr.print("Warning: Failed to parse entry: {}\n", .{err}) catch {};
-                }
-
-                pos = entry_end + 8; // Move past "</entry>"
-            } else {
-                break; // No closing tag found
-            }
-        } else {
-            break; // No more entries
-        }
-    }
-
-    return releases;
-}
-
-fn parseEntry(allocator: Allocator, entry_xml: []const u8) !Release {
-    var release = Release{
-        .repo_name = try allocator.dupe(u8, ""),
-        .tag_name = try allocator.dupe(u8, ""),
-        .published_at = try allocator.dupe(u8, ""),
-        .html_url = try allocator.dupe(u8, ""),
-        .description = try allocator.dupe(u8, ""),
-        .provider = try allocator.dupe(u8, ""),
-    };
-    errdefer release.deinit(allocator);
-
-    // Parse title to extract repo_name and tag_name
-    if (extractTagContent(entry_xml, "title", allocator)) |title| {
-        defer allocator.free(title);
-        if (std.mem.lastIndexOf(u8, title, " - ")) |dash_pos| {
-            allocator.free(release.repo_name);
-            allocator.free(release.tag_name);
-            release.repo_name = try allocator.dupe(u8, title[0..dash_pos]);
-            release.tag_name = try allocator.dupe(u8, title[dash_pos + 3 ..]);
-        }
-    }
-
-    // Parse link href attribute
-    if (extractLinkHref(entry_xml, allocator)) |url| {
-        allocator.free(release.html_url);
-        release.html_url = url;
-    }
-
-    // Parse updated timestamp
-    if (extractTagContent(entry_xml, "updated", allocator)) |updated| {
-        allocator.free(release.published_at);
-        release.published_at = updated;
-    }
-
-    // Parse content (description) - try content first, then fall back to summary
-    if (extractTagContent(entry_xml, "content", allocator)) |content| {
-        allocator.free(release.description);
-        release.description = content;
-    } else if (extractTagContent(entry_xml, "summary", allocator)) |summary| {
-        allocator.free(release.description);
-        release.description = summary;
-    }
-
-    // Parse category term attribute (provider)
-    if (extractCategoryTerm(entry_xml, allocator)) |provider| {
-        allocator.free(release.provider);
-        release.provider = provider;
-    }
-
-    return release;
-}
-
-fn extractTagContent(xml: []const u8, tag_name: []const u8, allocator: Allocator) ?[]u8 {
-    const open_tag = std.fmt.allocPrint(allocator, "<{s}>", .{tag_name}) catch return null;
-    defer allocator.free(open_tag);
-    const close_tag = std.fmt.allocPrint(allocator, "</{s}>", .{tag_name}) catch return null;
-    defer allocator.free(close_tag);
-
-    if (std.mem.indexOf(u8, xml, open_tag)) |start_pos| {
-        const content_start = start_pos + open_tag.len;
-        if (std.mem.indexOf(u8, xml[content_start..], close_tag)) |end_offset| {
-            const content_end = content_start + end_offset;
-            const content = xml[content_start..content_end];
-            return unescapeXml(allocator, content) catch null;
-        }
-    }
-
-    // Also try with attributes (e.g., <content type="html">)
-    const open_tag_with_attrs = std.fmt.allocPrint(allocator, "<{s} ", .{tag_name}) catch return null;
-    defer allocator.free(open_tag_with_attrs);
-
-    if (std.mem.indexOf(u8, xml, open_tag_with_attrs)) |start_pos| {
-        // Find the end of the opening tag
-        if (std.mem.indexOf(u8, xml[start_pos..], ">")) |tag_end_offset| {
-            const content_start = start_pos + tag_end_offset + 1;
-            if (std.mem.indexOf(u8, xml[content_start..], close_tag)) |end_offset| {
-                const content_end = content_start + end_offset;
-                const content = xml[content_start..content_end];
-                return unescapeXml(allocator, content) catch null;
-            }
-        }
-    }
-
-    return null;
-}
-
-fn extractLinkHref(xml: []const u8, allocator: Allocator) ?[]u8 {
-    const pattern = "<link href=\"";
-    if (std.mem.indexOf(u8, xml, pattern)) |start_pos| {
-        const content_start = start_pos + pattern.len;
-        if (std.mem.indexOf(u8, xml[content_start..], "\"")) |end_offset| {
-            const content_end = content_start + end_offset;
-            const href = xml[content_start..content_end];
-            return allocator.dupe(u8, href) catch null;
-        }
-    }
-    return null;
-}
-
-fn extractCategoryTerm(xml: []const u8, allocator: Allocator) ?[]u8 {
-    const pattern = "<category term=\"";
-    if (std.mem.indexOf(u8, xml, pattern)) |start_pos| {
-        const content_start = start_pos + pattern.len;
-        if (std.mem.indexOf(u8, xml[content_start..], "\"")) |end_offset| {
-            const content_end = content_start + end_offset;
-            const term = xml[content_start..content_end];
-            return allocator.dupe(u8, term) catch null;
-        }
-    }
-    return null;
-}
-
-fn unescapeXml(allocator: Allocator, input: []const u8) ![]u8 {
-    var result = ArrayList(u8).init(allocator);
-    defer result.deinit();
-
-    var i: usize = 0;
-    while (i < input.len) {
-        if (input[i] == '&') {
-            if (std.mem.startsWith(u8, input[i..], "&lt;")) {
-                try result.append('<');
-                i += 4;
-            } else if (std.mem.startsWith(u8, input[i..], "&gt;")) {
-                try result.append('>');
-                i += 4;
-            } else if (std.mem.startsWith(u8, input[i..], "&amp;")) {
-                try result.append('&');
-                i += 5;
-            } else if (std.mem.startsWith(u8, input[i..], "&quot;")) {
-                try result.append('"');
-                i += 6;
-            } else if (std.mem.startsWith(u8, input[i..], "&apos;")) {
-                try result.append('\'');
-                i += 6;
-            } else {
-                try result.append(input[i]);
-                i += 1;
-            }
-        } else {
-            try result.append(input[i]);
-            i += 1;
-        }
-    }
-
-    return result.toOwnedSlice();
-}
-
-// Tests
-test "parse simple atom entry" {
-    const allocator = std.testing.allocator;
-
-    const entry_xml =
-        \\<entry>
-        \\  <title>test/repo - v1.0.0</title>
-        \\  <link href="https://github.com/test/repo/releases/tag/v1.0.0"/>
-        \\  <id>https://github.com/test/repo/releases/tag/v1.0.0</id>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <author><n>github</n></author>
-        \\  <summary>Test release</summary>
-        \\  <category term="github"/>
-        \\</entry>
-    ;
-
-    const release = try parseEntry(allocator, entry_xml);
-    defer release.deinit(allocator);
-
-    try std.testing.expectEqualStrings("test/repo", release.repo_name);
-    try std.testing.expectEqualStrings("v1.0.0", release.tag_name);
-    try std.testing.expectEqualStrings("https://github.com/test/repo/releases/tag/v1.0.0", release.html_url);
-    try std.testing.expectEqualStrings("2024-01-01T00:00:00Z", release.published_at);
-    try std.testing.expectEqualStrings("Test release", release.description);
-    try std.testing.expectEqualStrings("github", release.provider);
-}
-
-test "parse atom entry with escaped characters" {
-    const allocator = std.testing.allocator;
-
-    const entry_xml =
-        \\<entry>
-        \\  <title>test/repo&lt;script&gt; - v1.0.0 &amp; more</title>
-        \\  <link href="https://github.com/test/repo/releases/tag/v1.0.0"/>
-        \\  <id>https://github.com/test/repo/releases/tag/v1.0.0</id>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <author><n>github</n></author>
-        \\  <summary>Test &quot;release&quot; with &lt;special&gt; chars &amp; symbols</summary>
-        \\  <category term="github"/>
-        \\</entry>
-    ;
-
-    const release = try parseEntry(allocator, entry_xml);
-    defer release.deinit(allocator);
-
-    try std.testing.expectEqualStrings("test/repo<script>", release.repo_name);
-    try std.testing.expectEqualStrings("v1.0.0 & more", release.tag_name);
-    try std.testing.expectEqualStrings("Test \"release\" with <special> chars & symbols", release.description);
-}
-
-test "parse full atom feed" {
-    const allocator = std.testing.allocator;
-
-    const atom_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<subtitle>New releases from starred repositories</subtitle>
-        \\<link href="https://github.com" rel="alternate"/>
-        \\<link href="https://example.com/releases.xml" rel="self"/>
-        \\<id>https://example.com/releases</id>
-        \\<updated>2024-01-01T00:00:00Z</updated>
-        \\<entry>
-        \\  <title>test/repo1 - v1.0.0</title>
-        \\  <link href="https://github.com/test/repo1/releases/tag/v1.0.0"/>
-        \\  <id>https://github.com/test/repo1/releases/tag/v1.0.0</id>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <author><n>github</n></author>
-        \\  <summary>First release</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\<entry>
-        \\  <title>test/repo2 - v2.0.0</title>
-        \\  <link href="https://github.com/test/repo2/releases/tag/v2.0.0"/>
-        \\  <id>https://github.com/test/repo2/releases/tag/v2.0.0</id>
-        \\  <updated>2024-01-02T00:00:00Z</updated>
-        \\  <author><n>github</n></author>
-        \\  <summary>Second release</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    var releases = try parseAtomFeed(allocator, atom_xml);
-    defer {
-        for (releases.items) |release| {
-            release.deinit(allocator);
-        }
-        releases.deinit();
-    }
-
-    try std.testing.expectEqual(@as(usize, 2), releases.items.len);
-
-    try std.testing.expectEqualStrings("test/repo1", releases.items[0].repo_name);
-    try std.testing.expectEqualStrings("v1.0.0", releases.items[0].tag_name);
-    try std.testing.expectEqualStrings("First release", releases.items[0].description);
-
-    try std.testing.expectEqualStrings("test/repo2", releases.items[1].repo_name);
-    try std.testing.expectEqualStrings("v2.0.0", releases.items[1].tag_name);
-    try std.testing.expectEqualStrings("Second release", releases.items[1].description);
-}
-
-test "XML unescaping" {
-    const allocator = std.testing.allocator;
-
-    const input = "Test &lt;tag&gt; &amp; &quot;quotes&quot; &amp; &apos;apostrophes&apos;";
-    const result = try unescapeXml(allocator, input);
-    defer allocator.free(result);
-
-    const expected = "Test <tag> & \"quotes\" & 'apostrophes'";
-    try std.testing.expectEqualStrings(expected, result);
-}
-
-test "parse entry with missing fields" {
-    const allocator = std.testing.allocator;
-
-    const entry_xml =
-        \\<entry>
-        \\  <title>test/repo - v1.0.0</title>
-        \\  <link href="https://github.com/test/repo/releases/tag/v1.0.0"/>
-        \\</entry>
-    ;
-
-    const release = try parseEntry(allocator, entry_xml);
-    defer release.deinit(allocator);
-
-    try std.testing.expectEqualStrings("test/repo", release.repo_name);
-    try std.testing.expectEqualStrings("v1.0.0", release.tag_name);
-    try std.testing.expectEqualStrings("https://github.com/test/repo/releases/tag/v1.0.0", release.html_url);
-    // Missing fields should be empty strings
-    try std.testing.expectEqualStrings("", release.published_at);
-    try std.testing.expectEqualStrings("", release.description);
-    try std.testing.expectEqualStrings("", release.provider);
-}
diff --git a/src/xml_parser_tests.zig b/src/xml_parser_tests.zig
deleted file mode 100644
index cc1bad8..0000000
--- a/src/xml_parser_tests.zig
+++ /dev/null
@@ -1,285 +0,0 @@
-const std = @import("std");
-const testing = std.testing;
-
-const xml_parser = @import("xml_parser.zig");
-const atom = @import("atom.zig");
-const Release = @import("main.zig").Release;
-
-test "round trip: generate atom feed and parse it back" {
-    const allocator = testing.allocator;
-
-    // Create test releases
-    const original_releases = [_]Release{
-        Release{
-            .repo_name = "test/repo1",
-            .tag_name = "v1.0.0",
-            .published_at = "2024-01-01T00:00:00Z",
-            .html_url = "https://github.com/test/repo1/releases/tag/v1.0.0",
-            .description = "First release",
-            .provider = "github",
-        },
-        Release{
-            .repo_name = "test/repo2",
-            .tag_name = "v2.0.0",
-            .published_at = "2024-01-02T00:00:00Z",
-            .html_url = "https://github.com/test/repo2/releases/tag/v2.0.0",
-            .description = "Second release",
-            .provider = "github",
-        },
-    };
-
-    // Generate atom feed
-    const atom_content = try atom.generateFeed(allocator, &original_releases);
-    defer allocator.free(atom_content);
-
-    // Parse it back
-    var parsed_releases = try xml_parser.parseAtomFeed(allocator, atom_content);
-    defer {
-        for (parsed_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        parsed_releases.deinit();
-    }
-
-    // Verify we got the same data back
-    try testing.expectEqual(@as(usize, 2), parsed_releases.items.len);
-
-    try testing.expectEqualStrings("test/repo1", parsed_releases.items[0].repo_name);
-    try testing.expectEqualStrings("v1.0.0", parsed_releases.items[0].tag_name);
-    try testing.expectEqualStrings("2024-01-01T00:00:00Z", parsed_releases.items[0].published_at);
-    try testing.expectEqualStrings("https://github.com/test/repo1/releases/tag/v1.0.0", parsed_releases.items[0].html_url);
-    try testing.expectEqualStrings("<p>First release</p>\n", parsed_releases.items[0].description);
-    try testing.expectEqualStrings("github", parsed_releases.items[0].provider);
-
-    try testing.expectEqualStrings("test/repo2", parsed_releases.items[1].repo_name);
-    try testing.expectEqualStrings("v2.0.0", parsed_releases.items[1].tag_name);
-    try testing.expectEqualStrings("2024-01-02T00:00:00Z", parsed_releases.items[1].published_at);
-    try testing.expectEqualStrings("https://github.com/test/repo2/releases/tag/v2.0.0", parsed_releases.items[1].html_url);
-    try testing.expectEqualStrings("<p>Second release</p>\n", parsed_releases.items[1].description);
-    try testing.expectEqualStrings("github", parsed_releases.items[1].provider);
-}
-
-test "parse atom feed with special characters" {
-    const allocator = testing.allocator;
-
-    // Create releases with special characters
-    const original_releases = [_]Release{
-        Release{
-            .repo_name = "test/repo<script>",
-            .tag_name = "v1.0.0 & more",
-            .published_at = "2024-01-01T00:00:00Z",
-            .html_url = "https://github.com/test/repo/releases/tag/v1.0.0",
-            .description = "Test \"release\" with <special> chars & symbols",
-            .provider = "github",
-        },
-    };
-
-    // Generate atom feed (this should escape the characters)
-    const atom_content = try atom.generateFeed(allocator, &original_releases);
-    defer allocator.free(atom_content);
-
-    // Verify the XML contains escaped characters in the title (not in content)
-    try testing.expect(std.mem.indexOf(u8, atom_content, "&lt;script&gt;") != null);
-    try testing.expect(std.mem.indexOf(u8, atom_content, "&amp; more") != null);
-    // The content will be XML-escaped HTML, so quotes in HTML will be &amp;quot;
-    try testing.expect(std.mem.indexOf(u8, atom_content, "&amp;quot;release&amp;quot;") != null);
-
-    // Parse it back (this should unescape the characters)
-    var parsed_releases = try xml_parser.parseAtomFeed(allocator, atom_content);
-    defer {
-        for (parsed_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        parsed_releases.deinit();
-    }
-
-    // Verify the parsed data has the original unescaped characters
-    try testing.expectEqual(@as(usize, 1), parsed_releases.items.len);
-    try testing.expectEqualStrings("test/repo<script>", parsed_releases.items[0].repo_name);
-    try testing.expectEqualStrings("v1.0.0 & more", parsed_releases.items[0].tag_name);
-    try testing.expectEqualStrings("<pre>Test &quot;release&quot; with &lt;special&gt; chars &amp; symbols</pre>\n", parsed_releases.items[0].description);
-}
-
-test "parse malformed atom feed gracefully" {
-    const allocator = testing.allocator;
-
-    const malformed_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<entry>
-        \\  <title>test/repo1 - v1.0.0</title>
-        \\  <link href="https://github.com/test/repo1/releases/tag/v1.0.0"/>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <summary>Good entry</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\<entry>
-        \\  <title>test/repo2 - v2.0.0</title>
-        \\  <!-- Missing closing entry tag -->
-        \\<entry>
-        \\  <title>test/repo3 - v3.0.0</title>
-        \\  <link href="https://github.com/test/repo3/releases/tag/v3.0.0"/>
-        \\  <updated>2024-01-03T00:00:00Z</updated>
-        \\  <summary>Another good entry</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    var parsed_releases = try xml_parser.parseAtomFeed(allocator, malformed_xml);
-    defer {
-        for (parsed_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        parsed_releases.deinit();
-    }
-
-    // Should parse the valid entries and skip the malformed one
-    // Note: The malformed entry (repo2) will be parsed but will contain mixed content
-    // The parser finds the first closing </entry> tag which belongs to repo3
-    try testing.expectEqual(@as(usize, 2), parsed_releases.items.len);
-    try testing.expectEqualStrings("test/repo1", parsed_releases.items[0].repo_name);
-    try testing.expectEqualStrings("test/repo2", parsed_releases.items[1].repo_name); // This gets the first title found
-}
-
-test "parse empty atom feed" {
-    const allocator = testing.allocator;
-
-    const empty_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<subtitle>New releases from starred repositories</subtitle>
-        \\<link href="https://github.com" rel="alternate"/>
-        \\<link href="https://example.com/releases.xml" rel="self"/>
-        \\<id>https://example.com/releases</id>
-        \\<updated>2024-01-01T00:00:00Z</updated>
-        \\</feed>
-    ;
-
-    var parsed_releases = try xml_parser.parseAtomFeed(allocator, empty_xml);
-    defer parsed_releases.deinit();
-
-    try testing.expectEqual(@as(usize, 0), parsed_releases.items.len);
-}
-
-test "parse atom feed with multiline summaries" {
-    const allocator = testing.allocator;
-
-    const multiline_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<entry>
-        \\  <title>test/repo - v1.0.0</title>
-        \\  <link href="https://github.com/test/repo/releases/tag/v1.0.0"/>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <summary>This is a multiline
-        \\summary with line breaks
-        \\and multiple paragraphs</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    var parsed_releases = try xml_parser.parseAtomFeed(allocator, multiline_xml);
-    defer {
-        for (parsed_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        parsed_releases.deinit();
-    }
-
-    try testing.expectEqual(@as(usize, 1), parsed_releases.items.len);
-    const expected_summary = "This is a multiline\nsummary with line breaks\nand multiple paragraphs";
-    try testing.expectEqualStrings(expected_summary, parsed_releases.items[0].description);
-}
-
-test "parse atom feed with different providers" {
-    const allocator = testing.allocator;
-
-    const multi_provider_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<title>Repository Releases</title>
-        \\<entry>
-        \\  <title>github/repo - v1.0.0</title>
-        \\  <link href="https://github.com/github/repo/releases/tag/v1.0.0"/>
-        \\  <updated>2024-01-01T00:00:00Z</updated>
-        \\  <summary>GitHub release</summary>
-        \\  <category term="github"/>
-        \\</entry>
-        \\<entry>
-        \\  <title>gitlab/repo - v2.0.0</title>
-        \\  <link href="https://gitlab.com/gitlab/repo/-/releases/v2.0.0"/>
-        \\  <updated>2024-01-02T00:00:00Z</updated>
-        \\  <summary>GitLab release</summary>
-        \\  <category term="gitlab"/>
-        \\</entry>
-        \\<entry>
-        \\  <title>codeberg/repo - v3.0.0</title>
-        \\  <link href="https://codeberg.org/codeberg/repo/releases/tag/v3.0.0"/>
-        \\  <updated>2024-01-03T00:00:00Z</updated>
-        \\  <summary>Codeberg release</summary>
-        \\  <category term="codeberg"/>
-        \\</entry>
-        \\<entry>
-        \\  <title>~user/repo - v4.0.0</title>
-        \\  <link href="https://git.sr.ht/~user/repo/refs/v4.0.0"/>
-        \\  <updated>2024-01-04T00:00:00Z</updated>
-        \\  <summary>SourceHut release</summary>
-        \\  <category term="sourcehut"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    var parsed_releases = try xml_parser.parseAtomFeed(allocator, multi_provider_xml);
-    defer {
-        for (parsed_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        parsed_releases.deinit();
-    }
-
-    try testing.expectEqual(@as(usize, 4), parsed_releases.items.len);
-
-    try testing.expectEqualStrings("github", parsed_releases.items[0].provider);
-    try testing.expectEqualStrings("gitlab", parsed_releases.items[1].provider);
-    try testing.expectEqualStrings("codeberg", parsed_releases.items[2].provider);
-    try testing.expectEqualStrings("sourcehut", parsed_releases.items[3].provider);
-}
-
-test "parse atom feed with missing optional fields" {
-    const allocator = testing.allocator;
-
-    const minimal_xml =
-        \\<?xml version="1.0" encoding="UTF-8"?>
-        \\<feed xmlns="http://www.w3.org/2005/Atom">
-        \\<entry>
-        \\  <title>test/repo - v1.0.0</title>
-        \\  <link href="https://github.com/test/repo/releases/tag/v1.0.0"/>
-        \\</entry>
-        \\</feed>
-    ;
-
-    var parsed_releases = try xml_parser.parseAtomFeed(allocator, minimal_xml);
-    defer {
-        for (parsed_releases.items) |release| {
-            release.deinit(allocator);
-        }
-        parsed_releases.deinit();
-    }
-
-    try testing.expectEqual(@as(usize, 1), parsed_releases.items.len);
-
-    const release = parsed_releases.items[0];
-    try testing.expectEqualStrings("test/repo", release.repo_name);
-    try testing.expectEqualStrings("v1.0.0", release.tag_name);
-    try testing.expectEqualStrings("https://github.com/test/repo/releases/tag/v1.0.0", release.html_url);
-
-    // Missing fields should be empty strings
-    try testing.expectEqualStrings("", release.published_at);
-    try testing.expectEqualStrings("", release.description);
-    try testing.expectEqualStrings("", release.provider);
-}