Speed up version client by partial response reads

.github/workflows/test.yml

@@ -27,7 +27,7 @@ jobs:
       - name: Actionlint
         uses: eifinger/actionlint-action@7802e0cc3ab3f81cbffb36fb0bf1a3621d994b89 # v1.10.1
       - name: Run zizmor
-        uses: zizmorcore/zizmor-action@71321a20a9ded102f6e9ce5718a2fcec2c4f70d8 # v0.5.2
+        uses: zizmorcore/zizmor-action@0dce2577a4760a2749d8cfb7a84b7d5585ebcb7d # v0.5.0
       - uses: actions/setup-node@53b83947a5a98c8d113130e565377fae1a50d02f # v6.3.0
         with:
           node-version-file: .nvmrc
@@ -164,21 +164,9 @@ jobs:
       - name: Latest version gets installed
         run: |
           LATEST_VERSION=$(gh api -H "Accept: application/vnd.github+json" -H "X-GitHub-Api-Version: 2022-11-28" /repos/astral-sh/uv/releases/latest | jq -r '.tag_name')
-          UV_VERSION_OUTPUT=$(uv --version)
-
-          if [[ ! "$UV_VERSION_OUTPUT" =~ ^uv[[:space:]]+([^[:space:]]+) ]]; then
-            echo "Could not parse uv version from: $UV_VERSION_OUTPUT"
-            exit 1
-          fi
-
-          UV_VERSION="${BASH_REMATCH[1]}"
-
           echo "Latest version is $LATEST_VERSION"
-          echo "uv --version output is $UV_VERSION_OUTPUT"
+          if [ "$(uv --version)" != "uv $LATEST_VERSION" ]; then
-          echo "Parsed uv version is $UV_VERSION"
+              echo "Wrong uv version: $(uv --version)"
-
-          if [ "$UV_VERSION" != "$LATEST_VERSION" ]; then
-            echo "Wrong uv version: $UV_VERSION_OUTPUT"
               exit 1
           fi
         env:
@@ -808,12 +796,12 @@ jobs:
       - name: Install from custom manifest file
         uses: ./
         with:
-          manifest-file: "https://raw.githubusercontent.com/astral-sh/setup-uv/${{ github.ref }}/__tests__/download/custom-manifest.ndjson"
+          manifest-file: "https://raw.githubusercontent.com/astral-sh/setup-uv/${{ github.ref }}/__tests__/download/custom-manifest.json"
       - run: uv sync
         working-directory: __tests__/fixtures/uv-project
       - name: Correct version gets installed
         run: |
-          if [ "$(uv --version)" != "uv 0.9.26" ]; then
+          if [ "$(uv --version)" != "uv 0.7.12-alpha.1" ]; then
             echo "Wrong uv version: $(uv --version)"
             exit 1
           fi

README.md

@@ -114,7 +114,7 @@ Have a look under [Advanced Configuration](#advanced-configuration) for detailed
     # Custom path to set UV_TOOL_BIN_DIR to
     tool-bin-dir: ""
 
-    # URL to a custom manifest file in the astral-sh/versions format
+    # URL to a custom manifest file (NDJSON preferred, legacy JSON array is deprecated)
     manifest-file: ""
 
     # Add problem matchers
@@ -190,8 +190,8 @@ For more advanced configuration options, see our detailed documentation:
 
 ## How it works
 
-By default, this action resolves uv versions from the
+By default, this action resolves uv versions from
-[`astral-sh/versions`](https://github.com/astral-sh/versions) manifest and downloads uv from the
+[`astral-sh/versions`](https://github.com/astral-sh/versions) (NDJSON) and downloads uv from the
 official [GitHub Releases](https://github.com/astral-sh/uv).
 
 It then uses the [GitHub Actions Toolkit](https://github.com/actions/toolkit) to cache uv as a

__tests__/download/custom-manifest.json

@@ -0,0 +1,9 @@
+[
+  {
+    "arch": "x86_64",
+    "artifactName": "uv-x86_64-unknown-linux-gnu.tar.gz",
+    "downloadUrl": "https://release.pyx.dev/0.7.12-alpha.1/uv-x86_64-unknown-linux-gnu.tar.gz",
+    "platform": "unknown-linux-gnu",
+    "version": "0.7.12-alpha.1"
+  }
+]

__tests__/download/custom-manifest.ndjson

@@ -1 +0,0 @@
-{"version":"0.9.26","artifacts":[{"platform":"x86_64-unknown-linux-gnu","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz","archive_format":"tar.gz","sha256":"30ccbf0a66dc8727a02b0e245c583ee970bdafecf3a443c1686e1b30ec4939e8"}]}

__tests__/download/download-version.test.ts

@@ -32,16 +32,32 @@ jest.unstable_mockModule("@actions/tool-cache", () => ({
 }));
 
 // biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
-const mockGetLatestVersion = jest.fn<any>();
+const mockGetLatestVersionFromNdjson = jest.fn<any>();
 // biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
-const mockGetAllVersions = jest.fn<any>();
+const mockGetAllVersionsFromNdjson = jest.fn<any>();
 // biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
-const mockGetArtifact = jest.fn<any>();
+const mockGetArtifactFromNdjson = jest.fn<any>();
+// biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
+const mockGetHighestSatisfyingVersionFromNdjson = jest.fn<any>();
 
-jest.unstable_mockModule("../../src/download/manifest", () => ({
+jest.unstable_mockModule("../../src/download/versions-client", () => ({
-  getAllVersions: mockGetAllVersions,
+  getAllVersions: mockGetAllVersionsFromNdjson,
-  getArtifact: mockGetArtifact,
+  getArtifact: mockGetArtifactFromNdjson,
-  getLatestVersion: mockGetLatestVersion,
+  getHighestSatisfyingVersion: mockGetHighestSatisfyingVersionFromNdjson,
+  getLatestVersion: mockGetLatestVersionFromNdjson,
+}));
+
+// biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
+const mockGetAllManifestVersions = jest.fn<any>();
+// biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
+const mockGetLatestVersionInManifest = jest.fn<any>();
+// biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
+const mockGetManifestArtifact = jest.fn<any>();
+
+jest.unstable_mockModule("../../src/download/version-manifest", () => ({
+  getAllVersions: mockGetAllManifestVersions,
+  getLatestKnownVersion: mockGetLatestVersionInManifest,
+  getManifestArtifact: mockGetManifestArtifact,
 }));
 
 // biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
@@ -51,9 +67,11 @@ jest.unstable_mockModule("../../src/download/checksum/checksum", () => ({
   validateChecksum: mockValidateChecksum,
 }));
 
-const { downloadVersion, resolveVersion, rewriteToMirror } = await import(
+const {
-  "../../src/download/download-version"
+  downloadVersionFromManifest,
-);
+  downloadVersionFromNdjson,
+  resolveVersion,
+} = await import("../../src/download/download-version");
 
 describe("download-version", () => {
   beforeEach(() => {
@@ -63,9 +81,13 @@ describe("download-version", () => {
     mockExtractTar.mockReset();
     mockExtractZip.mockReset();
     mockCacheDir.mockReset();
-    mockGetLatestVersion.mockReset();
+    mockGetLatestVersionFromNdjson.mockReset();
-    mockGetAllVersions.mockReset();
+    mockGetAllVersionsFromNdjson.mockReset();
-    mockGetArtifact.mockReset();
+    mockGetArtifactFromNdjson.mockReset();
+    mockGetHighestSatisfyingVersionFromNdjson.mockReset();
+    mockGetAllManifestVersions.mockReset();
+    mockGetLatestVersionInManifest.mockReset();
+    mockGetManifestArtifact.mockReset();
     mockValidateChecksum.mockReset();
 
     mockDownloadTool.mockResolvedValue("/tmp/downloaded");
@@ -75,28 +97,49 @@ describe("download-version", () => {
   });
 
   describe("resolveVersion", () => {
-    it("uses the default manifest to resolve latest", async () => {
+    it("uses astral-sh/versions to resolve latest", async () => {
-      mockGetLatestVersion.mockResolvedValue("0.9.26");
+      mockGetLatestVersionFromNdjson.mockResolvedValue("0.9.26");
 
       const version = await resolveVersion("latest", undefined);
 
       expect(version).toBe("0.9.26");
-      expect(mockGetLatestVersion).toHaveBeenCalledTimes(1);
+      expect(mockGetLatestVersionFromNdjson).toHaveBeenCalledTimes(1);
-      expect(mockGetLatestVersion).toHaveBeenCalledWith(undefined);
     });
 
-    it("uses the default manifest to resolve available versions", async () => {
+    it("streams astral-sh/versions to resolve the highest matching version", async () => {
-      mockGetAllVersions.mockResolvedValue(["0.9.26", "0.9.25"]);
+      mockGetHighestSatisfyingVersionFromNdjson.mockResolvedValue("0.9.26");
 
       const version = await resolveVersion("^0.9.0", undefined);
 
       expect(version).toBe("0.9.26");
-      expect(mockGetAllVersions).toHaveBeenCalledTimes(1);
+      expect(mockGetHighestSatisfyingVersionFromNdjson).toHaveBeenCalledWith(
-      expect(mockGetAllVersions).toHaveBeenCalledWith(undefined);
+        "^0.9.0",
+      );
+      expect(mockGetAllVersionsFromNdjson).not.toHaveBeenCalled();
+    });
+
+    it("still loads all versions when resolving the lowest matching version", async () => {
+      mockGetAllVersionsFromNdjson.mockResolvedValue(["0.9.26", "0.9.25"]);
+
+      const version = await resolveVersion("^0.9.0", undefined, "lowest");
+
+      expect(version).toBe("0.9.25");
+      expect(mockGetAllVersionsFromNdjson).toHaveBeenCalledTimes(1);
+      expect(mockGetHighestSatisfyingVersionFromNdjson).not.toHaveBeenCalled();
+    });
+
+    it("does not fall back when astral-sh/versions fails", async () => {
+      mockGetLatestVersionFromNdjson.mockRejectedValue(
+        new Error("NDJSON unavailable"),
+      );
+
+      await expect(resolveVersion("latest", undefined)).rejects.toThrow(
+        "NDJSON unavailable",
+      );
     });
 
     it("uses manifest-file when provided", async () => {
-      mockGetAllVersions.mockResolvedValue(["0.9.26", "0.9.25"]);
+      mockGetAllManifestVersions.mockResolvedValue(["0.9.26", "0.9.25"]);
 
       const version = await resolveVersion(
         "^0.9.0",
@@ -104,35 +147,37 @@ describe("download-version", () => {
       );
 
       expect(version).toBe("0.9.26");
-      expect(mockGetAllVersions).toHaveBeenCalledWith(
+      expect(mockGetAllManifestVersions).toHaveBeenCalledWith(
         "https://example.com/custom.ndjson",
       );
     });
   });
 
-  describe("downloadVersion", () => {
+  describe("downloadVersionFromNdjson", () => {
-    it("fails when manifest lookup fails", async () => {
+    it("fails when NDJSON metadata lookup fails", async () => {
-      mockGetArtifact.mockRejectedValue(new Error("manifest unavailable"));
+      mockGetArtifactFromNdjson.mockRejectedValue(
+        new Error("NDJSON unavailable"),
+      );
 
       await expect(
-        downloadVersion(
+        downloadVersionFromNdjson(
           "unknown-linux-gnu",
           "x86_64",
           "0.9.26",
           undefined,
           "token",
         ),
-      ).rejects.toThrow("manifest unavailable");
+      ).rejects.toThrow("NDJSON unavailable");
 
       expect(mockDownloadTool).not.toHaveBeenCalled();
       expect(mockValidateChecksum).not.toHaveBeenCalled();
     });
 
-    it("fails when no matching artifact exists in the default manifest", async () => {
+    it("fails when no matching artifact exists in NDJSON metadata", async () => {
-      mockGetArtifact.mockResolvedValue(undefined);
+      mockGetArtifactFromNdjson.mockResolvedValue(undefined);
 
       await expect(
-        downloadVersion(
+        downloadVersionFromNdjson(
           "unknown-linux-gnu",
           "x86_64",
           "0.9.26",
@@ -147,14 +192,14 @@ describe("download-version", () => {
       expect(mockValidateChecksum).not.toHaveBeenCalled();
     });
 
-    it("uses built-in checksums for default manifest downloads", async () => {
+    it("uses built-in checksums for default NDJSON downloads", async () => {
-      mockGetArtifact.mockResolvedValue({
+      mockGetArtifactFromNdjson.mockResolvedValue({
         archiveFormat: "tar.gz",
-        checksum: "manifest-checksum-that-should-be-ignored",
+        sha256: "ndjson-checksum-that-should-be-ignored",
-        downloadUrl: "https://example.com/uv.tar.gz",
+        url: "https://example.com/uv.tar.gz",
       });
 
-      await downloadVersion(
+      await downloadVersionFromNdjson(
         "unknown-linux-gnu",
         "x86_64",
         "0.9.26",
@@ -170,126 +215,23 @@ describe("download-version", () => {
         "0.9.26",
       );
     });
-
-    it("rewrites GitHub Releases URLs to the Astral mirror", async () => {
-      mockGetArtifact.mockResolvedValue({
-        archiveFormat: "tar.gz",
-        checksum: "abc123",
-        downloadUrl:
-          "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz",
-      });
-
-      await downloadVersion(
-        "unknown-linux-gnu",
-        "x86_64",
-        "0.9.26",
-        undefined,
-        "token",
-      );
-
-      expect(mockDownloadTool).toHaveBeenCalledWith(
-        "https://releases.astral.sh/github/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz",
-        undefined,
-        undefined,
-      );
-    });
-
-    it("does not rewrite non-GitHub URLs", async () => {
-      mockGetArtifact.mockResolvedValue({
-        archiveFormat: "tar.gz",
-        checksum: "abc123",
-        downloadUrl: "https://example.com/uv.tar.gz",
-      });
-
-      await downloadVersion(
-        "unknown-linux-gnu",
-        "x86_64",
-        "0.9.26",
-        undefined,
-        "token",
-      );
-
-      expect(mockDownloadTool).toHaveBeenCalledWith(
-        "https://example.com/uv.tar.gz",
-        undefined,
-        "token",
-      );
-    });
-
-    it("falls back to GitHub Releases when the mirror fails", async () => {
-      mockGetArtifact.mockResolvedValue({
-        archiveFormat: "tar.gz",
-        checksum: "abc123",
-        downloadUrl:
-          "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz",
-      });
-
-      mockDownloadTool
-        .mockRejectedValueOnce(new Error("mirror unavailable"))
-        .mockResolvedValueOnce("/tmp/downloaded");
-
-      await downloadVersion(
-        "unknown-linux-gnu",
-        "x86_64",
-        "0.9.26",
-        undefined,
-        "token",
-      );
-
-      expect(mockDownloadTool).toHaveBeenCalledTimes(2);
-      expect(mockDownloadTool).toHaveBeenNthCalledWith(
-        1,
-        "https://releases.astral.sh/github/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz",
-        undefined,
-        undefined,
-      );
-      expect(mockDownloadTool).toHaveBeenNthCalledWith(
-        2,
-        "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz",
-        undefined,
-        "token",
-      );
-      expect(mockWarning).toHaveBeenCalledWith(
-        "Failed to download from mirror, falling back to GitHub Releases: mirror unavailable",
-      );
-    });
-
-    it("does not fall back for non-GitHub URLs", async () => {
-      mockGetArtifact.mockResolvedValue({
-        archiveFormat: "tar.gz",
-        checksum: "abc123",
-        downloadUrl: "https://example.com/uv.tar.gz",
-      });
-
-      mockDownloadTool.mockRejectedValue(new Error("download failed"));
-
-      await expect(
-        downloadVersion(
-          "unknown-linux-gnu",
-          "x86_64",
-          "0.9.26",
-          undefined,
-          "token",
-        ),
-      ).rejects.toThrow("download failed");
-
-      expect(mockDownloadTool).toHaveBeenCalledTimes(1);
   });
 
+  describe("downloadVersionFromManifest", () => {
     it("uses manifest-file checksum metadata when checksum input is unset", async () => {
-      mockGetArtifact.mockResolvedValue({
+      mockGetManifestArtifact.mockResolvedValue({
         archiveFormat: "tar.gz",
         checksum: "manifest-checksum",
         downloadUrl: "https://example.com/custom-uv.tar.gz",
       });
 
-      await downloadVersion(
+      await downloadVersionFromManifest(
+        "https://example.com/custom.ndjson",
         "unknown-linux-gnu",
         "x86_64",
         "0.9.26",
         "",
         "token",
-        "https://example.com/custom.ndjson",
       );
 
       expect(mockValidateChecksum).toHaveBeenCalledWith(
@@ -302,19 +244,19 @@ describe("download-version", () => {
     });
 
     it("prefers checksum input over manifest-file checksum metadata", async () => {
-      mockGetArtifact.mockResolvedValue({
+      mockGetManifestArtifact.mockResolvedValue({
         archiveFormat: "tar.gz",
         checksum: "manifest-checksum",
         downloadUrl: "https://example.com/custom-uv.tar.gz",
       });
 
-      await downloadVersion(
+      await downloadVersionFromManifest(
+        "https://example.com/custom.ndjson",
         "unknown-linux-gnu",
         "x86_64",
         "0.9.26",
         "user-checksum",
         "token",
-        "https://example.com/custom.ndjson",
       );
 
       expect(mockValidateChecksum).toHaveBeenCalledWith(
@@ -326,28 +268,4 @@ describe("download-version", () => {
       );
     });
   });
-
-  describe("rewriteToMirror", () => {
-    it("rewrites a GitHub Releases URL to the Astral mirror", () => {
-      expect(
-        rewriteToMirror(
-          "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz",
-        ),
-      ).toBe(
-        "https://releases.astral.sh/github/uv/releases/download/0.9.26/uv-x86_64-unknown-linux-gnu.tar.gz",
-      );
-    });
-
-    it("returns undefined for non-GitHub URLs", () => {
-      expect(rewriteToMirror("https://example.com/uv.tar.gz")).toBeUndefined();
-    });
-
-    it("returns undefined for a different GitHub repo", () => {
-      expect(
-        rewriteToMirror(
-          "https://github.com/other/repo/releases/download/v1.0/file.tar.gz",
-        ),
-      ).toBeUndefined();
-    });
-  });
 });

__tests__/download/manifest.test.ts

@@ -1,168 +0,0 @@
-import { beforeEach, describe, expect, it, jest } from "@jest/globals";
-
-// biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
-const mockFetch = jest.fn<any>();
-
-jest.unstable_mockModule("@actions/core", () => ({
-  debug: jest.fn(),
-  info: jest.fn(),
-}));
-
-jest.unstable_mockModule("../../src/utils/fetch", () => ({
-  fetch: mockFetch,
-}));
-
-const {
-  clearManifestCache,
-  fetchManifest,
-  getAllVersions,
-  getArtifact,
-  getLatestVersion,
-  parseManifest,
-} = await import("../../src/download/manifest");
-
-const sampleManifestResponse = `{"version":"0.9.25","artifacts":[{"platform":"aarch64-apple-darwin","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.25/uv-aarch64-apple-darwin.tar.gz","archive_format":"tar.gz","sha256":"606b3c6949d971709f2526fa0d9f0fd23ccf60e09f117999b406b424af18a6a6"}]}
-{"version":"0.9.26","artifacts":[{"platform":"aarch64-apple-darwin","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.tar.gz","archive_format":"tar.gz","sha256":"fcf0a9ea6599c6ae28a4c854ac6da76f2c889354d7c36ce136ef071f7ab9721f"},{"platform":"x86_64-pc-windows-msvc","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-pc-windows-msvc.zip","archive_format":"zip","sha256":"eb02fd95d8e0eed462b4a67ecdd320d865b38c560bffcda9a0b87ec944bdf036"}]}`;
-
-const multiVariantManifestResponse = `{"version":"0.9.26","artifacts":[{"platform":"aarch64-apple-darwin","variant":"python-managed","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin-managed.tar.gz","archive_format":"tar.gz","sha256":"managed-checksum"},{"platform":"aarch64-apple-darwin","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.zip","archive_format":"zip","sha256":"default-checksum"}]}`;
-
-function createMockResponse(
-  ok: boolean,
-  status: number,
-  statusText: string,
-  data: string,
-) {
-  return {
-    ok,
-    status,
-    statusText,
-    text: async () => data,
-  };
-}
-
-describe("manifest", () => {
-  beforeEach(() => {
-    clearManifestCache();
-    mockFetch.mockReset();
-  });
-
-  describe("fetchManifest", () => {
-    it("fetches and parses manifest data", async () => {
-      mockFetch.mockResolvedValue(
-        createMockResponse(true, 200, "OK", sampleManifestResponse),
-      );
-
-      const versions = await fetchManifest();
-
-      expect(versions).toHaveLength(2);
-      expect(versions[0]?.version).toBe("0.9.25");
-      expect(versions[1]?.version).toBe("0.9.26");
-    });
-
-    it("throws on a failed fetch", async () => {
-      mockFetch.mockResolvedValue(
-        createMockResponse(false, 500, "Internal Server Error", ""),
-      );
-
-      await expect(fetchManifest()).rejects.toThrow(
-        "Failed to fetch manifest data: 500 Internal Server Error",
-      );
-    });
-
-    it("caches results per URL", async () => {
-      mockFetch.mockResolvedValue(
-        createMockResponse(true, 200, "OK", sampleManifestResponse),
-      );
-
-      await fetchManifest("https://example.com/custom.ndjson");
-      await fetchManifest("https://example.com/custom.ndjson");
-
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  describe("getAllVersions", () => {
-    it("returns all version strings", async () => {
-      mockFetch.mockResolvedValue(
-        createMockResponse(true, 200, "OK", sampleManifestResponse),
-      );
-
-      const versions = await getAllVersions(
-        "https://example.com/custom.ndjson",
-      );
-
-      expect(versions).toEqual(["0.9.25", "0.9.26"]);
-    });
-  });
-
-  describe("getArtifact", () => {
-    beforeEach(() => {
-      mockFetch.mockResolvedValue(
-        createMockResponse(true, 200, "OK", sampleManifestResponse),
-      );
-    });
-
-    it("finds an artifact by version and platform", async () => {
-      const artifact = await getArtifact("0.9.26", "aarch64", "apple-darwin");
-
-      expect(artifact).toEqual({
-        archiveFormat: "tar.gz",
-        checksum:
-          "fcf0a9ea6599c6ae28a4c854ac6da76f2c889354d7c36ce136ef071f7ab9721f",
-        downloadUrl:
-          "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.tar.gz",
-      });
-    });
-
-    it("finds a windows artifact", async () => {
-      const artifact = await getArtifact("0.9.26", "x86_64", "pc-windows-msvc");
-
-      expect(artifact).toEqual({
-        archiveFormat: "zip",
-        checksum:
-          "eb02fd95d8e0eed462b4a67ecdd320d865b38c560bffcda9a0b87ec944bdf036",
-        downloadUrl:
-          "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-pc-windows-msvc.zip",
-      });
-    });
-
-    it("prefers the default variant when multiple artifacts share a platform", async () => {
-      mockFetch.mockResolvedValue(
-        createMockResponse(true, 200, "OK", multiVariantManifestResponse),
-      );
-
-      const artifact = await getArtifact("0.9.26", "aarch64", "apple-darwin");
-
-      expect(artifact).toEqual({
-        archiveFormat: "zip",
-        checksum: "default-checksum",
-        downloadUrl:
-          "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.zip",
-      });
-    });
-
-    it("returns undefined for an unknown version", async () => {
-      const artifact = await getArtifact("0.0.1", "aarch64", "apple-darwin");
-
-      expect(artifact).toBeUndefined();
-    });
-
-    it("returns undefined for an unknown platform", async () => {
-      const artifact = await getArtifact(
-        "0.9.26",
-        "aarch64",
-        "unknown-linux-musl",
-      );
-
-      expect(artifact).toBeUndefined();
-    });
-  });
-
-  describe("parseManifest", () => {
-    it("throws for malformed manifest data", () => {
-      expect(() => parseManifest('{"version":"0.1.0"', "test-source")).toThrow(
-        "Failed to parse manifest data from test-source",
-      );
-    });
-  });
-});

__tests__/download/version-manifest.test.ts

@@ -0,0 +1,136 @@
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+
+const mockWarning = jest.fn();
+
+jest.unstable_mockModule("@actions/core", () => ({
+  debug: jest.fn(),
+  info: jest.fn(),
+  warning: mockWarning,
+}));
+
+// biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
+const mockFetch = jest.fn<any>();
+jest.unstable_mockModule("../../src/utils/fetch", () => ({
+  fetch: mockFetch,
+}));
+
+const {
+  clearManifestCache,
+  getAllVersions,
+  getLatestKnownVersion,
+  getManifestArtifact,
+} = await import("../../src/download/version-manifest");
+
+const legacyManifestResponse = JSON.stringify([
+  {
+    arch: "x86_64",
+    artifactName: "uv-x86_64-unknown-linux-gnu.tar.gz",
+    downloadUrl:
+      "https://example.com/releases/download/0.7.12-alpha.1/uv-x86_64-unknown-linux-gnu.tar.gz",
+    platform: "unknown-linux-gnu",
+    version: "0.7.12-alpha.1",
+  },
+  {
+    arch: "x86_64",
+    artifactName: "uv-x86_64-unknown-linux-gnu.tar.gz",
+    downloadUrl:
+      "https://example.com/releases/download/0.7.13/uv-x86_64-unknown-linux-gnu.tar.gz",
+    platform: "unknown-linux-gnu",
+    version: "0.7.13",
+  },
+]);
+
+const ndjsonManifestResponse = `{"version":"0.10.0","artifacts":[{"platform":"x86_64-unknown-linux-gnu","variant":"default","url":"https://example.com/releases/download/0.10.0/uv-x86_64-unknown-linux-gnu.tar.gz","archive_format":"tar.gz","sha256":"checksum-100"}]}
+{"version":"0.9.30","artifacts":[{"platform":"x86_64-unknown-linux-gnu","variant":"default","url":"https://example.com/releases/download/0.9.30/uv-x86_64-unknown-linux-gnu.tar.gz","archive_format":"tar.gz","sha256":"checksum-0930"}]}`;
+
+const multiVariantManifestResponse = `{"version":"0.10.0","artifacts":[{"platform":"x86_64-unknown-linux-gnu","variant":"managed-python","url":"https://example.com/releases/download/0.10.0/uv-x86_64-unknown-linux-gnu-managed-python.tar.gz","archive_format":"tar.gz","sha256":"checksum-managed"},{"platform":"x86_64-unknown-linux-gnu","variant":"default","url":"https://example.com/releases/download/0.10.0/uv-x86_64-unknown-linux-gnu-default.zip","archive_format":"zip","sha256":"checksum-default"}]}`;
+
+function createMockResponse(
+  ok: boolean,
+  status: number,
+  statusText: string,
+  data: string,
+) {
+  return {
+    ok,
+    status,
+    statusText,
+    text: async () => data,
+  };
+}
+
+describe("version-manifest", () => {
+  beforeEach(() => {
+    clearManifestCache();
+    mockFetch.mockReset();
+    mockWarning.mockReset();
+  });
+
+  it("supports the legacy JSON manifest format", async () => {
+    mockFetch.mockResolvedValue(
+      createMockResponse(true, 200, "OK", legacyManifestResponse),
+    );
+
+    const latest = await getLatestKnownVersion(
+      "https://example.com/legacy.json",
+    );
+    const artifact = await getManifestArtifact(
+      "https://example.com/legacy.json",
+      "0.7.13",
+      "x86_64",
+      "unknown-linux-gnu",
+    );
+
+    expect(latest).toBe("0.7.13");
+    expect(artifact).toEqual({
+      archiveFormat: undefined,
+      checksum: undefined,
+      downloadUrl:
+        "https://example.com/releases/download/0.7.13/uv-x86_64-unknown-linux-gnu.tar.gz",
+    });
+    expect(mockWarning).toHaveBeenCalledTimes(1);
+  });
+
+  it("supports NDJSON manifests", async () => {
+    mockFetch.mockResolvedValue(
+      createMockResponse(true, 200, "OK", ndjsonManifestResponse),
+    );
+
+    const versions = await getAllVersions("https://example.com/custom.ndjson");
+    const artifact = await getManifestArtifact(
+      "https://example.com/custom.ndjson",
+      "0.10.0",
+      "x86_64",
+      "unknown-linux-gnu",
+    );
+
+    expect(versions).toEqual(["0.10.0", "0.9.30"]);
+    expect(artifact).toEqual({
+      archiveFormat: "tar.gz",
+      checksum: "checksum-100",
+      downloadUrl:
+        "https://example.com/releases/download/0.10.0/uv-x86_64-unknown-linux-gnu.tar.gz",
+    });
+    expect(mockWarning).not.toHaveBeenCalled();
+  });
+
+  it("prefers the default variant when a manifest contains multiple variants", async () => {
+    mockFetch.mockResolvedValue(
+      createMockResponse(true, 200, "OK", multiVariantManifestResponse),
+    );
+
+    const artifact = await getManifestArtifact(
+      "https://example.com/multi-variant.ndjson",
+      "0.10.0",
+      "x86_64",
+      "unknown-linux-gnu",
+    );
+
+    expect(artifact).toEqual({
+      archiveFormat: "zip",
+      checksum: "checksum-default",
+      downloadUrl:
+        "https://example.com/releases/download/0.10.0/uv-x86_64-unknown-linux-gnu-default.zip",
+    });
+  });
+});

__tests__/download/versions-client.test.ts

@@ -0,0 +1,241 @@
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+
+// biome-ignore lint/suspicious/noExplicitAny: Mock requires flexible typing in tests.
+const mockFetch = jest.fn<any>();
+
+jest.unstable_mockModule("../../src/utils/fetch", () => ({
+  fetch: mockFetch,
+}));
+
+const {
+  clearCache,
+  fetchVersionData,
+  getAllVersions,
+  getArtifact,
+  getHighestSatisfyingVersion,
+  getLatestVersion,
+  parseVersionData,
+} = await import("../../src/download/versions-client");
+
+const sampleNdjsonResponse = `{"version":"0.9.26","artifacts":[{"platform":"aarch64-apple-darwin","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.tar.gz","archive_format":"tar.gz","sha256":"fcf0a9ea6599c6ae28a4c854ac6da76f2c889354d7c36ce136ef071f7ab9721f"},{"platform":"x86_64-pc-windows-msvc","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-pc-windows-msvc.zip","archive_format":"zip","sha256":"eb02fd95d8e0eed462b4a67ecdd320d865b38c560bffcda9a0b87ec944bdf036"}]}
+{"version":"0.9.25","artifacts":[{"platform":"aarch64-apple-darwin","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.25/uv-aarch64-apple-darwin.tar.gz","archive_format":"tar.gz","sha256":"606b3c6949d971709f2526fa0d9f0fd23ccf60e09f117999b406b424af18a6a6"}]}`;
+
+const multiVariantNdjsonResponse = `{"version":"0.9.26","artifacts":[{"platform":"aarch64-apple-darwin","variant":"python-managed","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin-managed.tar.gz","archive_format":"tar.gz","sha256":"managed-checksum"},{"platform":"aarch64-apple-darwin","variant":"default","url":"https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.zip","archive_format":"zip","sha256":"default-checksum"}]}`;
+
+function createMockStream(chunks: string[]): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const chunk of chunks) {
+        controller.enqueue(encoder.encode(chunk));
+      }
+      controller.close();
+    },
+  });
+}
+
+function createMockResponse(
+  ok: boolean,
+  status: number,
+  statusText: string,
+  data: string,
+  chunks: string[] = [data],
+) {
+  return {
+    body: createMockStream(chunks),
+    ok,
+    status,
+    statusText,
+    text: async () => data,
+  };
+}
+
+describe("versions-client", () => {
+  beforeEach(() => {
+    clearCache();
+    mockFetch.mockReset();
+  });
+
+  describe("fetchVersionData", () => {
+    it("should fetch and parse NDJSON data", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(true, 200, "OK", sampleNdjsonResponse),
+      );
+
+      const versions = await fetchVersionData();
+
+      expect(versions).toHaveLength(2);
+      expect(versions[0].version).toBe("0.9.26");
+      expect(versions[1].version).toBe("0.9.25");
+    });
+
+    it("should throw error on failed fetch", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(false, 500, "Internal Server Error", ""),
+      );
+
+      await expect(fetchVersionData()).rejects.toThrow(
+        "Failed to fetch version data: 500 Internal Server Error",
+      );
+    });
+
+    it("should cache results", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(true, 200, "OK", sampleNdjsonResponse),
+      );
+
+      await fetchVersionData();
+      await fetchVersionData();
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("getLatestVersion", () => {
+    it("should return the first version (newest)", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(true, 200, "OK", sampleNdjsonResponse),
+      );
+
+      const latest = await getLatestVersion();
+
+      expect(latest).toBe("0.9.26");
+    });
+
+    it("should stop after the first record when resolving latest", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(
+          true,
+          200,
+          "OK",
+          `${sampleNdjsonResponse}\n{"version":`,
+          [`${sampleNdjsonResponse.split("\n")[0]}\n`, '{"version":'],
+        ),
+      );
+
+      const latest = await getLatestVersion();
+
+      expect(latest).toBe("0.9.26");
+    });
+  });
+
+  describe("getAllVersions", () => {
+    it("should return all version strings", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(true, 200, "OK", sampleNdjsonResponse),
+      );
+
+      const versions = await getAllVersions();
+
+      expect(versions).toEqual(["0.9.26", "0.9.25"]);
+    });
+  });
+
+  describe("getHighestSatisfyingVersion", () => {
+    it("should return the first matching version from the stream", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(
+          true,
+          200,
+          "OK",
+          `${sampleNdjsonResponse}\n{"version":`,
+          [`${sampleNdjsonResponse.split("\n")[0]}\n`, '{"version":'],
+        ),
+      );
+
+      const version = await getHighestSatisfyingVersion("^0.9.0");
+
+      expect(version).toBe("0.9.26");
+    });
+  });
+
+  describe("getArtifact", () => {
+    beforeEach(() => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(true, 200, "OK", sampleNdjsonResponse),
+      );
+    });
+
+    it("should find artifact by version and platform", async () => {
+      const artifact = await getArtifact("0.9.26", "aarch64", "apple-darwin");
+
+      expect(artifact).toEqual({
+        archiveFormat: "tar.gz",
+        sha256:
+          "fcf0a9ea6599c6ae28a4c854ac6da76f2c889354d7c36ce136ef071f7ab9721f",
+        url: "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.tar.gz",
+      });
+    });
+
+    it("should stop once the requested version is found", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(
+          true,
+          200,
+          "OK",
+          `${sampleNdjsonResponse}\n{"version":`,
+          [`${sampleNdjsonResponse.split("\n")[0]}\n`, '{"version":'],
+        ),
+      );
+
+      const artifact = await getArtifact("0.9.26", "aarch64", "apple-darwin");
+
+      expect(artifact).toEqual({
+        archiveFormat: "tar.gz",
+        sha256:
+          "fcf0a9ea6599c6ae28a4c854ac6da76f2c889354d7c36ce136ef071f7ab9721f",
+        url: "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.tar.gz",
+      });
+    });
+
+    it("should find windows artifact", async () => {
+      const artifact = await getArtifact("0.9.26", "x86_64", "pc-windows-msvc");
+
+      expect(artifact).toEqual({
+        archiveFormat: "zip",
+        sha256:
+          "eb02fd95d8e0eed462b4a67ecdd320d865b38c560bffcda9a0b87ec944bdf036",
+        url: "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-x86_64-pc-windows-msvc.zip",
+      });
+    });
+
+    it("should prefer the default variant when multiple artifacts share a platform", async () => {
+      mockFetch.mockResolvedValue(
+        createMockResponse(true, 200, "OK", multiVariantNdjsonResponse),
+      );
+
+      const artifact = await getArtifact("0.9.26", "aarch64", "apple-darwin");
+
+      expect(artifact).toEqual({
+        archiveFormat: "zip",
+        sha256: "default-checksum",
+        url: "https://github.com/astral-sh/uv/releases/download/0.9.26/uv-aarch64-apple-darwin.zip",
+      });
+    });
+
+    it("should return undefined for unknown version", async () => {
+      const artifact = await getArtifact("0.0.1", "aarch64", "apple-darwin");
+
+      expect(artifact).toBeUndefined();
+    });
+
+    it("should return undefined for unknown platform", async () => {
+      const artifact = await getArtifact(
+        "0.9.26",
+        "aarch64",
+        "unknown-linux-musl",
+      );
+
+      expect(artifact).toBeUndefined();
+    });
+  });
+
+  describe("parseVersionData", () => {
+    it("should throw for malformed NDJSON", () => {
+      expect(() =>
+        parseVersionData('{"version":"0.1.0"', "test-source"),
+      ).toThrow("Failed to parse version data from test-source");
+    });
+  });
+});

action.yml

@@ -75,7 +75,7 @@ inputs:
     description: "Custom path to set UV_TOOL_BIN_DIR to."
     required: false
   manifest-file:
-    description: "URL to a custom manifest file in the astral-sh/versions format."
+    description: "URL to a custom manifest file. Supports the astral-sh/versions NDJSON format and the legacy JSON array format (deprecated)."
     required: false
   add-problem-matchers:
     description: "Add problem matchers."

docs/customization.md

@@ -19,14 +19,14 @@ are automatically verified by this action. The sha256 hashes can be found on the
 ## Manifest file
 
 By default, setup-uv reads version metadata from
-[`astral-sh/versions`](https://github.com/astral-sh/versions).
+[`astral-sh/versions`](https://github.com/astral-sh/versions) (NDJSON format).
 
 The `manifest-file` input lets you override that source with your own URL, for example to test
 custom uv builds or alternate download locations.
 
 ### Format
 
-The manifest file must use the same format as `astral-sh/versions`: one JSON object per line, where each object represents a version and its artifacts. The versions must be sorted in descending order. For example:
+The manifest file must be in NDJSON format, where each line is a JSON object representing a version and its artifacts. For example:
 
 ```json
 {"version":"0.10.7","artifacts":[{"platform":"x86_64-unknown-linux-gnu","variant":"default","url":"https://example.com/uv-x86_64-unknown-linux-gnu.tar.gz","archive_format":"tar.gz","sha256":"..."}]}
@@ -37,6 +37,23 @@ setup-uv currently only supports `default` as the `variant`.
 
 The `archive_format` field is currently ignored.
 
+### Legacy format: JSON array (deprecated)
+
+The previous JSON array format is still supported for compatibility, but deprecated and will be
+removed in a future major release.
+
+```json
+[
+  {
+    "version": "0.7.13",
+    "artifactName": "uv-aarch64-apple-darwin.tar.gz",
+    "arch": "aarch64",
+    "platform": "apple-darwin",
+    "downloadUrl": "https://github.com/astral-sh/uv/releases/download/0.7.13/uv-aarch64-apple-darwin.tar.gz"
+  }
+]
+```
+
 ```yaml
 - name: Use a custom manifest file
   uses: astral-sh/setup-uv@v7

package.json

@@ -9,6 +9,7 @@
     "build": "tsc --noEmit",
     "check": "biome check --write",
     "package": "node scripts/build-dist.mjs",
+    "bench:versions": "node scripts/bench-versions-client.mjs",
     "test:unit": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
     "test": "npm run build && npm run test:unit",
     "act": "act pull_request -W .github/workflows/test.yml --container-architecture linux/amd64 -s GITHUB_TOKEN=\"$(gh auth token)\"",

scripts/bench-versions-client.mjs

@@ -0,0 +1,483 @@
+import { performance } from "node:perf_hooks";
+import * as pep440 from "@renovatebot/pep440";
+import * as semver from "semver";
+import { ProxyAgent, fetch as undiciFetch } from "undici";
+
+const DEFAULT_URL =
+  "https://raw.githubusercontent.com/astral-sh/versions/main/v1/uv.ndjson";
+const DEFAULT_ITERATIONS = 100;
+const DEFAULT_ARCH = "aarch64";
+const DEFAULT_PLATFORM = "apple-darwin";
+
+function getProxyAgent() {
+  const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+  if (httpProxy) {
+    return new ProxyAgent(httpProxy);
+  }
+
+  const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (httpsProxy) {
+    return new ProxyAgent(httpsProxy);
+  }
+
+  return undefined;
+}
+
+async function fetch(url) {
+  return await undiciFetch(url, {
+    dispatcher: getProxyAgent(),
+  });
+}
+
+function parseArgs(argv) {
+  const options = {
+    arch: DEFAULT_ARCH,
+    iterations: DEFAULT_ITERATIONS,
+    platform: DEFAULT_PLATFORM,
+    url: DEFAULT_URL,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+
+    if (arg === "--iterations" && next !== undefined) {
+      options.iterations = Number.parseInt(next, 10);
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--url" && next !== undefined) {
+      options.url = next;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--arch" && next !== undefined) {
+      options.arch = next;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--platform" && next !== undefined) {
+      options.platform = next;
+      index += 1;
+    }
+  }
+
+  if (!Number.isInteger(options.iterations) || options.iterations <= 0) {
+    throw new Error("--iterations must be a positive integer");
+  }
+
+  return options;
+}
+
+function parseVersionLine(line, sourceDescription, lineNumber) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse version data from ${sourceDescription} at line ${lineNumber}: ${error.message}`,
+    );
+  }
+
+  if (
+    typeof parsed !== "object" ||
+    parsed === null ||
+    typeof parsed.version !== "string" ||
+    !Array.isArray(parsed.artifacts)
+  ) {
+    throw new Error(
+      `Invalid NDJSON record in ${sourceDescription} at line ${lineNumber}.`,
+    );
+  }
+
+  return parsed;
+}
+
+function parseVersionData(data, sourceDescription) {
+  const versions = [];
+
+  for (const [index, line] of data.split("\n").entries()) {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+
+    versions.push(parseVersionLine(trimmed, sourceDescription, index + 1));
+  }
+
+  if (versions.length === 0) {
+    throw new Error(`No version data found in ${sourceDescription}.`);
+  }
+
+  return versions;
+}
+
+async function readEntireResponse(response) {
+  if (response.body === null) {
+    const text = await response.text();
+    return {
+      bytesRead: Buffer.byteLength(text, "utf8"),
+      text,
+    };
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let bytesRead = 0;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      chunks.push(decoder.decode());
+      break;
+    }
+
+    bytesRead += value.byteLength;
+    chunks.push(decoder.decode(value, { stream: true }));
+  }
+
+  return {
+    bytesRead,
+    text: chunks.join(""),
+  };
+}
+
+async function fetchAllVersions(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch version data: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const { bytesRead, text } = await readEntireResponse(response);
+  return {
+    bytesRead,
+    versions: parseVersionData(text, url),
+  };
+}
+
+async function streamUntil(url, predicate) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch version data: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  if (response.body === null) {
+    const { bytesRead, versions } = await fetchAllVersions(url);
+    return {
+      bytesRead,
+      matchedVersion: versions.find(predicate),
+    };
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let bytesRead = 0;
+  let buffer = "";
+  let lineNumber = 0;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      buffer += decoder.decode();
+      break;
+    }
+
+    bytesRead += value.byteLength;
+    buffer += decoder.decode(value, { stream: true });
+
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      const trimmed = line.trim();
+
+      if (trimmed !== "") {
+        lineNumber += 1;
+        const versionData = parseVersionLine(trimmed, url, lineNumber);
+        if (predicate(versionData)) {
+          await reader.cancel();
+          return { bytesRead, matchedVersion: versionData };
+        }
+      }
+
+      newlineIndex = buffer.indexOf("\n");
+    }
+  }
+
+  if (buffer.trim() !== "") {
+    lineNumber += 1;
+    const versionData = parseVersionLine(buffer.trim(), url, lineNumber);
+    if (predicate(versionData)) {
+      return { bytesRead, matchedVersion: versionData };
+    }
+  }
+
+  return { bytesRead, matchedVersion: undefined };
+}
+
+function versionSatisfies(version, versionSpecifier) {
+  return (
+    semver.satisfies(version, versionSpecifier) ||
+    pep440.satisfies(version, versionSpecifier)
+  );
+}
+
+function maxSatisfying(versions, versionSpecifier) {
+  const semverMatch = semver.maxSatisfying(versions, versionSpecifier);
+  if (semverMatch !== null) {
+    return semverMatch;
+  }
+
+  return pep440.maxSatisfying(versions, versionSpecifier) ?? undefined;
+}
+
+function selectArtifact(artifacts) {
+  if (artifacts.length === 1) {
+    return artifacts[0];
+  }
+
+  const defaultVariant = artifacts.find(
+    (candidate) => candidate.variant === "default",
+  );
+  if (defaultVariant !== undefined) {
+    return defaultVariant;
+  }
+
+  return artifacts[0];
+}
+
+async function benchmarkCase(name, expected, implementations, iterations) {
+  const results = {
+    name,
+    new: [],
+    old: [],
+  };
+
+  for (let iteration = 0; iteration < iterations; iteration += 1) {
+    const order = iteration % 2 === 0 ? ["old", "new"] : ["new", "old"];
+
+    for (const label of order) {
+      const implementation = implementations[label];
+      const startedAt = performance.now();
+      const outcome = await implementation.run();
+      const durationMs = performance.now() - startedAt;
+
+      if (outcome.value !== expected) {
+        throw new Error(
+          `${name} ${label} produced ${JSON.stringify(outcome.value)}; expected ${JSON.stringify(expected)}`,
+        );
+      }
+
+      results[label].push({
+        bytesRead: outcome.bytesRead,
+        durationMs,
+      });
+    }
+  }
+
+  return results;
+}
+
+function summarize(samples) {
+  const durations = samples
+    .map((sample) => sample.durationMs)
+    .sort((left, right) => left - right);
+  const bytes = samples
+    .map((sample) => sample.bytesRead)
+    .sort((left, right) => left - right);
+
+  const sum = (values) => values.reduce((total, value) => total + value, 0);
+  const percentile = (values, ratio) => {
+    const index = Math.min(
+      values.length - 1,
+      Math.max(0, Math.ceil(values.length * ratio) - 1),
+    );
+    return values[index];
+  };
+
+  return {
+    avgBytes: sum(bytes) / bytes.length,
+    avgMs: sum(durations) / durations.length,
+    maxMs: durations[durations.length - 1],
+    medianMs: percentile(durations, 0.5),
+    minMs: durations[0],
+    p95Ms: percentile(durations, 0.95),
+  };
+}
+
+function formatNumber(value, digits = 2) {
+  return value.toFixed(digits);
+}
+
+function formatSummary(name, oldSummary, newSummary) {
+  const speedup = oldSummary.avgMs / newSummary.avgMs;
+  const timeReduction =
+    ((oldSummary.avgMs - newSummary.avgMs) / oldSummary.avgMs) * 100;
+  const byteReduction =
+    ((oldSummary.avgBytes - newSummary.avgBytes) / oldSummary.avgBytes) * 100;
+
+  return [
+    `Scenario: ${name}`,
+    `  old avg: ${formatNumber(oldSummary.avgMs)} ms | median: ${formatNumber(oldSummary.medianMs)} ms | p95: ${formatNumber(oldSummary.p95Ms)} ms | avg bytes: ${Math.round(oldSummary.avgBytes)}`,
+    `  new avg: ${formatNumber(newSummary.avgMs)} ms | median: ${formatNumber(newSummary.medianMs)} ms | p95: ${formatNumber(newSummary.p95Ms)} ms | avg bytes: ${Math.round(newSummary.avgBytes)}`,
+    `  delta: ${formatNumber(timeReduction)}% faster | ${formatNumber(speedup)}x speedup | ${formatNumber(byteReduction)}% fewer bytes read`,
+  ].join("\n");
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  console.log(`Preparing benchmark data from ${options.url}`);
+  const baseline = await fetchAllVersions(options.url);
+  const latestVersion = baseline.versions[0]?.version;
+  if (!latestVersion) {
+    throw new Error("No versions found in NDJSON data");
+  }
+
+  const latestArtifact = selectArtifact(
+    baseline.versions[0].artifacts.filter(
+      (candidate) =>
+        candidate.platform === `${options.arch}-${options.platform}`,
+    ),
+  );
+  if (!latestArtifact) {
+    throw new Error(
+      `No artifact found for ${options.arch}-${options.platform} in ${latestVersion}`,
+    );
+  }
+
+  const rangeSpecifier = `^${latestVersion.split(".")[0]}.${latestVersion.split(".")[1]}.0`;
+
+  console.log(
+    `Running ${options.iterations} iterations per scenario against ${options.url}`,
+  );
+  console.log(`Latest version: ${latestVersion}`);
+  console.log(`Range benchmark: ${rangeSpecifier}`);
+  console.log(`Artifact benchmark: ${options.arch}-${options.platform}`);
+  console.log("");
+
+  const scenarios = [
+    await benchmarkCase(
+      "latest version",
+      latestVersion,
+      {
+        new: {
+          run: async () => {
+            const { bytesRead, matchedVersion } = await streamUntil(
+              options.url,
+              () => true,
+            );
+            return {
+              bytesRead,
+              value: matchedVersion?.version,
+            };
+          },
+        },
+        old: {
+          run: async () => {
+            const { bytesRead, versions } = await fetchAllVersions(options.url);
+            return {
+              bytesRead,
+              value: versions[0]?.version,
+            };
+          },
+        },
+      },
+      options.iterations,
+    ),
+    await benchmarkCase(
+      "highest satisfying range",
+      latestVersion,
+      {
+        new: {
+          run: async () => {
+            const { bytesRead, matchedVersion } = await streamUntil(
+              options.url,
+              (candidate) =>
+                versionSatisfies(candidate.version, rangeSpecifier),
+            );
+            return {
+              bytesRead,
+              value: matchedVersion?.version,
+            };
+          },
+        },
+        old: {
+          run: async () => {
+            const { bytesRead, versions } = await fetchAllVersions(options.url);
+            return {
+              bytesRead,
+              value: maxSatisfying(
+                versions.map((versionData) => versionData.version),
+                rangeSpecifier,
+              ),
+            };
+          },
+        },
+      },
+      options.iterations,
+    ),
+    await benchmarkCase(
+      "exact version artifact",
+      latestArtifact.url,
+      {
+        new: {
+          run: async () => {
+            const { bytesRead, matchedVersion } = await streamUntil(
+              options.url,
+              (candidate) => candidate.version === latestVersion,
+            );
+            const artifact = matchedVersion
+              ? selectArtifact(
+                  matchedVersion.artifacts.filter(
+                    (candidate) =>
+                      candidate.platform ===
+                      `${options.arch}-${options.platform}`,
+                  ),
+                )
+              : undefined;
+            return {
+              bytesRead,
+              value: artifact?.url,
+            };
+          },
+        },
+        old: {
+          run: async () => {
+            const { bytesRead, versions } = await fetchAllVersions(options.url);
+            const versionData = versions.find(
+              (candidate) => candidate.version === latestVersion,
+            );
+            const artifact = selectArtifact(
+              versionData.artifacts.filter(
+                (candidate) =>
+                  candidate.platform === `${options.arch}-${options.platform}`,
+              ),
+            );
+            return {
+              bytesRead,
+              value: artifact?.url,
+            };
+          },
+        },
+      },
+      options.iterations,
+    ),
+  ];
+
+  for (const scenario of scenarios) {
+    const oldSummary = summarize(scenario.old);
+    const newSummary = summarize(scenario.new);
+    console.log(formatSummary(scenario.name, oldSummary, newSummary));
+    console.log("");
+  }
+}
+
+await main();

src/download/checksum/known-checksums.ts

@@ -1,143 +1,5 @@
 // AUTOGENERATED_DO_NOT_EDIT
 export const KNOWN_CHECKSUMS: { [key: string]: string } = {
-  "aarch64-apple-darwin-0.11.1":
-    "f7815f739ed5d0e4202e6292acedb8659b9ae7de663d07188d8c6cbd7f96303f",
-  "aarch64-pc-windows-msvc-0.11.1":
-    "b789db0c1504dd3b02c090bd5783487497cc46cc2eb71754874cdd1ef59eb52a",
-  "aarch64-unknown-linux-gnu-0.11.1":
-    "1340e62da1ee3c1109764340e1247e8a1a232c30dde4a0f0548976dcaa90f06d",
-  "aarch64-unknown-linux-musl-0.11.1":
-    "bd04ffce77ee8d77f39823c13606183581847c2f5dcd704f2ea0f15e376b1a27",
-  "arm-unknown-linux-musleabihf-0.11.1":
-    "625c0e756e2374fce864ceaa6beedd5821e276e2b6307f2b719f2d62b449b89c",
-  "armv7-unknown-linux-gnueabihf-0.11.1":
-    "baf8daaab20b0502d1853dbfd916afb0762c024ae7f0df1c2deb2a1a1c1c3467",
-  "armv7-unknown-linux-musleabihf-0.11.1":
-    "684c25b74e83bcb1b177152379cfe2c974ba731aa5af278e1d161e41709f8bcf",
-  "i686-pc-windows-msvc-0.11.1":
-    "3c07858a08c54e4e5753239354c7b07ae69071b2b6f5aa2cc970e612adcb4740",
-  "i686-unknown-linux-gnu-0.11.1":
-    "6e83167c05708570563b10b6cc7e8c289daef5f51fde0b152e41af2a7ef70813",
-  "i686-unknown-linux-musl-0.11.1":
-    "b0d5152635c257fec76f95cb9268112b47ff70bd33a23866295a4f2ed9f46b7f",
-  "powerpc64le-unknown-linux-gnu-0.11.1":
-    "e42d2abfac46f57564789e2bfa6dbea4ae3135892e36ae066ba0ae77b69bb676",
-  "riscv64gc-unknown-linux-gnu-0.11.1":
-    "5e2c757b35dab015ad37f74ee3e060208390b5f4defb6684876f1be0664f3f6e",
-  "riscv64gc-unknown-linux-musl-0.11.1":
-    "6f590a824aed363cbec4079f7ddab87b5685119e0f5f0e71cd114c7b7c326199",
-  "s390x-unknown-linux-gnu-0.11.1":
-    "4208173c74e29572b799178709b5ed5828b24888659f944a4b47c0aaf78b42d2",
-  "x86_64-apple-darwin-0.11.1":
-    "2103670e8e949605e51926c7b953923ff6f6befbfb55aee928f5e760c9c910f8",
-  "x86_64-pc-windows-msvc-0.11.1":
-    "6659250cebbd3bb6ee48bcb21a3f0c6656450d63fb97f0f069bcb532bdb688ed",
-  "x86_64-unknown-linux-gnu-0.11.1":
-    "7c0c8069053e6e99e5911ff32b916be571f3419cd8e11bd28fb7da2c7dcaa553",
-  "x86_64-unknown-linux-musl-0.11.1":
-    "4e949471a95b37088a1ff1a585f69abed4d3cd3f921f50709a46b6ba62986d38",
-  "aarch64-apple-darwin-0.11.0":
-    "0c0f32c6a3473c5928aff96c3233715edfc79290e892f255cac93710cde7b91a",
-  "aarch64-pc-windows-msvc-0.11.0":
-    "95419e04a3ef5f13fb2a06bd6d787ba80a9d8981d6f097780e5a979817a2879d",
-  "aarch64-unknown-linux-gnu-0.11.0":
-    "8e179ca110343a17f801444ff9ef117dba56ef5fc9f6a4c9bb77b318ddba5f24",
-  "aarch64-unknown-linux-musl-0.11.0":
-    "658be4b8ec905635f1295468d4d5120d9e1ab1722eec9a104473ce993590babe",
-  "arm-unknown-linux-musleabihf-0.11.0":
-    "bfdcbd5fa41c8a9877a72c2b55a95da2bc79933885ef56c699b65bb2ed9cea91",
-  "armv7-unknown-linux-gnueabihf-0.11.0":
-    "0cad4e1b6769e48aa1e80cf639ddcc7c1bfe9ed017e95868fed185a8d818c949",
-  "armv7-unknown-linux-musleabihf-0.11.0":
-    "2aa9da83c6c0cf8a06bc9df14d51056284fa067ef5390b4db79998ff12f3bee7",
-  "i686-pc-windows-msvc-0.11.0":
-    "3b09d70e686087e096dbd8a2af21b922a2cac7d613dc053c3281c3ddbb961961",
-  "i686-unknown-linux-gnu-0.11.0":
-    "59928a0267501c20d9f9942f5f1d81a991ec55e29a19e002ae3d5c178c674c89",
-  "i686-unknown-linux-musl-0.11.0":
-    "1f438d6f6f851f0dabad3307ce7fd46541ecc5c42ebb664f382eb6c9a424a67d",
-  "powerpc64le-unknown-linux-gnu-0.11.0":
-    "29f17fb43595492b1a36cda57df7adad74183132df32799d32897268ff4e26dd",
-  "riscv64gc-unknown-linux-gnu-0.11.0":
-    "84ef37dda1003c5b65fa6c8f84242d35a7fcc84cc5ea9490d702edc36cad1f67",
-  "s390x-unknown-linux-gnu-0.11.0":
-    "b25be62f3b642348a2fece5c658624586661b8d1103891ab6903768b0529edc4",
-  "x86_64-apple-darwin-0.11.0":
-    "31aaec764166af8885cf99321fd6ed24fef80225a6f26ed1ae8ce04111688a7e",
-  "x86_64-pc-windows-msvc-0.11.0":
-    "e21d00b172df83531564a95e75a2bdc0c59b471dbb3515f0c1b4d6ef657dc451",
-  "x86_64-unknown-linux-gnu-0.11.0":
-    "cc0fbb42b3642125f600a55b0b095bea65cddaadb94c6ea2b6ba5d79c5825089",
-  "x86_64-unknown-linux-musl-0.11.0":
-    "bf6b0757c73d1726faa2a819b155d4d864919a95766720215d78fdcd09d42d26",
-  "aarch64-apple-darwin-0.10.12":
-    "ae738b5661a900579ec621d3918c0ef17bdec0da2a8a6d8b161137cd15f25414",
-  "aarch64-pc-windows-msvc-0.10.12":
-    "e79881e2c4f98a0f3a37b8770bf224e8fee70f6dcf8fc17055d8291bb1b0b867",
-  "aarch64-unknown-linux-gnu-0.10.12":
-    "0ed7d20f49f6b9b60d45fdfcac28f3ac01a671a6ef08672401ed2833423fea2a",
-  "aarch64-unknown-linux-musl-0.10.12":
-    "55bd1c1c10ec8b95a8c184f5e18b566703c6ab105f0fc118aaa4d748aabf28e4",
-  "arm-unknown-linux-musleabihf-0.10.12":
-    "9714e5059b05110a1c7ddbc18c971c13e0260e10551b7b77d82cbf907a4ebd9b",
-  "armv7-unknown-linux-gnueabihf-0.10.12":
-    "eaa02f36d5112029601b18ac3d1a0c03a83bb20cb4154c2f5345f777fa6c4101",
-  "armv7-unknown-linux-musleabihf-0.10.12":
-    "bd735652298c6e62cdd2ac939babe176a3356613e6803baa33d0bc10e8d9e4ed",
-  "i686-pc-windows-msvc-0.10.12":
-    "2312e75b9c77befdc1bff30da18f16df03083452852952553bee91da362c1a1d",
-  "i686-unknown-linux-gnu-0.10.12":
-    "8501844b34e3a28cfbba5a4b857eebd696d952e0bb4160357451ad80f3f49db8",
-  "i686-unknown-linux-musl-0.10.12":
-    "56cad78abcf5b710d2f7b9f774fcfd6bbed340d2aa9d9fc9e3b515542ec5e953",
-  "powerpc64le-unknown-linux-gnu-0.10.12":
-    "3c8017d9112221c83f43e8a15a58099663c0b2bdeabc8b43bb800413dfa21218",
-  "riscv64gc-unknown-linux-gnu-0.10.12":
-    "b1ca482b6b5dd7bf6ab733a3695cb0ab5b8e992ca96527efae93aa78fcc52a9b",
-  "s390x-unknown-linux-gnu-0.10.12":
-    "e1a0345eefe6fd3300948cd6f18aab092f9b88a243782113e645ce96530a6693",
-  "x86_64-apple-darwin-0.10.12":
-    "17443e293f2ae407bb2d8d34b875ebfe0ae01cf1296de5647e69e7b2e2b428f0",
-  "x86_64-pc-windows-msvc-0.10.12":
-    "4c1d55501869b3330d4aabf45ad6024ce2367e0f3af83344395702d272c22e88",
-  "x86_64-unknown-linux-gnu-0.10.12":
-    "ec72570c9d1f33021aa80b176d7baba390de2cfeb1abcbefca346d563bf17484",
-  "x86_64-unknown-linux-musl-0.10.12":
-    "adccf40b5d1939a5e0093081ec2307ea24235adf7c2d96b122c561fa37711c46",
-  "aarch64-apple-darwin-0.10.11":
-    "437a7d498dd6564d5bf986074249ba1fc600e73da55ae04d7bd4c24d5f149b95",
-  "aarch64-pc-windows-msvc-0.10.11":
-    "6a3eec4105c775dd87c11ef8ec41564648273751ff807c8955c24ddbcc636d03",
-  "aarch64-unknown-linux-gnu-0.10.11":
-    "23003df007937dd607409c8ddf010baa82bad2673e60e254632ca5b04edcce13",
-  "aarch64-unknown-linux-musl-0.10.11":
-    "5d80a7f6343d2676dfde1e5126582070a2bbc62df6f60d5527a169be3788532a",
-  "arm-unknown-linux-musleabihf-0.10.11":
-    "d3c248497c450d22a39c1d43a4a358c0c852e6056f5f49be96495eea41afb96c",
-  "armv7-unknown-linux-gnueabihf-0.10.11":
-    "7895a6470dfba051af4e74253599482fc0b37141b5d229956b383365e1a22902",
-  "armv7-unknown-linux-musleabihf-0.10.11":
-    "d2880c08acfdaef0985488972c8b14969f7139c27545046e2f6202f0e0f4d9d8",
-  "i686-pc-windows-msvc-0.10.11":
-    "c17f3dc3b2c47490057f17a1f0c37270f11a7b7cedf9bf2c0f841ce02bc7001b",
-  "i686-unknown-linux-gnu-0.10.11":
-    "1ab69ff7dd104a902731758ee05b782dfd9bdb263384e61650de638f33f586df",
-  "i686-unknown-linux-musl-0.10.11":
-    "cffb80d303fc1655e259d0b769c489f452e97425a6b6d3393d766413783a1d8c",
-  "powerpc64le-unknown-linux-gnu-0.10.11":
-    "ddc6a20670e60219e947b1b04813be80d7e9f4c4a0234231c8ed9298eec04aa6",
-  "riscv64gc-unknown-linux-gnu-0.10.11":
-    "c0719473cf5f8b475e917b8dfef6ae5d876b86a00a82ef91e47a02f561399f4f",
-  "s390x-unknown-linux-gnu-0.10.11":
-    "305ee734c585918515a22fe43b7cf253c38d468771373a0c02364d67498e07b2",
-  "x86_64-apple-darwin-0.10.11":
-    "ff90020b554cf02ef8008535c9aab6ef27bb7be6b075359300dec79c361df897",
-  "x86_64-pc-windows-msvc-0.10.11":
-    "9ee74df98582f37fdd6069e1caac80d2616f9a489f5dbb2b1c152f30be69c58e",
-  "x86_64-unknown-linux-gnu-0.10.11":
-    "5a360b0de092ddf4131f5313d0411b48c4e95e8107e40c3f8f2e9fcb636b3583",
-  "x86_64-unknown-linux-musl-0.10.11":
-    "d78246139dc6cf3ed6d03c84da762686bced7ad1de67977ee372a45b95a1f6d0",
   "aarch64-apple-darwin-0.10.10":
     "8a09f0ef51ee7f7170731b4cb8bde5bf9ba6da5304f49a7df6cdab42a1f37b5d",
   "aarch64-pc-windows-msvc-0.10.10":

src/download/download-version.ts

@@ -4,15 +4,20 @@ import * as core from "@actions/core";
 import * as tc from "@actions/tool-cache";
 import * as pep440 from "@renovatebot/pep440";
 import * as semver from "semver";
-import {
+import { TOOL_CACHE_NAME, VERSIONS_NDJSON_URL } from "../utils/constants";
-  ASTRAL_MIRROR_PREFIX,
-  GITHUB_RELEASES_PREFIX,
-  TOOL_CACHE_NAME,
-  VERSIONS_MANIFEST_URL,
-} from "../utils/constants";
 import type { Architecture, Platform } from "../utils/platforms";
 import { validateChecksum } from "./checksum/checksum";
-import { getAllVersions, getArtifact, getLatestVersion } from "./manifest";
+import {
+  getAllVersions as getAllManifestVersions,
+  getLatestKnownVersion as getLatestVersionInManifest,
+  getManifestArtifact,
+} from "./version-manifest";
+import {
+  getAllVersions as getAllVersionsFromNdjson,
+  getArtifact as getArtifactFromNdjson,
+  getHighestSatisfyingVersion as getHighestSatisfyingVersionFromNdjson,
+  getLatestVersion as getLatestVersionFromNdjson,
+} from "./versions-client";
 
 export function tryGetFromToolCache(
   arch: Architecture,
@@ -29,85 +34,73 @@ export function tryGetFromToolCache(
   return { installedPath, version: resolvedVersion };
 }
 
-export async function downloadVersion(
+export async function downloadVersionFromNdjson(
   platform: Platform,
   arch: Architecture,
   version: string,
   checkSum: string | undefined,
   githubToken: string,
-  manifestUrl?: string,
 ): Promise<{ version: string; cachedToolDir: string }> {
-  const artifact = await getArtifact(version, arch, platform, manifestUrl);
+  const artifact = await getArtifactFromNdjson(version, arch, platform);
 
   if (!artifact) {
     throw new Error(
-      getMissingArtifactMessage(version, arch, platform, manifestUrl),
+      `Could not find artifact for version ${version}, arch ${arch}, platform ${platform} in ${VERSIONS_NDJSON_URL} .`,
     );
   }
 
   // For the default astral-sh/versions source, checksum validation relies on
-  // user input or the built-in KNOWN_CHECKSUMS table, not manifest sha256 values.
+  // user input or the built-in KNOWN_CHECKSUMS table, not NDJSON sha256 values.
-  const checksum =
+  return await downloadVersion(
-    manifestUrl === undefined
+    artifact.url,
-      ? checkSum
-      : resolveChecksum(checkSum, artifact.checksum);
-
-  const mirrorUrl = rewriteToMirror(artifact.downloadUrl);
-  const downloadUrl = mirrorUrl ?? artifact.downloadUrl;
-  // Don't send the GitHub token to the Astral mirror.
-  const downloadToken = mirrorUrl !== undefined ? undefined : githubToken;
-
-  try {
-    return await downloadArtifact(
-      downloadUrl,
     `uv-${arch}-${platform}`,
     platform,
     arch,
     version,
-      checksum,
+    checkSum,
-      downloadToken,
+    githubToken,
+  );
+}
+
+export async function downloadVersionFromManifest(
+  manifestUrl: string,
+  platform: Platform,
+  arch: Architecture,
+  version: string,
+  checkSum: string | undefined,
+  githubToken: string,
+): Promise<{ version: string; cachedToolDir: string }> {
+  const artifact = await getManifestArtifact(
+    manifestUrl,
+    version,
+    arch,
+    platform,
+  );
+  if (!artifact) {
+    throw new Error(
+      `manifest-file does not contain version ${version}, arch ${arch}, platform ${platform}.`,
     );
-  } catch (err) {
-    if (mirrorUrl === undefined) {
-      throw err;
   }
 
-    core.warning(
+  return await downloadVersion(
-      `Failed to download from mirror, falling back to GitHub Releases: ${(err as Error).message}`,
-    );
-
-    return await downloadArtifact(
     artifact.downloadUrl,
     `uv-${arch}-${platform}`,
     platform,
     arch,
     version,
-      checksum,
+    resolveChecksum(checkSum, artifact.checksum),
     githubToken,
   );
-  }
 }
 
-/**
+async function downloadVersion(
- * Rewrite a GitHub Releases URL to the Astral mirror.
- * Returns `undefined` if the URL does not match the expected GitHub prefix.
- */
-export function rewriteToMirror(url: string): string | undefined {
-  if (!url.startsWith(GITHUB_RELEASES_PREFIX)) {
-    return undefined;
-  }
-
-  return ASTRAL_MIRROR_PREFIX + url.slice(GITHUB_RELEASES_PREFIX.length);
-}
-
-async function downloadArtifact(
   downloadUrl: string,
   artifactName: string,
   platform: Platform,
   arch: Architecture,
   version: string,
   checksum: string | undefined,
-  githubToken: string | undefined,
+  githubToken: string,
 ): Promise<{ version: string; cachedToolDir: string }> {
   core.info(`Downloading uv from "${downloadUrl}" ...`);
   const downloadPath = await tc.downloadTool(
@@ -144,26 +137,13 @@ async function downloadArtifact(
     version,
     arch,
   );
-  return { cachedToolDir, version };
+  return { cachedToolDir, version: version };
-}
-
-function getMissingArtifactMessage(
-  version: string,
-  arch: Architecture,
-  platform: Platform,
-  manifestUrl?: string,
-): string {
-  if (manifestUrl === undefined) {
-    return `Could not find artifact for version ${version}, arch ${arch}, platform ${platform} in ${VERSIONS_MANIFEST_URL} .`;
-  }
-
-  return `manifest-file does not contain version ${version}, arch ${arch}, platform ${platform}.`;
 }
 
 function resolveChecksum(
   checkSum: string | undefined,
-  manifestChecksum: string,
+  manifestChecksum?: string,
-): string {
+): string | undefined {
   return checkSum !== undefined && checkSum !== ""
     ? checkSum
     : manifestChecksum;
@@ -179,31 +159,46 @@ export async function resolveVersion(
   resolutionStrategy: "highest" | "lowest" = "highest",
 ): Promise<string> {
   core.debug(`Resolving version: ${versionInput}`);
+  let version: string;
   const isSimpleMinimumVersionSpecifier =
     versionInput.includes(">") && !versionInput.includes(",");
   const resolveVersionSpecifierToLatest =
     isSimpleMinimumVersionSpecifier && resolutionStrategy === "highest";
-
   if (resolveVersionSpecifierToLatest) {
     core.info("Found minimum version specifier, using latest version");
   }
-
+  if (manifestUrl !== undefined) {
-  const version =
+    version =
       versionInput === "latest" || resolveVersionSpecifierToLatest
-      ? await getLatestVersion(manifestUrl)
+        ? await getLatestVersionInManifest(manifestUrl)
         : versionInput;
-
+  } else {
+    version =
+      versionInput === "latest" || resolveVersionSpecifierToLatest
+        ? await getLatestVersionFromNdjson()
+        : versionInput;
+  }
   if (tc.isExplicitVersion(version)) {
     core.debug(`Version ${version} is an explicit version.`);
-    if (
+    if (resolveVersionSpecifierToLatest) {
-      resolveVersionSpecifierToLatest &&
+      if (!pep440.satisfies(version, versionInput)) {
-      !pep440.satisfies(version, versionInput)
-    ) {
         throw new Error(`No version found for ${versionInput}`);
       }
+    }
     return version;
   }
 
+  if (manifestUrl === undefined && resolutionStrategy === "highest") {
+    const resolvedVersion =
+      await getHighestSatisfyingVersionFromNdjson(version);
+    if (resolvedVersion !== undefined) {
+      core.debug(`Resolved version from NDJSON stream: ${resolvedVersion}`);
+      return resolvedVersion;
+    }
+
+    throw new Error(`No version found for ${version}`);
+  }
+
   const availableVersions = await getAvailableVersions(manifestUrl);
   core.debug(`Available versions: ${availableVersions}`);
   const resolvedVersion =
@@ -225,11 +220,11 @@ async function getAvailableVersions(
     core.info(
       `Getting available versions from manifest-file ${manifestUrl} ...`,
     );
-  } else {
+    return await getAllManifestVersions(manifestUrl);
-    core.info(`Getting available versions from ${VERSIONS_MANIFEST_URL} ...`);
   }
 
-  return await getAllVersions(manifestUrl);
+  core.info(`Getting available versions from ${VERSIONS_NDJSON_URL} ...`);
+  return await getAllVersionsFromNdjson();
 }
 
 function maxSatisfying(

src/download/legacy-version-manifest.ts

@@ -0,0 +1,80 @@
+import * as core from "@actions/core";
+
+export interface ManifestEntry {
+  arch: string;
+  platform: string;
+  version: string;
+  downloadUrl: string;
+  checksum?: string;
+  variant?: string;
+  archiveFormat?: string;
+}
+
+interface LegacyManifestEntry {
+  arch: string;
+  platform: string;
+  version: string;
+  downloadUrl: string;
+  checksum?: string;
+}
+
+const warnedLegacyManifestUrls = new Set<string>();
+
+export function parseLegacyManifestEntries(
+  parsedEntries: unknown[],
+  manifestUrl: string,
+): ManifestEntry[] {
+  warnAboutLegacyManifestFormat(manifestUrl);
+
+  return parsedEntries.map((entry, index) => {
+    if (!isLegacyManifestEntry(entry)) {
+      throw new Error(
+        `Invalid legacy manifest-file entry at index ${index} in ${manifestUrl}.`,
+      );
+    }
+
+    return {
+      arch: entry.arch,
+      checksum: entry.checksum,
+      downloadUrl: entry.downloadUrl,
+      platform: entry.platform,
+      version: entry.version,
+    };
+  });
+}
+
+export function clearLegacyManifestWarnings(): void {
+  warnedLegacyManifestUrls.clear();
+}
+
+function warnAboutLegacyManifestFormat(manifestUrl: string): void {
+  if (warnedLegacyManifestUrls.has(manifestUrl)) {
+    return;
+  }
+
+  warnedLegacyManifestUrls.add(manifestUrl);
+  core.warning(
+    `manifest-file ${manifestUrl} uses the legacy JSON array format, which is deprecated. Please migrate to the astral-sh/versions NDJSON format before the next major release.`,
+  );
+}
+
+function isLegacyManifestEntry(value: unknown): value is LegacyManifestEntry {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  const checksumIsValid =
+    typeof value.checksum === "string" || value.checksum === undefined;
+
+  return (
+    typeof value.arch === "string" &&
+    checksumIsValid &&
+    typeof value.downloadUrl === "string" &&
+    typeof value.platform === "string" &&
+    typeof value.version === "string"
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}

src/download/manifest.ts

@@ -1,208 +0,0 @@
-import * as core from "@actions/core";
-import * as semver from "semver";
-import { VERSIONS_MANIFEST_URL } from "../utils/constants";
-import { fetch } from "../utils/fetch";
-import { selectDefaultVariant } from "./variant-selection";
-
-export interface ManifestArtifact {
-  platform: string;
-  variant?: string;
-  url: string;
-  archive_format: string;
-  sha256: string;
-}
-
-export interface ManifestVersion {
-  version: string;
-  artifacts: ManifestArtifact[];
-}
-
-export interface ArtifactResult {
-  archiveFormat: string;
-  checksum: string;
-  downloadUrl: string;
-}
-
-const cachedManifestData = new Map<string, ManifestVersion[]>();
-
-export async function fetchManifest(
-  manifestUrl: string = VERSIONS_MANIFEST_URL,
-): Promise<ManifestVersion[]> {
-  const cachedVersions = cachedManifestData.get(manifestUrl);
-  if (cachedVersions !== undefined) {
-    core.debug(`Using cached manifest data from ${manifestUrl}`);
-    return cachedVersions;
-  }
-
-  core.info(`Fetching manifest data from ${manifestUrl} ...`);
-  const response = await fetch(manifestUrl, {});
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch manifest data: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  const body = await response.text();
-  const versions = parseManifest(body, manifestUrl);
-  cachedManifestData.set(manifestUrl, versions);
-  return versions;
-}
-
-export function parseManifest(
-  data: string,
-  sourceDescription: string,
-): ManifestVersion[] {
-  const trimmed = data.trim();
-  if (trimmed === "") {
-    throw new Error(`Manifest at ${sourceDescription} is empty.`);
-  }
-
-  if (trimmed.startsWith("[")) {
-    throw new Error(
-      `Legacy JSON array manifests are no longer supported in ${sourceDescription}. Use the astral-sh/versions manifest format instead.`,
-    );
-  }
-
-  const versions: ManifestVersion[] = [];
-
-  for (const [index, line] of data.split("\n").entries()) {
-    const record = line.trim();
-    if (record === "") {
-      continue;
-    }
-
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(record);
-    } catch (error) {
-      throw new Error(
-        `Failed to parse manifest data from ${sourceDescription} at line ${index + 1}: ${(error as Error).message}`,
-      );
-    }
-
-    if (!isManifestVersion(parsed)) {
-      throw new Error(
-        `Invalid manifest record in ${sourceDescription} at line ${index + 1}.`,
-      );
-    }
-
-    versions.push(parsed);
-  }
-
-  if (versions.length === 0) {
-    throw new Error(`No manifest data found in ${sourceDescription}.`);
-  }
-
-  return versions;
-}
-
-export async function getLatestVersion(
-  manifestUrl: string = VERSIONS_MANIFEST_URL,
-): Promise<string> {
-  const versions = await fetchManifest(manifestUrl);
-  const [firstVersion, ...remainingVersions] = versions.map(
-    (versionData) => versionData.version,
-  );
-
-  if (firstVersion === undefined) {
-    throw new Error("No versions found in manifest data");
-  }
-
-  const latestVersion = remainingVersions.reduce(
-    (latest, current) => (semver.gt(current, latest) ? current : latest),
-    firstVersion,
-  );
-
-  core.debug(`Latest version from manifest: ${latestVersion}`);
-  return latestVersion;
-}
-
-export async function getAllVersions(
-  manifestUrl: string = VERSIONS_MANIFEST_URL,
-): Promise<string[]> {
-  const versions = await fetchManifest(manifestUrl);
-  return versions.map((versionData) => versionData.version);
-}
-
-export async function getArtifact(
-  version: string,
-  arch: string,
-  platform: string,
-  manifestUrl: string = VERSIONS_MANIFEST_URL,
-): Promise<ArtifactResult | undefined> {
-  const versions = await fetchManifest(manifestUrl);
-  const versionData = versions.find(
-    (candidate) => candidate.version === version,
-  );
-  if (!versionData) {
-    core.debug(`Version ${version} not found in manifest ${manifestUrl}`);
-    return undefined;
-  }
-
-  const targetPlatform = `${arch}-${platform}`;
-  const matchingArtifacts = versionData.artifacts.filter(
-    (candidate) => candidate.platform === targetPlatform,
-  );
-
-  if (matchingArtifacts.length === 0) {
-    core.debug(
-      `Artifact for ${targetPlatform} not found in version ${version}. Available platforms: ${versionData.artifacts
-        .map((candidate) => candidate.platform)
-        .join(", ")}`,
-    );
-    return undefined;
-  }
-
-  const artifact = selectDefaultVariant(
-    matchingArtifacts,
-    `Multiple artifacts found for ${targetPlatform} in version ${version}`,
-  );
-
-  return {
-    archiveFormat: artifact.archive_format,
-    checksum: artifact.sha256,
-    downloadUrl: artifact.url,
-  };
-}
-
-export function clearManifestCache(manifestUrl?: string): void {
-  if (manifestUrl === undefined) {
-    cachedManifestData.clear();
-    return;
-  }
-
-  cachedManifestData.delete(manifestUrl);
-}
-
-function isManifestVersion(value: unknown): value is ManifestVersion {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  if (typeof value.version !== "string" || !Array.isArray(value.artifacts)) {
-    return false;
-  }
-
-  return value.artifacts.every(isManifestArtifact);
-}
-
-function isManifestArtifact(value: unknown): value is ManifestArtifact {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  const variantIsValid =
-    typeof value.variant === "string" || value.variant === undefined;
-
-  return (
-    typeof value.archive_format === "string" &&
-    typeof value.platform === "string" &&
-    typeof value.sha256 === "string" &&
-    typeof value.url === "string" &&
-    variantIsValid
-  );
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}

src/download/version-manifest.ts

@@ -0,0 +1,169 @@
+import * as core from "@actions/core";
+import * as semver from "semver";
+import { fetch } from "../utils/fetch";
+import {
+  clearLegacyManifestWarnings,
+  type ManifestEntry,
+  parseLegacyManifestEntries,
+} from "./legacy-version-manifest";
+import { selectDefaultVariant } from "./variant-selection";
+import { type NdjsonVersion, parseVersionData } from "./versions-client";
+
+export interface ManifestArtifact {
+  downloadUrl: string;
+  checksum?: string;
+  archiveFormat?: string;
+}
+
+const cachedManifestEntries = new Map<string, ManifestEntry[]>();
+
+export async function getLatestKnownVersion(
+  manifestUrl: string,
+): Promise<string> {
+  const versions = await getAllVersions(manifestUrl);
+  const latestVersion = versions.reduce((latest, current) =>
+    semver.gt(current, latest) ? current : latest,
+  );
+
+  return latestVersion;
+}
+
+export async function getAllVersions(manifestUrl: string): Promise<string[]> {
+  const manifestEntries = await getManifestEntries(manifestUrl);
+  return [...new Set(manifestEntries.map((entry) => entry.version))];
+}
+
+export async function getManifestArtifact(
+  manifestUrl: string,
+  version: string,
+  arch: string,
+  platform: string,
+): Promise<ManifestArtifact | undefined> {
+  const manifestEntries = await getManifestEntries(manifestUrl);
+  const entry = selectManifestEntry(
+    manifestEntries,
+    manifestUrl,
+    version,
+    arch,
+    platform,
+  );
+
+  if (!entry) {
+    return undefined;
+  }
+
+  return {
+    archiveFormat: entry.archiveFormat,
+    checksum: entry.checksum,
+    downloadUrl: entry.downloadUrl,
+  };
+}
+
+export function clearManifestCache(): void {
+  cachedManifestEntries.clear();
+  clearLegacyManifestWarnings();
+}
+
+async function getManifestEntries(
+  manifestUrl: string,
+): Promise<ManifestEntry[]> {
+  const cachedEntries = cachedManifestEntries.get(manifestUrl);
+  if (cachedEntries !== undefined) {
+    core.debug(`Using cached manifest-file from: ${manifestUrl}`);
+    return cachedEntries;
+  }
+
+  core.info(`Fetching manifest-file from: ${manifestUrl}`);
+  const response = await fetch(manifestUrl, {});
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch manifest-file: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const data = await response.text();
+  const parsedEntries = parseManifestEntries(data, manifestUrl);
+  cachedManifestEntries.set(manifestUrl, parsedEntries);
+
+  return parsedEntries;
+}
+
+function parseManifestEntries(
+  data: string,
+  manifestUrl: string,
+): ManifestEntry[] {
+  const trimmed = data.trim();
+  if (trimmed === "") {
+    throw new Error(`manifest-file at ${manifestUrl} is empty.`);
+  }
+
+  const parsedAsJson = tryParseJson(trimmed);
+  if (Array.isArray(parsedAsJson)) {
+    return parseLegacyManifestEntries(parsedAsJson, manifestUrl);
+  }
+
+  const versions = parseVersionData(trimmed, manifestUrl);
+  return mapNdjsonVersionsToManifestEntries(versions, manifestUrl);
+}
+
+function mapNdjsonVersionsToManifestEntries(
+  versions: NdjsonVersion[],
+  manifestUrl: string,
+): ManifestEntry[] {
+  const manifestEntries: ManifestEntry[] = [];
+
+  for (const versionData of versions) {
+    for (const artifact of versionData.artifacts) {
+      const [arch, ...platformParts] = artifact.platform.split("-");
+      if (arch === undefined || platformParts.length === 0) {
+        throw new Error(
+          `Invalid artifact platform '${artifact.platform}' in manifest-file ${manifestUrl}.`,
+        );
+      }
+
+      manifestEntries.push({
+        arch,
+        archiveFormat: artifact.archive_format,
+        checksum: artifact.sha256,
+        downloadUrl: artifact.url,
+        platform: platformParts.join("-"),
+        variant: artifact.variant,
+        version: versionData.version,
+      });
+    }
+  }
+
+  return manifestEntries;
+}
+
+function selectManifestEntry(
+  manifestEntries: ManifestEntry[],
+  manifestUrl: string,
+  version: string,
+  arch: string,
+  platform: string,
+): ManifestEntry | undefined {
+  const matches = manifestEntries.filter(
+    (candidate) =>
+      candidate.version === version &&
+      candidate.arch === arch &&
+      candidate.platform === platform,
+  );
+
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  return selectDefaultVariant(
+    matches,
+    `manifest-file ${manifestUrl} contains multiple artifacts for version ${version}, arch ${arch}, platform ${platform}`,
+  );
+}
+
+function tryParseJson(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return undefined;
+  }
+}

src/download/versions-client.ts

@@ -0,0 +1,380 @@
+import * as core from "@actions/core";
+import * as pep440 from "@renovatebot/pep440";
+import * as semver from "semver";
+import { VERSIONS_NDJSON_URL } from "../utils/constants";
+import { fetch } from "../utils/fetch";
+import { selectDefaultVariant } from "./variant-selection";
+
+export interface NdjsonArtifact {
+  platform: string;
+  variant?: string;
+  url: string;
+  archive_format: string;
+  sha256: string;
+}
+
+export interface NdjsonVersion {
+  version: string;
+  artifacts: NdjsonArtifact[];
+}
+
+export interface ArtifactResult {
+  url: string;
+  sha256: string;
+  archiveFormat: string;
+}
+
+const cachedVersionData = new Map<string, NdjsonVersion[]>();
+const cachedLatestVersionData = new Map<string, NdjsonVersion>();
+const cachedVersionLookup = new Map<string, Map<string, NdjsonVersion>>();
+
+export async function fetchVersionData(
+  url: string = VERSIONS_NDJSON_URL,
+): Promise<NdjsonVersion[]> {
+  const cachedVersions = cachedVersionData.get(url);
+  if (cachedVersions !== undefined) {
+    core.debug(`Using cached NDJSON version data from ${url}`);
+    return cachedVersions;
+  }
+
+  core.info(`Fetching version data from ${url} ...`);
+  const { versions } = await readVersionData(url);
+  cacheCompleteVersionData(url, versions);
+  return versions;
+}
+
+export function parseVersionData(
+  data: string,
+  sourceDescription: string,
+): NdjsonVersion[] {
+  const versions: NdjsonVersion[] = [];
+
+  for (const [index, line] of data.split("\n").entries()) {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+
+    versions.push(parseVersionLine(trimmed, sourceDescription, index + 1));
+  }
+
+  if (versions.length === 0) {
+    throw new Error(`No version data found in ${sourceDescription}.`);
+  }
+
+  return versions;
+}
+
+export async function getLatestVersion(): Promise<string> {
+  const cachedVersions = cachedVersionData.get(VERSIONS_NDJSON_URL);
+  const cachedLatestVersion =
+    cachedVersions?.[0] ?? cachedLatestVersionData.get(VERSIONS_NDJSON_URL);
+  if (cachedLatestVersion !== undefined) {
+    core.debug(
+      `Latest version from NDJSON cache: ${cachedLatestVersion.version}`,
+    );
+    return cachedLatestVersion.version;
+  }
+
+  const latestVersion = await findVersionData(() => true);
+  if (!latestVersion) {
+    throw new Error("No versions found in NDJSON data");
+  }
+
+  core.debug(`Latest version from NDJSON: ${latestVersion.version}`);
+  return latestVersion.version;
+}
+
+export async function getAllVersions(): Promise<string[]> {
+  const versions = await fetchVersionData();
+  return versions.map((versionData) => versionData.version);
+}
+
+export async function getHighestSatisfyingVersion(
+  versionSpecifier: string,
+  url: string = VERSIONS_NDJSON_URL,
+): Promise<string | undefined> {
+  const matchedVersion = await findVersionData(
+    (candidate) => versionSatisfies(candidate.version, versionSpecifier),
+    url,
+  );
+
+  return matchedVersion?.version;
+}
+
+export async function getArtifact(
+  version: string,
+  arch: string,
+  platform: string,
+): Promise<ArtifactResult | undefined> {
+  const versionData = await getVersionData(version);
+  if (!versionData) {
+    core.debug(`Version ${version} not found in NDJSON data`);
+    return undefined;
+  }
+
+  const targetPlatform = `${arch}-${platform}`;
+  const matchingArtifacts = versionData.artifacts.filter(
+    (candidate) => candidate.platform === targetPlatform,
+  );
+
+  if (matchingArtifacts.length === 0) {
+    core.debug(
+      `Artifact for ${targetPlatform} not found in version ${version}. Available platforms: ${versionData.artifacts
+        .map((candidate) => candidate.platform)
+        .join(", ")}`,
+    );
+    return undefined;
+  }
+
+  const artifact = selectArtifact(matchingArtifacts, version, targetPlatform);
+
+  return {
+    archiveFormat: artifact.archive_format,
+    sha256: artifact.sha256,
+    url: artifact.url,
+  };
+}
+
+export function clearCache(url?: string): void {
+  if (url === undefined) {
+    cachedVersionData.clear();
+    cachedLatestVersionData.clear();
+    cachedVersionLookup.clear();
+    return;
+  }
+
+  cachedVersionData.delete(url);
+  cachedLatestVersionData.delete(url);
+  cachedVersionLookup.delete(url);
+}
+
+function selectArtifact(
+  artifacts: NdjsonArtifact[],
+  version: string,
+  targetPlatform: string,
+): NdjsonArtifact {
+  return selectDefaultVariant(
+    artifacts,
+    `Multiple artifacts found for ${targetPlatform} in version ${version}`,
+  );
+}
+
+async function getVersionData(
+  version: string,
+  url: string = VERSIONS_NDJSON_URL,
+): Promise<NdjsonVersion | undefined> {
+  const cachedVersions = cachedVersionData.get(url);
+  if (cachedVersions !== undefined) {
+    return cachedVersions.find((candidate) => candidate.version === version);
+  }
+
+  const cachedVersion = cachedVersionLookup.get(url)?.get(version);
+  if (cachedVersion !== undefined) {
+    return cachedVersion;
+  }
+
+  return await findVersionData(
+    (candidate) => candidate.version === version,
+    url,
+  );
+}
+
+async function findVersionData(
+  predicate: (versionData: NdjsonVersion) => boolean,
+  url: string = VERSIONS_NDJSON_URL,
+): Promise<NdjsonVersion | undefined> {
+  const cachedVersions = cachedVersionData.get(url);
+  if (cachedVersions !== undefined) {
+    return cachedVersions.find(predicate);
+  }
+
+  const { matchedVersion, versions, complete } = await readVersionData(
+    url,
+    predicate,
+  );
+
+  if (complete) {
+    cacheCompleteVersionData(url, versions);
+  }
+
+  return matchedVersion;
+}
+
+async function readVersionData(
+  url: string,
+  stopWhen?: (versionData: NdjsonVersion) => boolean,
+): Promise<{
+  complete: boolean;
+  matchedVersion: NdjsonVersion | undefined;
+  versions: NdjsonVersion[];
+}> {
+  const response = await fetch(url, {});
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch version data: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  if (response.body === null) {
+    const body = await response.text();
+    const versions = parseVersionData(body, url);
+    const matchedVersion = stopWhen
+      ? versions.find((candidate) => stopWhen(candidate))
+      : undefined;
+    return { complete: true, matchedVersion, versions };
+  }
+
+  const versions: NdjsonVersion[] = [];
+  let lineNumber = 0;
+  let matchedVersion: NdjsonVersion | undefined;
+  let buffer = "";
+  const decoder = new TextDecoder();
+  const reader = response.body.getReader();
+
+  const processLine = (line: string): boolean => {
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      return false;
+    }
+
+    lineNumber += 1;
+    const versionData = parseVersionLine(trimmed, url, lineNumber);
+    if (versions.length === 0) {
+      cachedLatestVersionData.set(url, versionData);
+    }
+
+    versions.push(versionData);
+    cacheVersion(url, versionData);
+
+    if (stopWhen?.(versionData) === true) {
+      matchedVersion = versionData;
+      return true;
+    }
+
+    return false;
+  };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      buffer += decoder.decode();
+      break;
+    }
+
+    buffer += decoder.decode(value, { stream: true });
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+
+      if (processLine(line)) {
+        await reader.cancel();
+        return { complete: false, matchedVersion, versions };
+      }
+
+      newlineIndex = buffer.indexOf("\n");
+    }
+  }
+
+  if (buffer.trim() !== "" && processLine(buffer)) {
+    return { complete: true, matchedVersion, versions };
+  }
+
+  if (versions.length === 0) {
+    throw new Error(`No version data found in ${url}.`);
+  }
+
+  return { complete: true, matchedVersion, versions };
+}
+
+function cacheCompleteVersionData(
+  url: string,
+  versions: NdjsonVersion[],
+): void {
+  cachedVersionData.set(url, versions);
+
+  if (versions[0] !== undefined) {
+    cachedLatestVersionData.set(url, versions[0]);
+  }
+
+  const versionLookup = new Map<string, NdjsonVersion>();
+  for (const versionData of versions) {
+    versionLookup.set(versionData.version, versionData);
+  }
+
+  cachedVersionLookup.set(url, versionLookup);
+}
+
+function cacheVersion(url: string, versionData: NdjsonVersion): void {
+  let versionLookup = cachedVersionLookup.get(url);
+  if (versionLookup === undefined) {
+    versionLookup = new Map<string, NdjsonVersion>();
+    cachedVersionLookup.set(url, versionLookup);
+  }
+
+  versionLookup.set(versionData.version, versionData);
+}
+
+function parseVersionLine(
+  line: string,
+  sourceDescription: string,
+  lineNumber: number,
+): NdjsonVersion {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse version data from ${sourceDescription} at line ${lineNumber}: ${(error as Error).message}`,
+    );
+  }
+
+  if (!isNdjsonVersion(parsed)) {
+    throw new Error(
+      `Invalid NDJSON record in ${sourceDescription} at line ${lineNumber}.`,
+    );
+  }
+
+  return parsed;
+}
+
+function versionSatisfies(version: string, versionSpecifier: string): boolean {
+  return (
+    semver.satisfies(version, versionSpecifier) ||
+    pep440.satisfies(version, versionSpecifier)
+  );
+}
+
+function isNdjsonVersion(value: unknown): value is NdjsonVersion {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  if (typeof value.version !== "string" || !Array.isArray(value.artifacts)) {
+    return false;
+  }
+
+  return value.artifacts.every(isNdjsonArtifact);
+}
+
+function isNdjsonArtifact(value: unknown): value is NdjsonArtifact {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  const variantIsValid =
+    typeof value.variant === "string" || value.variant === undefined;
+
+  return (
+    typeof value.archive_format === "string" &&
+    typeof value.platform === "string" &&
+    typeof value.sha256 === "string" &&
+    typeof value.url === "string" &&
+    variantIsValid
+  );
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}

src/setup-uv.ts

@@ -4,7 +4,8 @@ import * as core from "@actions/core";
 import * as exec from "@actions/exec";
 import { restoreCache } from "./cache/restore-cache";
 import {
-  downloadVersion,
+  downloadVersionFromManifest,
+  downloadVersionFromNdjson,
   resolveVersion,
   tryGetFromToolCache,
 } from "./download/download-version";
@@ -131,7 +132,7 @@ async function setupUv(
   checkSum: string | undefined,
   githubToken: string,
 ): Promise<{ uvDir: string; version: string }> {
-  const resolvedVersion = await determineVersion();
+  const resolvedVersion = await determineVersion(manifestFile);
   const toolCacheResult = tryGetFromToolCache(arch, resolvedVersion);
   if (toolCacheResult.installedPath) {
     core.info(`Found uv in tool-cache for ${toolCacheResult.version}`);
@@ -141,34 +142,36 @@ async function setupUv(
     };
   }
 
-  const downloadResult = await downloadVersion(
+  const downloadVersionResult =
+    manifestFile !== undefined
+      ? await downloadVersionFromManifest(
+          manifestFile,
+          platform,
+          arch,
+          resolvedVersion,
+          checkSum,
+          githubToken,
+        )
+      : await downloadVersionFromNdjson(
           platform,
           arch,
           resolvedVersion,
           checkSum,
           githubToken,
-    manifestFile,
         );
 
   return {
-    uvDir: downloadResult.cachedToolDir,
+    uvDir: downloadVersionResult.cachedToolDir,
-    version: downloadResult.version,
+    version: downloadVersionResult.version,
   };
 }
 
-async function determineVersion(): Promise<string> {
+async function determineVersion(
-  return await resolveVersion(
+  manifestFile: string | undefined,
-    getRequestedVersion(),
+): Promise<string> {
-    manifestFile,
-    resolutionStrategy,
-  );
-}
-
-function getRequestedVersion(): string {
   if (versionInput !== "") {
-    return versionInput;
+    return await resolveVersion(versionInput, manifestFile, resolutionStrategy);
   }
-
   if (versionFileInput !== "") {
     const versionFromFile = getUvVersionFromFile(versionFileInput);
     if (versionFromFile === undefined) {
@@ -176,23 +179,28 @@ function getRequestedVersion(): string {
         `Could not determine uv version from file: ${versionFileInput}`,
       );
     }
-    return versionFromFile;
+    return await resolveVersion(
+      versionFromFile,
+      manifestFile,
+      resolutionStrategy,
+    );
   }
-
   const versionFromUvToml = getUvVersionFromFile(
     `${workingDirectory}${path.sep}uv.toml`,
   );
   const versionFromPyproject = getUvVersionFromFile(
     `${workingDirectory}${path.sep}pyproject.toml`,
   );
-
   if (versionFromUvToml === undefined && versionFromPyproject === undefined) {
     core.info(
       "Could not determine uv version from uv.toml or pyproject.toml. Falling back to latest.",
     );
   }
-
+  return await resolveVersion(
-  return versionFromUvToml || versionFromPyproject || "latest";
+    versionFromUvToml || versionFromPyproject || "latest",
+    manifestFile,
+    resolutionStrategy,
+  );
 }
 
 function addUvToPathAndOutput(cachedPath: string): void {

src/update-known-checksums.ts

@@ -6,10 +6,10 @@ import {
   updateChecksums,
 } from "./download/checksum/update-known-checksums";
 import {
-  fetchManifest,
+  fetchVersionData,
   getLatestVersion,
-  type ManifestVersion,
+  type NdjsonVersion,
-} from "./download/manifest";
+} from "./download/versions-client";
 
 const VERSION_IN_CHECKSUM_KEY_PATTERN =
   /-(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)$/;
@@ -32,8 +32,8 @@ async function run(): Promise<void> {
     return;
   }
 
-  const versions = await fetchManifest();
+  const versions = await fetchVersionData();
-  const checksumEntries = extractChecksumsFromManifest(versions);
+  const checksumEntries = extractChecksumsFromNdjson(versions);
   await updateChecksums(checksumFilePath, checksumEntries);
 
   core.setOutput("latest-version", latestVersion);
@@ -61,8 +61,8 @@ function extractVersionFromChecksumKey(key: string): string | undefined {
   return key.match(VERSION_IN_CHECKSUM_KEY_PATTERN)?.[1];
 }
 
-function extractChecksumsFromManifest(
+function extractChecksumsFromNdjson(
-  versions: ManifestVersion[],
+  versions: NdjsonVersion[],
 ): ChecksumEntry[] {
   const checksums: ChecksumEntry[] = [];
 

src/utils/constants.ts

@@ -1,13 +1,5 @@
 export const TOOL_CACHE_NAME = "uv";
 export const STATE_UV_PATH = "uv-path";
 export const STATE_UV_VERSION = "uv-version";
-export const VERSIONS_MANIFEST_URL =
+export const VERSIONS_NDJSON_URL =
   "https://raw.githubusercontent.com/astral-sh/versions/main/v1/uv.ndjson";
-
-/** GitHub Releases URL prefix for uv artifacts. */
-export const GITHUB_RELEASES_PREFIX =
-  "https://github.com/astral-sh/uv/releases/download/";
-
-/** Astral mirror URL prefix that fronts GitHub Releases for uv artifacts. */
-export const ASTRAL_MIRROR_PREFIX =
-  "https://releases.astral.sh/github/uv/releases/download/";