fix exact downloader selection for itag jobs

src/main/kotlin/dev/typetype/downloader/services/JobOptionsNormalizer.kt

@@ -87,7 +87,7 @@ object JobOptionsNormalizer {
     }
 
     private fun normalizeCodec(raw: String): String {
-        val value = raw.trim().lowercase()
+        val value = raw.trim()
         if (value.isBlank()) return ""
         return if (value.all { it.isLetterOrDigit() || it == '.' || it == '_' || it == '-' }) value else ""
     }

src/main/kotlin/dev/typetype/downloader/services/JobWorker.kt

@@ -38,7 +38,7 @@ class JobWorker(
         redis.setex(redisJobKey(id), config.jobTtlSeconds, "running")
         try {
             val startedAt = System.nanoTime()
-            val token = tokenServiceClient.fetchForUrl(job.url)
+            val token = if (shouldUseTokenFor(options)) tokenServiceClient.fetchForUrl(job.url) else null
             val result = ytDlpService.download(job.url, token, options) {
                 jobsRepository.getById(id)?.status != JobStatus.RUNNING
             }
@@ -84,6 +84,13 @@ class JobWorker(
         return runCatching { JobOptionsCodec.decode(row.optionsJson) }.map(JobOptionsNormalizer::normalize).getOrElse { JobOptions() }
     }
 
+    private fun shouldUseTokenFor(options: JobOptions): Boolean {
+        val hasExactSelection = options.videoItag.isNotBlank() || options.audioItag.isNotBlank() ||
+            options.height != null || options.fps != null || options.videoCodec.isNotBlank() ||
+            options.audioCodec.isNotBlank() || options.bitrate != null
+        return !hasExactSelection
+    }
+
     private fun uploadArtifact(cacheKey: String, filePath: java.nio.file.Path): StorageArtifact {
         val expiresAt = Instant.now().plusSeconds(config.s3ArtifactTtlSeconds)
         val extension = filePath.fileName.toString().substringAfterLast('.', "bin")

src/main/kotlin/dev/typetype/downloader/services/YtDlpOptionResolver.kt

@@ -10,7 +10,7 @@ object YtDlpOptionResolver {
     fun audioSelector(options: JobOptions): String {
         val audioItag = options.audioItag
         if (audioItag.isNotBlank()) {
-            val strict = "ba[format_id=$audioItag]/b[format_id=$audioItag]"
+            val strict = "ba[format_id='$audioItag']/b[format_id='$audioItag']"
             return if (options.allowQualityFallback) "$strict/bestaudio/best" else strict
         }
         return if (options.quality.lowercase() == "worst") "worstaudio/worst" else "bestaudio/best"
@@ -33,8 +33,8 @@ object YtDlpOptionResolver {
     private fun exactVideoSelector(options: JobOptions): String {
         val videoFilters = mutableListOf<String>()
         val audioFilters = mutableListOf<String>()
-        options.videoItag.takeIf { it.isNotBlank() }?.let { videoFilters += "[format_id=$it]" }
-        options.audioItag.takeIf { it.isNotBlank() }?.let { audioFilters += "[format_id=$it]" }
+        options.videoItag.takeIf { it.isNotBlank() }?.let { videoFilters += "[format_id='$it']" }
+        options.audioItag.takeIf { it.isNotBlank() }?.let { audioFilters += "[format_id='$it']" }
         options.height?.let { videoFilters += "[height=$it]" }
         options.fps?.let { videoFilters += "[fps=$it]" }
         options.videoCodec.takeIf { it.isNotBlank() }?.let { videoFilters += "[vcodec^=$it]" }
@@ -43,7 +43,7 @@ object YtDlpOptionResolver {
         val video = "bv*${videoFilters.joinToString("")}"
         val audio = "ba${audioFilters.joinToString("")}"
         return if (options.videoItag.isNotBlank() && options.audioItag.isBlank()) {
-            "$video+$audio/b[format_id=${options.videoItag}]"
+            "$video+$audio/b[format_id='${options.videoItag}']"
         } else {
             "$video+$audio"
         }

src/test/kotlin/dev/typetype/downloader/services/JobOptionsNormalizerTest.kt

@@ -98,4 +98,12 @@ class JobOptionsNormalizerTest {
         assertEquals("mp4a.40.2", normalized.audioCodec)
         assertEquals(null, normalized.bitrate)
     }
+
+    @Test
+    fun `keeps codec case for av1 profile strings`() {
+        val normalized = JobOptionsNormalizer.normalize(
+            JobOptions(videoCodec = "av01.0.08M.08"),
+        )
+        assertEquals("av01.0.08M.08", normalized.videoCodec)
+    }
 }

src/test/kotlin/dev/typetype/downloader/services/JobWorkerTokenSelectionTest.kt

@@ -0,0 +1,62 @@
+package dev.typetype.downloader.services
+
+import dev.typetype.downloader.models.JobOptions
+import kotlin.reflect.full.declaredFunctions
+import kotlin.reflect.jvm.isAccessible
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class JobWorkerTokenSelectionTest {
+    @Test
+    fun `uses token for non exact jobs`() {
+        assertTrue(shouldUseToken(JobOptions()))
+    }
+
+    @Test
+    fun `skips token for exact selector inputs`() {
+        assertFalse(shouldUseToken(JobOptions(videoItag = "137")))
+        assertFalse(shouldUseToken(JobOptions(audioItag = "251")))
+        assertFalse(shouldUseToken(JobOptions(height = 720)))
+        assertFalse(shouldUseToken(JobOptions(fps = 25)))
+        assertFalse(shouldUseToken(JobOptions(videoCodec = "avc1.640028")))
+        assertFalse(shouldUseToken(JobOptions(audioCodec = "opus")))
+        assertFalse(shouldUseToken(JobOptions(bitrate = 160)))
+    }
+
+    private fun shouldUseToken(options: JobOptions): Boolean {
+        val method = JobWorker::class.declaredFunctions.first { it.name == "shouldUseTokenFor" }
+        method.isAccessible = true
+        return method.call(worker(), options) as Boolean
+    }
+
+    private fun worker(): JobWorker = JobWorker(
+        jobsRepository = io.mockk.mockk(relaxed = true),
+        redis = io.mockk.mockk(relaxed = true),
+        ytDlpService = io.mockk.mockk(relaxed = true),
+        tokenServiceClient = io.mockk.mockk(relaxed = true),
+        storageService = io.mockk.mockk(relaxed = true),
+        config = dev.typetype.downloader.config.AppConfig(
+            httpPort = 18093,
+            dbUrl = "jdbc:postgresql://localhost:55432/typetype_downloader",
+            dbUser = "typetype",
+            dbPassword = "typetype",
+            redisHost = "localhost",
+            redisPort = 56379,
+            redisQueueKey = "downloader:queue",
+            maxConcurrentWorkers = 1,
+            maxQueueSize = 10,
+            jobTtlSeconds = 600,
+            ytdlpBin = "yt-dlp",
+            ytdlpTimeoutSeconds = 120,
+            enableTranscode = false,
+            s3Endpoint = "http://localhost:3900",
+            s3Region = "garage",
+            s3Bucket = "typetype-downloads",
+            s3AccessKey = "demo",
+            s3SecretKey = "demo",
+            s3ArtifactTtlSeconds = 7200,
+            tokenServiceUrl = "http://localhost:8081",
+        ),
+    )
+}

src/test/kotlin/dev/typetype/downloader/services/YtDlpOptionResolverTest.kt

@@ -11,7 +11,7 @@ class YtDlpOptionResolverTest {
         assertEquals("worstaudio/worst", YtDlpOptionResolver.audioSelector(JobOptions(mode = DownloadMode.AUDIO, quality = "worst")))
         assertEquals("bestaudio/best", YtDlpOptionResolver.audioSelector(JobOptions(mode = DownloadMode.AUDIO, quality = "best")))
         assertEquals(
-            "ba[format_id=251]/b[format_id=251]",
+            "ba[format_id='251']/b[format_id='251']",
             YtDlpOptionResolver.audioSelector(JobOptions(mode = DownloadMode.AUDIO, audioItag = "251")),
         )
         assertEquals("mp3", YtDlpOptionResolver.audioFormat("avi"))
@@ -30,7 +30,7 @@ class YtDlpOptionResolverTest {
         )
         assertEquals("bv*+ba/b", YtDlpOptionResolver.videoSelector(JobOptions(mode = DownloadMode.VIDEO, quality = "best")))
         assertEquals(
-            "bv*[format_id=137]+ba[format_id=140]",
+            "bv*[format_id='137']+ba[format_id='140']",
             YtDlpOptionResolver.videoSelector(JobOptions(mode = DownloadMode.VIDEO, videoItag = "137", audioItag = "140")),
         )
         assertEquals("mp4", YtDlpOptionResolver.videoFormat("unknown"))