refactor(status-fetcher): replace fetch-utils with Effect-based fetchers

Replaces the hand-rolled timeout+retry loop in packages/status-fetcher/src/fetch-utils.ts
with Effect's Schedule.exponential+jittered and Effect.timeoutFail. Each fetcher's fetch()
now returns Effect.Effect<StatusResult, FetchError> instead of Promise<StatusResult>, so the
downstream consumer in apps/workflows can compose typed errors directly via Effect.forEach +
Effect.either instead of Promise.allSettled.

Adds 'effect': '3.19.12' to packages/status-fetcher dependencies (matching apps/workflows).

Behavior changes (must be reviewed):
- Timeouts now retry up to 3 times like other transient errors. Worst-case per-entry time
  grows from ~30s to ~120s. The outer Effect.retry({ times: 3 }) in external-status.ts is
  removed to compensate (inner fetchJson retry is sufficient).
- Jitter formula differs slightly: today's +/-25% on planned delay -> Effect's
  Schedule.jittered (uniform [delay, 2*delay]). Functionally equivalent for herd avoidance.
- FetchError constructor changed from positional args to options object:
  new FetchError({ url, fetcherName?, entryId?, httpStatus?, cause? }). Added httpStatus
  field so retry predicate skips 4xx without regex-matching the message.
- Public surface narrowed: fetchWithTimeout / fetchWithRetry / fetchWithDeduplication and
  their option types removed from src/index.ts. No external consumers found.
- StatusFetcher.fetch signature: Promise<StatusResult> -> Effect.Effect<StatusResult, FetchError>.

Internal helpers fetchJson and fetchText are package-internal; only FetchError, fetcher
registry, and type surface are re-exported.

Also fixes pre-existing tsconfig typo (bun-types -> bun) and removes stale
@openstatus/status-fetcher dep from apps/web/package.json (no source imports).

Tests: 168 pass / 0 fail. README rewritten.

Author: thibaultleouay

apps/web/package.json

@@ -36,7 +36,6 @@
     "@openstatus/react": "workspace:*",
     "@openstatus/regions": "workspace:*",
     "@openstatus/services": "workspace:*",
-    "@openstatus/status-fetcher": "workspace:*",
     "@openstatus/theme-store": "workspace:*",
     "@openstatus/tinybird": "workspace:*",
     "@openstatus/tracker": "workspace:*",

apps/workflows/src/cron/external-status.ts

@@ -1,10 +1,10 @@
 import { getLogger } from "@logtape/logtape";
 import { listExternalServices } from "@openstatus/services/external-service";
 import type { ExternalServiceRow } from "@openstatus/services/external-service";
-import { fetchers } from "@openstatus/status-fetcher";
+import { FetchError, fetchers } from "@openstatus/status-fetcher";
 import type { StatusPageEntry, StatusResult } from "@openstatus/status-fetcher";
 import { OSTinybird } from "@openstatus/tinybird";
-import { Effect, Schedule } from "effect";
+import { Effect, Either } from "effect";
 import type { Context } from "hono";
 
 import { env } from "../env";
@@ -65,32 +65,42 @@ export async function runExternalStatusTick(): Promise<{
   const entries = services.map(toStatusPageEntry);
   const fetchedAt = Date.now();
 
-  const settled = await Promise.allSettled(
-    entries.map(async (entry) => {
-      const fetcher = fetchers.find((f) => f.canHandle(entry));
-      if (!fetcher) {
-        throw new Error(`no fetcher matches entry slug=${entry.id}`);
-      }
-      const result = await fetcher.fetch(entry);
-      return buildSnapshot({ entry, result, fetchedAt });
-    }),
+  const results = await Effect.runPromise(
+    Effect.forEach(
+      entries,
+      (entry) => {
+        const fetcher = fetchers.find((f) => f.canHandle(entry));
+        if (!fetcher) {
+          return Effect.either(
+            Effect.fail(
+              new FetchError({
+                url: entry.status_page_url,
+                entryId: entry.id,
+                cause: new Error(`no fetcher matches entry slug=${entry.id}`),
+              }),
+            ),
+          );
+        }
+        return fetcher.fetch(entry).pipe(
+          Effect.map((result) => buildSnapshot({ entry, result, fetchedAt })),
+          Effect.either,
+        );
+      },
+      { concurrency: "unbounded" },
+    ),
   );
 
   const snapshots: Snapshot[] = [];
   let failureCount = 0;
-  for (const [i, r] of settled.entries()) {
-    if (r.status === "fulfilled") {
-      snapshots.push(r.value);
+  for (const [i, r] of results.entries()) {
+    if (Either.isRight(r)) {
+      snapshots.push(r.right);
     } else {
       failureCount++;
       const slug = entries[i]?.id ?? "<unknown>";
       logger.warn(
         "external-status tick: fetcher failed for slug={slug}: {reason}",
-        {
-          slug,
-          reason:
-            r.reason instanceof Error ? r.reason.message : String(r.reason),
-        },
+        { slug, reason: r.left.message },
       );
     }
   }
@@ -121,10 +131,6 @@ export async function handleExternalStatusCron(c: Context) {
           `external-status tick failed: ${e instanceof Error ? e.message : String(e)}`,
         ),
     }).pipe(
-      Effect.retry({
-        times: 3,
-        schedule: Schedule.exponential("1000 millis"),
-      }),
       Effect.tap((res) =>
         Effect.sync(() => {
           logger.info(