perf: run fetch sources concurrently instead of sequentially

Every LinkedIn search and every fetch-other.ts source hits a different
host, so there was no real reason for the old for-loop to wait on each
one in turn - that's what made a full run take 30-40+ minutes. Runs
them concurrently now (bounded: 3 at a time within each group, both
groups started together), which brought a real run down to under 90
seconds.

existingLinks.add() now happens synchronously right after the .has()
check and before any await, which is what makes concurrent workers
safe against double-claiming the same link.

Concurrency surfaced a real regression: LinkedIn started returning
occasional 429s under parallel load, and fetchJobs treated that the
same as end-of-results, silently truncating the rest of that search.
Added retry-with-backoff (3 attempts, 1s/2s/4s) so a rate limit no
longer costs real listings.

index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { searches } from "./config.ts";
 import { fetchJobs, isViableContent, isViableUrl } from "./fetch.ts";
-import { fetchDataCareer, fetchStellenBasel, fetchItJobsCh, fetchJobRoom, fetchBaselIntlOrgs } from "./fetch-other.ts";
+import { fetchDataCareer, fetchStellenBasel, fetchItJobsCh, fetchJobRoom, fetchBaselIntlOrgs, fetchJobBasel, fetchEnglishJobSearch } from "./fetch-other.ts";
 
 const CSV = "./results/jobs.csv";
 const OLD_HEADER = "date_found,posted_at,search,title,company,link";
@@ -59,40 +59,69 @@ function csvCell(val: string): string {
   return `"${val.replace(/"/g, '""')}"`;
 }
 
-// LinkedIn searches
-for (const config of searches) {
+// Every search/source below hits a different host (LinkedIn, job-room.ch,
+// jobbasel.ch, itjobs.ch, unjobs.org, ...), so there's no reason they need to
+// run one after another — that's what made a full run take 30-40+ minutes.
+// Run them concurrently instead, bounded per group so we don't burst LinkedIn
+// (unauthenticated scraping, sensitive to anti-bot heuristics — see the
+// auth warning in CLAUDE.md) or open too many simultaneous connections to
+// the smaller extra sources at once.
+//
+// `existingLinks` is claimed synchronously (`.add()` right after the `.has()`
+// check, before any `await`) rather than after the content-check — since Bun
+// is single-threaded and only yields at `await`, that ordering is what makes
+// concurrent workers safe: two sources racing on the same link can't both
+// slip past the check before either claims it.
+//
+// Trade-off: each source still logs its own page-by-page progress from
+// inside fetch.ts/fetch-other.ts, so concurrent sources' output interleaves
+// in the terminal instead of printing in clean sequential blocks. Cutting
+// total runtime was the actual complaint; log readability is secondary and
+// still traceable (grep the source label).
+async function runWithConcurrency<T>(items: T[], limit: number, worker: (item: T) => Promise<void>): Promise<void> {
+  const queue = [...items];
+  async function runner() {
+    while (queue.length) {
+      const item = queue.shift()!;
+      await worker(item);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, runner));
+}
+
+async function processLinkedInSearch(config: (typeof searches)[number]): Promise<void> {
   console.log(`\n[${config.label}]`);
   const jobs = await fetchJobs(config);
 
   if (jobs.length === 0) {
-    console.log("  No jobs found.");
-    continue;
+    console.log(`  [${config.label}] No jobs found.`);
+    return;
   }
 
   let added = 0;
   let langDropped = 0;
   for (const job of jobs) {
-    if (!existingLinks.has(job.link)) {
-      process.stdout.write(`  checking content: ${job.title} … `);
-      // One fetch, two checks: written in German/French, or written in English
-      // but demanding German above B1.
-      const viable = await isViableContent(job.id);
-      if (!viable.ok) {
-        console.log(`dropped (${viable.reason})`);
-        langDropped++;
-        continue;
-      }
-      console.log("ok");
-      existingLinks.add(job.link);
-      newRows.push(
-        [date, job.postedAt, config.label, job.title, job.company, job.link, "linkedin.com", job.location]
-          .map(csvCell)
-          .join(",")
-      );
-      added++;
+    if (existingLinks.has(job.link)) continue;
+    existingLinks.add(job.link); // claim before the await — see note above
+
+    process.stdout.write(`  [${config.label}] checking content: ${job.title} … `);
+    // One fetch, two checks: written in German/French, or written in English
+    // but demanding German above B1.
+    const viable = await isViableContent(job.id);
+    if (!viable.ok) {
+      console.log(`dropped (${viable.reason})`);
+      langDropped++;
+      continue;
     }
+    console.log("ok");
+    newRows.push(
+      [date, job.postedAt, config.label, job.title, job.company, job.link, "linkedin.com", job.location]
+        .map(csvCell)
+        .join(",")
+    );
+    added++;
   }
-  console.log(`  ${jobs.length} found, ${added} new, ${langDropped} non-English dropped`);
+  console.log(`  [${config.label}] ${jobs.length} found, ${added} new, ${langDropped} non-English dropped`);
 }
 
 const extraSources: Array<{ label: string; fetch: () => Promise<ReturnType<typeof fetchDataCareer>> }> = [
@@ -101,49 +130,59 @@ const extraSources: Array<{ label: string; fetch: () => Promise<ReturnType<typeo
   { label: "itjobs.ch", fetch: fetchItJobsCh },
   { label: "job-room.ch", fetch: fetchJobRoom },
   { label: "basel intl orgs", fetch: fetchBaselIntlOrgs },
+  { label: "jobbasel.ch", fetch: fetchJobBasel },
+  { label: "englishjobsearch.ch", fetch: fetchEnglishJobSearch },
 ];
 
-for (const { label, fetch: fetchFn } of extraSources) {
+async function processExtraSource({ label, fetch: fetchFn }: (typeof extraSources)[number]): Promise<void> {
   console.log(`\n[${label}]`);
   let jobs;
   try {
     jobs = await fetchFn();
   } catch (e) {
-    console.error(`  error: ${e}`);
-    continue;
+    console.error(`  [${label}] error: ${e}`);
+    return;
   }
 
   if (jobs.length === 0) {
-    console.log("  No jobs found.");
-    continue;
+    console.log(`  [${label}] No jobs found.`);
+    return;
   }
 
   let added = 0;
   let langDropped = 0;
   for (const job of jobs) {
-    if (!existingLinks.has(job.link)) {
-      if (!job.contentChecked) {
-        process.stdout.write(`  checking content: ${job.title} … `);
-        const viable = await isViableUrl(job.link);
-        if (!viable.ok) {
-          console.log(`dropped (${viable.reason})`);
-          langDropped++;
-          continue;
-        }
-        console.log("ok");
+    if (existingLinks.has(job.link)) continue;
+    existingLinks.add(job.link); // claim before the await — see note above
+
+    if (!job.contentChecked) {
+      process.stdout.write(`  [${label}] checking content: ${job.title} … `);
+      const viable = await isViableUrl(job.link);
+      if (!viable.ok) {
+        console.log(`dropped (${viable.reason})`);
+        langDropped++;
+        continue;
       }
-      existingLinks.add(job.link);
-      newRows.push(
-        [date, job.postedAt, job.search, job.title, job.company, job.link, job.source, job.location]
-          .map(csvCell)
-          .join(",")
-      );
-      added++;
+      console.log("ok");
     }
+    newRows.push(
+      [date, job.postedAt, job.search, job.title, job.company, job.link, job.source, job.location]
+        .map(csvCell)
+        .join(",")
+    );
+    added++;
   }
-  console.log(`  ${jobs.length} found, ${added} new, ${langDropped} non-English dropped`);
+  console.log(`  [${label}] ${jobs.length} found, ${added} new, ${langDropped} non-English dropped`);
 }
 
+const LINKEDIN_CONCURRENCY = 3;
+const EXTRA_SOURCE_CONCURRENCY = 3;
+
+await Promise.all([
+  runWithConcurrency(searches, LINKEDIN_CONCURRENCY, processLinkedInSearch),
+  runWithConcurrency(extraSources, EXTRA_SOURCE_CONCURRENCY, processExtraSource),
+]);
+
 if (newRows.length === 0) {
   console.log("\nNo new jobs.");
   process.exit(0);