@aliou/pi-synthetic 0.10.1 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-synthetic",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "MIT",
   "type": "module",
   "private": false,

package/src/extensions/command-quotas/command.ts

@@ -15,50 +15,65 @@ export function registerQuotasCommand(pi: ExtensionAPI): void {
         ctx.ui.notify(MISSING_AUTH_MESSAGE, "warning");
         return;
       }
+      const key: string = apiKey;
 
       const result = await ctx.ui.custom<null>((tui, theme, _kb, done) => {
-        const component = new QuotasComponent(theme, () => done(null));
-
-        fetchQuotas(apiKey)
-          .then((quotas) => {
-            if (!quotas) {
-              component.setState({
-                type: "error",
-                message:
-                  "Failed to fetch quotas. Check your Synthetic subscription status.",
-              });
-            } else {
-              component.setState({ type: "loaded", quotas });
-            }
+        const controller = new AbortController();
+        const component = new QuotasComponent(
+          theme,
+          tui,
+          () => {
+            controller.abort();
+            done(null);
+          },
+          () => {
+            component.setState({ type: "loading" });
             tui.requestRender();
-          })
-          .catch(() => {
+            void loadQuotas();
+          },
+        );
+
+        async function loadQuotas(): Promise<void> {
+          const fetchResult = await fetchQuotas(key, controller.signal);
+          if (controller.signal.aborted) return;
+          if (fetchResult.success) {
+            component.setState({
+              type: "loaded",
+              quotas: fetchResult.data.quotas,
+            });
+          } else {
             component.setState({
               type: "error",
-              message:
-                "Failed to fetch quotas. Check your Synthetic subscription status.",
+              message: fetchResult.error.message,
             });
-            tui.requestRender();
-          });
+          }
+          tui.requestRender();
+        }
+
+        void loadQuotas();
 
         return {
           render: (width: number) => component.render(width),
           invalidate: () => component.invalidate(),
           handleInput: (data: string) => component.handleInput(data),
+          dispose: () => {
+            controller.abort();
+            component.destroy();
+          },
         };
       });
 
-      // RPC fallback: return JSON
+      // Non-interactive fallback (RPC, print, JSON modes)
       if (result === undefined) {
-        const quotas = await fetchQuotas(apiKey);
-        if (!quotas) {
+        const fetchResult = await fetchQuotas(key);
+        if (!fetchResult.success) {
           ctx.ui.notify(
-            JSON.stringify({ error: "Failed to fetch quotas" }),
+            JSON.stringify({ error: fetchResult.error.message }),
             "error",
           );
           return;
         }
-        ctx.ui.notify(JSON.stringify(quotas, null, 2), "info");
+        ctx.ui.notify(JSON.stringify(fetchResult.data.quotas), "info");
       }
     },
   });

package/src/extensions/command-quotas/components/quotas-display.ts

@@ -1,11 +1,7 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { DynamicBorder } from "@mariozechner/pi-coding-agent";
-import type { Component } from "@mariozechner/pi-tui";
-import {
-  matchesKey,
-  truncateToWidth,
-  visibleWidth,
-} from "@mariozechner/pi-tui";
+import type { Component, TUI } from "@mariozechner/pi-tui";
+import { Loader, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
 import type { QuotasResponse } from "../../../types/quotas";
 
 type QuotasState =
@@ -20,10 +16,12 @@ interface QuotaWindow {
   windowSeconds: number;
   usedValue: number;
   limitValue: number;
-  isCredits?: boolean;
-  isLimited?: boolean;
-  tickPercent?: number;
-  nextRegenCredits?: string;
+  isCurrency?: boolean;
+  showPace?: boolean;
+  paceScale?: number;
+  limited?: boolean;
+  nextAmount?: string;
+  nextLabel?: string;
 }
 
 /** Safely compute percentage, guarding against division by zero */
@@ -41,80 +39,65 @@ function parseCurrency(value: string): number {
 function toWindows(quotas: QuotasResponse): QuotaWindow[] {
   const windows: QuotaWindow[] = [];
 
-  // Weekly token limit (credits-based)
   if (quotas.weeklyTokenLimit) {
     const { weeklyTokenLimit } = quotas;
     const limitValue = parseCurrency(weeklyTokenLimit.maxCredits);
     const remainingValue = parseCurrency(weeklyTokenLimit.remainingCredits);
     windows.push({
-      label: "Credits",
+      label: "Credits / week",
       usedPercent: Math.max(
         0,
         Math.min(100, 100 - weeklyTokenLimit.percentRemaining),
       ),
       resetsAt: new Date(weeklyTokenLimit.nextRegenAt),
-      windowSeconds: 7 * 24 * 60 * 60,
+      windowSeconds: 24 * 60 * 60,
       usedValue: limitValue - remainingValue,
       limitValue,
-      isCredits: true,
-      nextRegenCredits: weeklyTokenLimit.nextRegenCredits,
+      isCurrency: true,
+      showPace: true,
+      paceScale: 1 / 7,
+      nextAmount: `+${weeklyTokenLimit.nextRegenCredits}`,
+      nextLabel: "Next regen",
     });
   }
 
-  // Rolling 5-hour limit (request-based)
   if (quotas.rollingFiveHourLimit && quotas.rollingFiveHourLimit.max > 0) {
     const { rollingFiveHourLimit } = quotas;
+    const used = rollingFiveHourLimit.max - rollingFiveHourLimit.remaining;
+    const tickAmount =
+      rollingFiveHourLimit.tickPercent * rollingFiveHourLimit.max;
     windows.push({
-      label: "5h",
-      usedPercent: safePercent(
-        rollingFiveHourLimit.max - rollingFiveHourLimit.remaining,
-        rollingFiveHourLimit.max,
-      ),
+      label: "Requests / 5h",
+      usedPercent: safePercent(used, rollingFiveHourLimit.max),
       resetsAt: new Date(rollingFiveHourLimit.nextTickAt),
       windowSeconds: 5 * 60 * 60,
-      usedValue: rollingFiveHourLimit.max - rollingFiveHourLimit.remaining,
+      usedValue: Math.round(used),
       limitValue: rollingFiveHourLimit.max,
-      isLimited: rollingFiveHourLimit.limited,
-      tickPercent: rollingFiveHourLimit.tickPercent,
-    });
-  }
-
-  // Legacy subscription (fallback if rollingFiveHourLimit not available)
-  if (
-    !quotas.rollingFiveHourLimit &&
-    quotas.subscription?.limit &&
-    quotas.subscription.limit > 0
-  ) {
-    windows.push({
-      label: "Completions",
-      usedPercent: safePercent(
-        quotas.subscription.requests,
-        quotas.subscription.limit,
-      ),
-      resetsAt: new Date(quotas.subscription.renewsAt),
-      windowSeconds: 5 * 60 * 60,
-      usedValue: quotas.subscription.requests,
-      limitValue: quotas.subscription.limit,
+      showPace: false,
+      limited: rollingFiveHourLimit.limited,
+      nextAmount: `+${tickAmount.toFixed(1)}`,
+      nextLabel: "Next tick",
     });
   }
 
   if (quotas.search?.hourly?.limit && quotas.search.hourly.limit > 0) {
+    const { hourly } = quotas.search;
     windows.push({
-      label: "Search",
-      usedPercent: safePercent(
-        quotas.search.hourly.requests,
-        quotas.search.hourly.limit,
-      ),
-      resetsAt: new Date(quotas.search.hourly.renewsAt),
+      label: "Search / hour",
+      usedPercent: safePercent(hourly.requests, hourly.limit),
+      resetsAt: new Date(hourly.renewsAt),
       windowSeconds: 60 * 60,
-      usedValue: quotas.search.hourly.requests,
-      limitValue: quotas.search.hourly.limit,
+      usedValue: hourly.requests,
+      limitValue: hourly.limit,
+      showPace: true,
+      paceScale: 1,
+      nextLabel: "Resets",
     });
   }
 
   if (quotas.freeToolCalls?.limit && quotas.freeToolCalls.limit > 0) {
     windows.push({
-      label: "Free Tool Calls",
+      label: "Free Tool Calls / day",
       usedPercent: safePercent(
         quotas.freeToolCalls.requests,
         quotas.freeToolCalls.limit,
@@ -123,6 +106,9 @@ function toWindows(quotas: QuotasResponse): QuotaWindow[] {
       windowSeconds: 24 * 60 * 60,
       usedValue: quotas.freeToolCalls.requests,
       limitValue: quotas.freeToolCalls.limit,
+      showPace: true,
+      paceScale: 1,
+      nextLabel: "Resets",
     });
   }
 
@@ -167,29 +153,28 @@ function getSeverity(
   return "success";
 }
 
-function formatResetDateTime(date: Date): string {
-  const now = new Date();
-  const isToday =
-    date.getDate() === now.getDate() &&
-    date.getMonth() === now.getMonth() &&
-    date.getFullYear() === now.getFullYear();
-
-  const timeStr = date.toLocaleTimeString("en-US", {
-    hour: "numeric",
-    minute: "2-digit",
-    hour12: true,
-  });
-
-  if (isToday) {
-    return `today ${timeStr}`;
-  }
-
-  const dateStr = date.toLocaleDateString("en-US", {
-    month: "short",
-    day: "numeric",
-  });
+function formatTimeRemaining(date: Date): string {
+  const ms = date.getTime() - Date.now();
+  if (ms <= 0) return "now";
+  const totalMins = Math.ceil(ms / (1000 * 60));
+  const hours = Math.floor(totalMins / 60);
+  const mins = totalMins % 60;
+  if (hours >= 1) return mins > 0 ? `${hours}h${mins}m` : `${hours}h`;
+  const totalSecs = Math.ceil(ms / 1000);
+  return totalMins >= 1 ? `${totalMins}m` : `${totalSecs}s`;
+}
 
-  return `${dateStr} ${timeStr}`;
+/**
+ * Convert a foreground ANSI escape to its background equivalent.
+ * Handles truecolor (38;2), 256-color (38;5), and basic (3X) escapes.
+ */
+function fgAnsiToBg(fgAnsi: string): string {
+  // Convert fg escape sequences to bg equivalents by replacing the
+  // discriminating digit: 38 (truecolor/256) → 48, 3X (basic) → 4X.
+  return fgAnsi
+    .split("[38;")
+    .join("[48;")
+    .replace(/\[3([0-9])m/g, "[4$1m");
 }
 
 function renderProgressBar(
@@ -201,45 +186,40 @@ function renderProgressBar(
 ): string {
   const clamped = Math.max(0, Math.min(100, Math.round(percent)));
   const filled = Math.round((clamped / 100) * width);
-  const paceIndex =
-    pacePercent === null || pacePercent === undefined || pacePercent <= percent
-      ? null
-      : Math.round((Math.max(0, Math.min(100, pacePercent)) / 100) * width);
 
-  const parts: string[] = [];
-  for (let idx = 0; idx < width; idx++) {
-    if (idx < filled) {
-      parts.push(theme.fg(fillColor, "█"));
-    } else if (paceIndex !== null && idx < paceIndex) {
-      parts.push(theme.fg(fillColor, "▓"));
-    } else {
-      parts.push(theme.fg("dim", "░"));
-    }
-  }
+  const showPace =
+    pacePercent !== null &&
+    pacePercent !== undefined &&
+    pacePercent >= 5 &&
+    Math.abs(pacePercent - percent) >= 5;
+  const paceIndex = showPace
+    ? Math.min(
+        width - 1,
+        Math.round(
+          (Math.max(0, Math.min(100, pacePercent ?? 0)) / 100) * width,
+        ),
+      )
+    : null;
 
-  return parts.join("");
-}
+  const reset = "\x1b[0m";
 
-function renderSimpleIndicatorBar(
-  usedPercent: number,
-  width: number,
-  theme: Theme,
-  severity: "success" | "warning" | "error",
-): string {
-  const clampedPercent = Math.max(0, Math.min(100, usedPercent));
-  // Clamp to width - 1 to avoid off-by-one when usedPercent === 100
-  const usedIndex = Math.min(
-    Math.round((clampedPercent / 100) * width),
-    width - 1,
-  );
   const parts: string[] = [];
-
-  // Hide marker when within 5% of edges
-  const showMarker = clampedPercent >= 5 && clampedPercent <= 95;
-
   for (let idx = 0; idx < width; idx++) {
-    if (showMarker && idx === usedIndex) {
-      parts.push(theme.fg(severity, "|"));
+    if (paceIndex !== null && idx === paceIndex) {
+      // Inside fill = ahead of pace: accent. Outside = behind pace: severity.
+      const markerColor = idx < filled ? "accent" : fillColor;
+      // Inside fill: set bg to fill color so `|` doesn't expose the panel bg
+      // through the thin character. Outside fill: ░ uses terminal bg naturally,
+      // so leave bg unset to match.
+      if (idx < filled) {
+        const bgAnsi = fgAnsiToBg(theme.getFgAnsi(fillColor));
+        const fgAnsi = theme.getFgAnsi(markerColor);
+        parts.push(`${bgAnsi}${fgAnsi}|${reset}`);
+      } else {
+        parts.push(theme.fg(markerColor, "|"));
+      }
+    } else if (idx < filled) {
+      parts.push(theme.fg(fillColor, "█"));
     } else {
       parts.push(theme.fg("dim", "░"));
     }
@@ -251,14 +231,46 @@ function renderSimpleIndicatorBar(
 export class QuotasComponent implements Component {
   private state: QuotasState = { type: "loading" };
   private theme: Theme;
+  private tui: TUI;
   private onClose: () => void;
-
-  constructor(theme: Theme, onClose: () => void) {
+  private onRefetch: () => void;
+  private loader: Loader | null = null;
+
+  constructor(
+    theme: Theme,
+    tui: TUI,
+    onClose: () => void,
+    onRefetch: () => void,
+  ) {
     this.theme = theme;
+    this.tui = tui;
     this.onClose = onClose;
+    this.onRefetch = onRefetch;
+    this.startLoader();
+  }
+
+  private startLoader(): void {
+    this.loader = new Loader(
+      this.tui,
+      (s: string) => this.theme.fg("accent", s),
+      (s: string) => this.theme.fg("muted", s),
+      "Fetching quotas...",
+    );
+  }
+
+  destroy(): void {
+    this.loader?.stop();
+    this.loader = null;
   }
 
   setState(state: QuotasState): void {
+    if (state.type === "loading") {
+      this.loader?.stop();
+      this.startLoader();
+    } else if (this.state.type === "loading") {
+      this.loader?.stop();
+      this.loader = null;
+    }
     this.state = state;
   }
 
@@ -267,6 +279,10 @@ export class QuotasComponent implements Component {
       this.onClose();
       return true;
     }
+    if (data === "r") {
+      this.onRefetch();
+      return true;
+    }
     return false;
   }
 
@@ -286,7 +302,11 @@ export class QuotasComponent implements Component {
 
     switch (this.state.type) {
       case "loading":
-        lines.push(this.theme.fg("muted", "  Loading..."));
+        if (this.loader) {
+          lines.push(...this.loader.render(width));
+        } else {
+          lines.push(this.theme.fg("muted", "  Fetching quotas..."));
+        }
         break;
       case "error":
         lines.push(this.theme.fg("error", `  ${this.state.message}`));
@@ -299,7 +319,7 @@ export class QuotasComponent implements Component {
     }
 
     lines.push("");
-    lines.push(this.theme.fg("dim", "  q/Esc to close"));
+    lines.push(this.theme.fg("dim", "  r to refresh  q/Esc to close"));
     lines.push(...border.render(width));
 
     return lines;
@@ -335,134 +355,51 @@ export class QuotasComponent implements Component {
     const lines: string[] = [];
     const theme = this.theme;
 
-    const pacePercent = getPacePercent(window);
+    const rawPace = window.showPace ? getPacePercent(window) : null;
+    const pacePercent =
+      rawPace !== null ? rawPace * (window.paceScale ?? 1) : null;
     const projectedPercent = getProjectedPercent(
       window.usedPercent,
       pacePercent,
     );
-    const severity = getSeverity(projectedPercent, pacePercent);
+    let severity = getSeverity(projectedPercent, pacePercent);
+    if (window.limited) severity = "error";
 
     // Label
     lines.push(
       truncateToWidth(`  ${theme.fg("accent", window.label)}`, maxWidth),
     );
 
-    // Progress bar + usage (or indicator for new quota types)
-    if (window.isCredits || window.tickPercent !== undefined) {
-      // Show simple indicator bar for new quota types
-      const bar = renderSimpleIndicatorBar(
-        window.usedPercent,
-        barWidth,
-        theme,
-        severity,
-      );
-      const usedStr = window.isCredits
-        ? `$${window.usedValue.toFixed(2)}/$${window.limitValue.toFixed(2)} (${Math.round(window.usedPercent)}%)`
-        : `${window.usedValue.toFixed(0)}/${window.limitValue.toFixed(0)} (${Math.round(window.usedPercent)}%)`;
-      const limitedBadge = window.isLimited
-        ? theme.fg("error", " LIMITED")
-        : "";
-      lines.push(
-        truncateToWidth(
-          `  ${bar} ${theme.fg(severity, usedStr)}${limitedBadge}`,
-          maxWidth,
-        ),
-      );
-    } else {
-      // Traditional progress bar for legacy quota types
-      const bar = renderProgressBar(
-        window.usedPercent,
-        barWidth,
-        theme,
-        severity,
-        pacePercent,
-      );
-      const usedStr = `${window.usedValue.toLocaleString()}/${window.limitValue.toLocaleString()} (${Math.round(window.usedPercent)}%)`;
-      lines.push(
-        truncateToWidth(`  ${bar} ${theme.fg(severity, usedStr)}`, maxWidth),
-      );
-    }
-
-    // Metadata: estimated + pace left, reset time right
-    const leftParts: string[] = [];
-
-    // Show tick info for rolling window
-    if (window.tickPercent !== undefined) {
-      const now = Date.now();
-      const remainingMs = window.resetsAt.getTime() - now;
-      const remainingMins = Math.ceil(remainingMs / (1000 * 60));
-      const remainingSecs = Math.ceil(remainingMs / 1000);
-      const timeStr =
-        remainingMs <= 0
-          ? "now"
-          : remainingMins >= 1
-            ? `${remainingMins}m`
-            : `${remainingSecs}s`;
-      const tickValue = (window.tickPercent / 100) * window.limitValue;
-      const tickStr = `+${tickValue.toFixed(1)} in ${timeStr}`;
-      leftParts.push(theme.fg("dim", tickStr));
-    }
-
-    // Show next regen credits for weekly token limit
-    if (window.nextRegenCredits !== undefined) {
-      const now = Date.now();
-      const remainingMs = window.resetsAt.getTime() - now;
-      const remainingHours = Math.ceil(remainingMs / (1000 * 60 * 60));
-      const remainingMins = Math.ceil(remainingMs / (1000 * 60));
-      const timeStr =
-        remainingMs <= 0
-          ? "now"
-          : remainingHours >= 1
-            ? `${remainingHours}h`
-            : `${remainingMins}m`;
-      const regenStr = `+${window.nextRegenCredits} in ${timeStr}`;
-      leftParts.push(theme.fg("dim", regenStr));
-    }
+    // Bar + usage
+    const bar = renderProgressBar(
+      window.usedPercent,
+      barWidth,
+      theme,
+      severity,
+      pacePercent,
+    );
+    const usedStr = window.isCurrency
+      ? `${Math.round(window.usedPercent)}%/$${window.limitValue.toFixed(2)}`
+      : `${Math.round(window.usedPercent)}%/${window.limitValue}`;
+    const limitedBadge = window.limited ? theme.fg("error", " LIMITED") : "";
+    lines.push(
+      truncateToWidth(
+        `  ${bar} ${theme.fg(severity, usedStr)}${limitedBadge}`,
+        maxWidth,
+      ),
+    );
 
-    if (
-      projectedPercent > 0 &&
-      window.tickPercent === undefined &&
-      window.nextRegenCredits === undefined
-    ) {
-      const estStr = `est ${Math.round(projectedPercent)}%`;
-      leftParts.push(
-        severity !== "success"
-          ? theme.fg(severity, estStr)
-          : theme.fg("dim", estStr),
+    // Subtitle: next event info
+    if (window.nextLabel) {
+      const timeStr = formatTimeRemaining(window.resetsAt);
+      const subtitleStr = window.nextAmount
+        ? `${window.nextAmount} in ${timeStr}`
+        : `${window.nextLabel} in ${timeStr}`;
+      lines.push(
+        truncateToWidth(`  ${theme.fg("dim", subtitleStr)}`, maxWidth),
       );
     }
 
-    if (
-      pacePercent !== null &&
-      window.tickPercent === undefined &&
-      window.nextRegenCredits === undefined
-    ) {
-      const paceDiff = window.usedPercent - pacePercent;
-      if (Math.abs(paceDiff) > 5) {
-        if (paceDiff > 0) {
-          leftParts.push(
-            theme.fg("warning", `${Math.round(Math.abs(paceDiff))}% ahead`),
-          );
-        } else {
-          leftParts.push(
-            theme.fg("success", `${Math.round(Math.abs(paceDiff))}% behind`),
-          );
-        }
-      }
-    }
-
-    const leftStr = leftParts.join("  ");
-    const resetStr = formatResetDateTime(window.resetsAt);
-    const rightStr = theme.fg("dim", resetStr);
-
-    const leftW = visibleWidth(leftStr);
-    const rightW = visibleWidth(rightStr);
-    const gap = Math.max(2, barWidth - leftW - rightW);
-
-    lines.push(
-      truncateToWidth(`  ${leftStr}${" ".repeat(gap)}${rightStr}`, maxWidth),
-    );
-
     return lines;
   }
 

package/src/extensions/command-quotas/sub-integration.ts

@@ -107,10 +107,13 @@ async function emitCurrentUsage(
 ): Promise<void> {
   const apiKey = await getSyntheticApiKey(authStorage);
   if (!apiKey) return;
-  const quotas = await fetchQuotas(apiKey);
-  if (!quotas) return;
+  const result = await fetchQuotas(apiKey);
+  if (!result.success) return;
   pi.events.emit("sub-core:update-current", {
-    state: { provider: "synthetic", usage: toUsageSnapshot(quotas) },
+    state: {
+      provider: "synthetic",
+      usage: toUsageSnapshot(result.data.quotas),
+    },
   });
 }
 

package/src/types/quotas.ts

@@ -1,3 +1,14 @@
+export type QuotasErrorKind =
+  | "cancelled"
+  | "timeout"
+  | "config"
+  | "http"
+  | "network";
+
+export type QuotasResult =
+  | { success: true; data: { quotas: QuotasResponse } }
+  | { success: false; error: { message: string; kind: QuotasErrorKind } };
+
 export interface QuotasResponse {
   subscription?: {
     limit: number;

package/src/utils/quotas.ts

@@ -1,20 +1,73 @@
-import type { QuotasResponse } from "../types/quotas";
+import type { QuotasResponse, QuotasResult } from "../types/quotas";
+
+const FETCH_TIMEOUT_MS = 15_000;
+
+function isTimeoutReason(reason: unknown): boolean {
+  return (
+    (reason instanceof DOMException && reason.name === "TimeoutError") ||
+    (reason instanceof Error && reason.name === "TimeoutError")
+  );
+}
 
 export async function fetchQuotas(
   apiKey: string,
-): Promise<QuotasResponse | null> {
-  if (!apiKey) return null;
+  signal?: AbortSignal,
+): Promise<QuotasResult> {
+  if (!apiKey) {
+    return {
+      success: false,
+      error: { message: "No API key provided", kind: "config" },
+    };
+  }
+
+  const signals: AbortSignal[] = [AbortSignal.timeout(FETCH_TIMEOUT_MS)];
+  if (signal) signals.push(signal);
+  const combined = AbortSignal.any(signals);
 
   try {
     const response = await fetch("https://api.synthetic.new/v2/quotas", {
       headers: { Authorization: `Bearer ${apiKey}` },
+      signal: combined,
     });
 
-    if (!response.ok) return null;
+    if (!response.ok) {
+      let message = response.statusText;
+      try {
+        const body = await response.text();
+        if (body) {
+          try {
+            const parsed = JSON.parse(body) as { error?: string };
+            if (parsed.error) message = parsed.error;
+          } catch {
+            message = body;
+          }
+        }
+      } catch {
+        return { success: false, error: { message, kind: "http" } };
+      }
+      return { success: false, error: { message, kind: "http" } };
+    }
+
     const data: QuotasResponse = await response.json();
-    return data;
-  } catch {
-    return null;
+    return { success: true, data: { quotas: data } };
+  } catch (err: unknown) {
+    const isAbort =
+      combined.aborted ||
+      (err instanceof DOMException && err.name === "AbortError");
+    if (isAbort) {
+      if (isTimeoutReason(combined.reason)) {
+        return {
+          success: false,
+          error: { message: "Request timed out", kind: "timeout" },
+        };
+      }
+      return {
+        success: false,
+        error: { message: "Request cancelled", kind: "cancelled" },
+      };
+    }
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return { success: false, error: { message, kind: "network" } };
   }
 }