morille 0.1.0

package/dist/hooks/use-queue.js

@@ -0,0 +1,194 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+async function resolveQueueItems(client, context, cacheRef) {
+    if (context) {
+        if (cacheRef.current?.contextUri === context.uri) {
+            return {
+                items: cacheRef.current.items,
+                name: cacheRef.current.name,
+                subtitle: cacheRef.current.subtitle,
+            };
+        }
+        const result = await fetchContextTracks(client, context).catch(() => null);
+        if (result && result.items.length > 0) {
+            cacheRef.current = {
+                contextUri: context.uri,
+                snapshotId: result.snapshotId,
+                items: result.items,
+                name: result.name,
+                subtitle: result.subtitle,
+            };
+            return result;
+        }
+    }
+    // Fall back to queue API
+    const data = await client.player.getUsersQueue();
+    const items = [];
+    if (data.currently_playing) {
+        items.push(mapTrackItem(data.currently_playing, false));
+    }
+    for (const item of data.queue) {
+        items.push(mapTrackItem(item, false));
+    }
+    cacheRef.current = null;
+    return {
+        items,
+        name: 'Current Queue',
+        subtitle: null,
+    };
+}
+function extractContextId(uri) {
+    // spotify:playlist:ID or spotify:album:ID
+    const parts = uri.split(':');
+    return parts.length >= 3 ? parts[2] : null;
+}
+/**
+ * Fetches the current playlist/album content and marks the currently playing track.
+ * Falls back to the Spotify queue API if no context is available.
+ * @param client - Authenticated Spotify API client
+ * @param enabled - Whether to fetch data
+ * @param trackKey - Current track identity for refresh triggers
+ * @param context - Current playback context (playlist/album)
+ * @param currentTrackUri - URI of the currently playing track
+ * @returns Queue items with current track marked, loading state, and current track index
+ */
+export function useQueue(client, enabled, context, currentTrackUri) {
+    const [queue, setQueue] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [currentIndex, setCurrentIndex] = useState(0);
+    const [contextName, setContextName] = useState(null);
+    const [contextSubtitle, setContextSubtitle] = useState(null);
+    const cacheRef = useRef(null);
+    const contextRef = useRef(context);
+    const trackUriRef = useRef(currentTrackUri);
+    contextRef.current = context;
+    trackUriRef.current = currentTrackUri;
+    const refresh = useCallback(async () => {
+        try {
+            const result = await resolveQueueItems(client, contextRef.current, cacheRef);
+            const uri = trackUriRef.current;
+            const currentIdx = uri ? result.items.findIndex((i) => i.uri === uri) : -1;
+            const marked = result.items.map((item, idx) => ({
+                ...item,
+                isCurrent: idx === currentIdx,
+                isPrevious: currentIdx >= 0 && idx < currentIdx,
+            }));
+            setQueue(marked);
+            setCurrentIndex(Math.max(currentIdx, 0));
+            setContextName(result.name);
+            setContextSubtitle(result.subtitle);
+        }
+        catch {
+            // Silently ignore - show stale data
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [
+        client,
+    ]);
+    const hasLoadedRef = useRef(false);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        if (!hasLoadedRef.current) {
+            setIsLoading(true);
+        }
+        refresh().then(() => {
+            hasLoadedRef.current = true;
+        });
+    }, [
+        enabled,
+        refresh,
+    ]);
+    // Re-mark current/previous when the playing track changes (cache hit, no API call)
+    // biome-ignore lint/correctness/useExhaustiveDependencies: currentTrackUri is intentionally a trigger
+    useEffect(() => {
+        if (enabled && hasLoadedRef.current) {
+            refresh();
+        }
+    }, [
+        enabled,
+        currentTrackUri,
+        refresh,
+    ]);
+    return {
+        queue,
+        contextName,
+        contextSubtitle,
+        isLoading,
+        currentIndex,
+        refresh,
+    };
+}
+function mapTrackItem(item, isPrevious) {
+    const artist = item.artists ? item.artists.map((a) => a.name).join(', ') : 'Unknown';
+    return {
+        name: item.name,
+        artist,
+        durationMs: item.duration_ms,
+        uri: item.uri,
+        isCurrent: false,
+        isPrevious,
+    };
+}
+// type TrackLike = {
+//   name: string;
+//   uri: string;
+//   duration_ms: number;
+//   artists?: Array<{
+//     name: string;
+//   }>;
+// };
+async function fetchContextTracks(client, context) {
+    if (context.type === 'collection') {
+        const page = await client.currentUser.tracks.savedTracks(50, 0);
+        return {
+            items: page.items.map((e) => mapTrackItem(e.track, false)),
+            name: 'Liked Songs',
+            subtitle: null,
+        };
+    }
+    const id = extractContextId(context.uri);
+    if (!id)
+        return {
+            items: [],
+            name: null,
+            subtitle: null,
+        };
+    if (context.type === 'playlist') {
+        /**
+         *
+         * Temp disabling playlist fetching due to API issues
+         * KEEP THIS CODE
+         *
+        const playlist = await client.playlists.getPlaylist(
+          id,
+          undefined,
+          'name,snapshot_id,tracks.items(track(name,uri,duration_ms,artists(name)))',
+        );
+        const items = playlist.tracks.items.filter((e) => e.track).map((e) => mapTrackItem(e.track as TrackLike, false));
+        return {
+          items,
+          name: playlist.name,
+          snapshotId: playlist.snapshot_id,
+        }; */
+    }
+    if (context.type === 'album') {
+        const album = await client.albums.get(id);
+        return {
+            items: album.tracks.items.map((t) => mapTrackItem(t, false)),
+            name: `${album.name}`,
+            subtitle: `${album.artists
+                .filter((_, index) => {
+                return index < 3;
+            })
+                .map((a) => a.name)
+                .join(', ')}${album.tracks.total > 3 ? ` (+${album.tracks.total - 3} more)` : ''}`,
+        };
+    }
+    return {
+        items: [],
+        name: null,
+        subtitle: null,
+    };
+}

package/dist/hooks/use-search.d.ts

@@ -0,0 +1,16 @@
+import type { SpotifyApi } from '@spotify/web-api-ts-sdk';
+import type { SearchResults } from '../spotify/search.js';
+/**
+ * Manages search state with debounced API calls and deduplication.
+ * Only fetches when enabled (panel is active).
+ * @param client - Authenticated Spotify API client
+ * @param enabled - Whether the search panel is active
+ * @returns Search state and controls
+ */
+export declare function useSearch(client: SpotifyApi, enabled: boolean): {
+    query: string;
+    setQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    results: SearchResults | null;
+    isLoading: boolean;
+    clear: () => void;
+};

package/dist/hooks/use-search.js

@@ -0,0 +1,77 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { SEARCH_DEBOUNCE_MS } from '../config.js';
+import { searchSpotify } from '../spotify/search.js';
+/**
+ * Manages search state with debounced API calls and deduplication.
+ * Only fetches when enabled (panel is active).
+ * @param client - Authenticated Spotify API client
+ * @param enabled - Whether the search panel is active
+ * @returns Search state and controls
+ */
+export function useSearch(client, enabled) {
+    const [query, setQuery] = useState('');
+    const [results, setResults] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const timerRef = useRef(null);
+    const inflightRef = useRef(null);
+    const doSearch = useCallback(async (q) => {
+        if (inflightRef.current === q)
+            return;
+        inflightRef.current = q;
+        setIsLoading(true);
+        try {
+            const data = await searchSpotify(client, q);
+            if (inflightRef.current === q) {
+                setResults(data);
+            }
+        }
+        catch (error) {
+            console.error(`Search failed for query "${q}":`, error);
+        }
+        finally {
+            if (inflightRef.current === q) {
+                setIsLoading(false);
+                inflightRef.current = null;
+            }
+        }
+    }, [
+        client,
+    ]);
+    useEffect(() => {
+        if (!enabled)
+            return;
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        if (query.trim().length === 0) {
+            setResults(null);
+            setIsLoading(false);
+            return;
+        }
+        timerRef.current = setTimeout(() => {
+            doSearch(query.trim());
+        }, SEARCH_DEBOUNCE_MS);
+        return () => {
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+        };
+    }, [
+        query,
+        enabled,
+        doSearch,
+    ]);
+    const clear = useCallback(() => {
+        setQuery('');
+        setResults(null);
+        setIsLoading(false);
+        if (timerRef.current)
+            clearTimeout(timerRef.current);
+        inflightRef.current = null;
+    }, []);
+    return {
+        query,
+        setQuery,
+        results,
+        isLoading,
+        clear,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export type { RepeatMode, TrackInfo } from './spotify/playback.js';
+export { getCurrentTrackInfo, getPlaybackState, pause, play, playInContext, playUri, seek, setRepeat, setShuffle, setVolume, skipNext, skipPrevious, togglePlayback, } from './spotify/playback.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadEnvFile } from 'node:process';
+const envPath = join(import.meta.dirname, '../.env');
+if (existsSync(envPath)) {
+    loadEnvFile(envPath);
+}
+export { getCurrentTrackInfo, getPlaybackState, pause, play, playInContext, playUri, seek, setRepeat, setShuffle, setVolume, skipNext, skipPrevious, togglePlayback, } from './spotify/playback.js';
+await import('./main.js');

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/main.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './app.js';
+render(_jsx(App, {}), {
+    alternateScreen: true,
+});

package/dist/spotify/auth.d.ts

@@ -0,0 +1,36 @@
+import type { AccessToken } from '@spotify/web-api-ts-sdk';
+export type AuthenticateOptions = {
+    onAuthUrl?: (url: string, openBrowserFn: () => void) => void;
+};
+/**
+ * Runs the full Spotify PKCE OAuth flow: starts a local callback server,
+ * opens the browser for user authorization, and exchanges the code for tokens.
+ * @param clientId - Spotify application client ID
+ * @param options - Optional callbacks, including {@link AuthenticateOptions.onAuthUrl} fired with the authorization URL
+ * @returns Access token with refresh token and expiration
+ */
+export declare function authenticate(clientId: string, options?: AuthenticateOptions): Promise<AccessToken>;
+/**
+ * Loads a previously stored access token from disk.
+ * @returns The stored token, or `null` if none exists or the file is invalid
+ */
+export declare function loadStoredToken(): AccessToken | null;
+/**
+ * Persists an access token to disk at {@link TOKEN_PATH}.
+ * @param token - The access token to store
+ */
+export declare function storeToken(token: AccessToken): void;
+/**
+ * Checks whether an access token has expired.
+ * @param token - The access token to check
+ * @returns `true` if the token is expired or has no expiration set
+ */
+export declare function isTokenExpired(token: AccessToken): boolean;
+/**
+ * Refreshes an expired access token using its refresh token.
+ * The new token is automatically persisted to disk.
+ * @param clientId - Spotify application client ID
+ * @param token - The expired token containing a valid refresh token
+ * @returns A fresh access token
+ */
+export declare function refreshToken(clientId: string, token: AccessToken): Promise<AccessToken>;

package/dist/spotify/auth.js

@@ -0,0 +1,183 @@
+import { execFile } from 'node:child_process';
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { AUTH_REDIRECT_PORT, AUTH_REDIRECT_URI, AUTH_SCOPES, CONFIG_DIR, TOKEN_PATH } from '../config.js';
+function generateCodeVerifier() {
+    return randomBytes(64).toString('base64url');
+}
+function generateCodeChallenge(verifier) {
+    return createHash('sha256').update(verifier).digest('base64url');
+}
+function openBrowser(url) {
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = process.platform === 'win32'
+        ? [
+            '/c',
+            'start',
+            '',
+            url,
+        ]
+        : [
+            url,
+        ];
+    execFile(command, args);
+}
+function parseCallbackResult(url) {
+    const code = url.searchParams.get('code');
+    const error = url.searchParams.get('error');
+    const errorDescription = url.searchParams.get('error_description');
+    if (error) {
+        const message = `Spotify auth error: ${error}${errorDescription ? ` - ${errorDescription}` : ''}`;
+        return {
+            error: message,
+        };
+    }
+    if (code) {
+        return {
+            code,
+        };
+    }
+    return {
+        error: 'No auth code received',
+    };
+}
+function waitForAuthCode() {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? '/', `http://127.0.0.1:${AUTH_REDIRECT_PORT}`);
+            if (url.pathname === '/callback') {
+                res.writeHead(200, {
+                    'Content-Type': 'text/html',
+                });
+                res.end('<html><body><h1>Done! You can close this tab.</h1></body></html>');
+                server.close();
+                const result = parseCallbackResult(url);
+                if ('code' in result) {
+                    resolve(result.code);
+                }
+                else {
+                    reject(new Error(result.error));
+                }
+            }
+        });
+        server.listen(AUTH_REDIRECT_PORT, '127.0.0.1');
+        server.on('error', reject);
+    });
+}
+async function exchangeCodeForToken(clientId, code, codeVerifier) {
+    const response = await fetch('https://accounts.spotify.com/api/token', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+            grant_type: 'authorization_code',
+            code,
+            redirect_uri: AUTH_REDIRECT_URI,
+            client_id: clientId,
+            code_verifier: codeVerifier,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Token exchange failed (${response.status}): ${text}`);
+    }
+    const data = (await response.json());
+    return {
+        ...data,
+        expires: Date.now() + data.expires_in * 1000,
+    };
+}
+/**
+ * Runs the full Spotify PKCE OAuth flow: starts a local callback server,
+ * opens the browser for user authorization, and exchanges the code for tokens.
+ * @param clientId - Spotify application client ID
+ * @param options - Optional callbacks, including {@link AuthenticateOptions.onAuthUrl} fired with the authorization URL
+ * @returns Access token with refresh token and expiration
+ */
+export async function authenticate(clientId, options) {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const authUrl = new URL('https://accounts.spotify.com/authorize');
+    authUrl.searchParams.set('response_type', 'code');
+    authUrl.searchParams.set('client_id', clientId);
+    authUrl.searchParams.set('redirect_uri', AUTH_REDIRECT_URI);
+    authUrl.searchParams.set('code_challenge_method', 'S256');
+    authUrl.searchParams.set('code_challenge', codeChallenge);
+    authUrl.searchParams.set('scope', AUTH_SCOPES);
+    const url = authUrl.toString();
+    const codePromise = waitForAuthCode();
+    options?.onAuthUrl?.(url, () => openBrowser(url));
+    const code = await codePromise;
+    return exchangeCodeForToken(clientId, code, codeVerifier);
+}
+/**
+ * Loads a previously stored access token from disk.
+ * @returns The stored token, or `null` if none exists or the file is invalid
+ */
+export function loadStoredToken() {
+    if (!existsSync(TOKEN_PATH)) {
+        return null;
+    }
+    try {
+        const data = readFileSync(TOKEN_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Persists an access token to disk at {@link TOKEN_PATH}.
+ * @param token - The access token to store
+ */
+export function storeToken(token) {
+    mkdirSync(CONFIG_DIR, {
+        recursive: true,
+    });
+    writeFileSync(TOKEN_PATH, JSON.stringify(token, null, 2));
+}
+/**
+ * Checks whether an access token has expired.
+ * @param token - The access token to check
+ * @returns `true` if the token is expired or has no expiration set
+ */
+export function isTokenExpired(token) {
+    if (token.expires == null) {
+        return true;
+    }
+    return Date.now() >= token.expires;
+}
+/**
+ * Refreshes an expired access token using its refresh token.
+ * The new token is automatically persisted to disk.
+ * @param clientId - Spotify application client ID
+ * @param token - The expired token containing a valid refresh token
+ * @returns A fresh access token
+ */
+export async function refreshToken(clientId, token) {
+    const response = await fetch('https://accounts.spotify.com/api/token', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: token.refresh_token,
+            client_id: clientId,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Token refresh failed (${response.status}): ${text}`);
+    }
+    const data = (await response.json());
+    const refreshed = {
+        ...data,
+        refresh_token: data.refresh_token || token.refresh_token,
+        expires: Date.now() + data.expires_in * 1000,
+    };
+    storeToken(refreshed);
+    return refreshed;
+}

package/dist/spotify/client.d.ts

@@ -0,0 +1,18 @@
+import { SpotifyApi } from '@spotify/web-api-ts-sdk';
+import type { AuthenticateOptions } from './auth.js';
+/**
+ * Resolves the Spotify Client ID to use for authentication.
+ * Checks the `SPOTIFY_CLIENT_ID` environment variable first (allowing user overrides),
+ * then falls back to the default embedded at build time in `DEFAULT_SPOTIFY_CLIENT_ID`.
+ * @returns The client ID
+ * @throws When neither the environment variable nor the embedded default is set
+ */
+export declare function getClientId(): string;
+/**
+ * Creates an authenticated Spotify API client. Loads a stored token if available,
+ * refreshes it if expired, or runs the full OAuth flow for first-time authentication.
+ * @param clientId - Spotify application client ID
+ * @param options - Optional auth callbacks forwarded to {@link authenticate}
+ * @returns An authenticated Spotify API client
+ */
+export declare function createSpotifyClient(clientId: string, options?: AuthenticateOptions): Promise<SpotifyApi>;

package/dist/spotify/client.js

@@ -0,0 +1,48 @@
+import { SpotifyApi } from '@spotify/web-api-ts-sdk';
+import { DEFAULT_SPOTIFY_CLIENT_ID } from '../config.js';
+import { authenticate, isTokenExpired, loadStoredToken, refreshToken, storeToken } from './auth.js';
+import { fetchWithRetry } from './fetch-with-retry.js';
+/**
+ * Resolves the Spotify Client ID to use for authentication.
+ * Checks the `SPOTIFY_CLIENT_ID` environment variable first (allowing user overrides),
+ * then falls back to the default embedded at build time in `DEFAULT_SPOTIFY_CLIENT_ID`.
+ * @returns The client ID
+ * @throws When neither the environment variable nor the embedded default is set
+ */
+export function getClientId() {
+    // biome-ignore lint/complexity/useLiteralKeys: TS noPropertyAccessFromIndexSignature requires bracket notation
+    const fromEnv = process.env['SPOTIFY_CLIENT_ID'];
+    const clientId = fromEnv?.trim() || DEFAULT_SPOTIFY_CLIENT_ID;
+    if (!clientId) {
+        throw new Error('No Spotify Client ID available.\n' +
+            'Either the embedded default is empty, or override it at runtime:\n' +
+            '  1. Create a Spotify app at https://developer.spotify.com/dashboard\n' +
+            '  2. Set: export SPOTIFY_CLIENT_ID=your_client_id');
+    }
+    return clientId;
+}
+/**
+ * Creates an authenticated Spotify API client. Loads a stored token if available,
+ * refreshes it if expired, or runs the full OAuth flow for first-time authentication.
+ * @param clientId - Spotify application client ID
+ * @param options - Optional auth callbacks forwarded to {@link authenticate}
+ * @returns An authenticated Spotify API client
+ */
+export async function createSpotifyClient(clientId, options) {
+    let token = loadStoredToken();
+    if (token && isTokenExpired(token) && token.refresh_token) {
+        try {
+            token = await refreshToken(clientId, token);
+        }
+        catch {
+            token = null;
+        }
+    }
+    if (!token || isTokenExpired(token)) {
+        token = await authenticate(clientId, options);
+        storeToken(token);
+    }
+    return SpotifyApi.withAccessToken(clientId, token, {
+        fetch: fetchWithRetry,
+    });
+}

package/dist/spotify/fetch-with-retry.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetch wrapper that retries on 429 (rate limit) responses, deduplicates
+ * concurrent GET requests, and injects the shared `USER_AGENT` header into
+ * every request (Spotify Web API + LRCLIB).
+ */
+export declare function fetchWithRetry(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;

package/dist/spotify/fetch-with-retry.js

@@ -0,0 +1,70 @@
+import { USER_AGENT } from '../config.js';
+const MAX_RETRIES = 3;
+const DEFAULT_RETRY_AFTER_S = 1;
+const MAX_RETRY_AFTER_S = 5;
+const inflight = new Map();
+function getCacheKey(input, init) {
+    const url = input.toString();
+    const method = init?.method ?? 'GET';
+    return `${method}:${url}`;
+}
+/**
+ * Returns a new RequestInit with `User-Agent` set to the shared `USER_AGENT`
+ * constant unless the caller has already provided one.
+ */
+function withUserAgent(init) {
+    const headers = new Headers(init?.headers);
+    if (!headers.has('User-Agent')) {
+        headers.set('User-Agent', USER_AGENT);
+    }
+    return {
+        ...init,
+        headers,
+    };
+}
+/**
+ * Fetch wrapper that retries on 429 (rate limit) responses, deduplicates
+ * concurrent GET requests, and injects the shared `USER_AGENT` header into
+ * every request (Spotify Web API + LRCLIB).
+ */
+export function fetchWithRetry(input, init) {
+    const initWithUa = withUserAgent(init);
+    const key = getCacheKey(input, initWithUa);
+    console.error(`fetchWithRetry: ${key}`); // Log all fetch attempts for debugging
+    // Only deduplicate GET requests - mutations must always go through
+    const method = initWithUa.method ?? 'GET';
+    if (method !== 'GET') {
+        console.error(`fetchWithRetry: Body`, initWithUa.body); // Log request body for non-GET requests
+        return attempt(input, initWithUa, MAX_RETRIES);
+    }
+    const pending = inflight.get(key);
+    if (pending) {
+        return pending;
+    }
+    const promise = attempt(input, initWithUa, 0).finally(() => {
+        inflight.delete(key);
+    });
+    inflight.set(key, promise);
+    return promise;
+}
+async function attempt(input, init, retryCount) {
+    const response = await fetch(input, init);
+    if (!response.ok) {
+        // Clone the response so reading its body for logging doesn't consume the
+        // stream before the caller (e.g. the Spotify SDK's deserializer) can read it.
+        // Calling `.text()` on the original response would leave the body unusable
+        // and trigger "Body is unusable: Body has already been read" downstream.
+        const bodyText = await response.clone().text();
+        console.error(`Request failed with status ${response.status} for ${input.toString()}`, bodyText);
+    }
+    if (response.status !== 429 || retryCount >= MAX_RETRIES) {
+        return response;
+    }
+    const retryAfterHeader = response.headers.get('Retry-After');
+    const retryAfterS = retryAfterHeader ? Number.parseInt(retryAfterHeader, 10) : Number.NaN;
+    const clampedS = Number.isNaN(retryAfterS) ? DEFAULT_RETRY_AFTER_S : Math.min(retryAfterS, MAX_RETRY_AFTER_S);
+    const delayMs = clampedS * 1000;
+    console.error(`Received 429 for ${input.toString()}. Retrying after ${clampedS} seconds (retry ${retryCount + 1}/${MAX_RETRIES})`);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    return attempt(input, init, retryCount + 1);
+}