webpeel 0.21.64 → 0.21.66

package/dist/core/domain-extractors.js

@@ -93,6 +93,25 @@ const REGISTRY = [
     { match: (h) => h === 'www.producthunt.com' || h === 'producthunt.com', extractor: productHuntExtractor },
     { match: (h) => h === 'substack.com' || h === 'www.substack.com', extractor: substackRootExtractor },
     { match: (_h, url = '') => /\.pdf(\?|$|#)/i.test(url) || /\/pdf\//i.test(url), extractor: pdfExtractor },
+    // ── Prediction markets & trading ─────────────────────────────────────────
+    { match: (h) => h === 'polymarket.com' || h === 'www.polymarket.com', extractor: polymarketExtractor },
+    { match: (h) => h === 'kalshi.com' || h === 'www.kalshi.com', extractor: kalshiExtractor },
+    { match: (h) => h === 'tradingview.com' || h === 'www.tradingview.com', extractor: tradingViewExtractor },
+    // ── Sports ───────────────────────────────────────────────────────────────
+    { match: (h) => h === 'espn.com' || h === 'www.espn.com', extractor: espnExtractor },
+    { match: (h) => h === 'draftkings.com' || h === 'www.draftkings.com' || h === 'sportsbook.draftkings.com', extractor: sportsBettingExtractor },
+    { match: (h) => h === 'fanduel.com' || h === 'www.fanduel.com' || h === 'sportsbook.fanduel.com', extractor: sportsBettingExtractor },
+    { match: (h) => h === 'betmgm.com' || h === 'www.betmgm.com', extractor: sportsBettingExtractor },
+    // ── Academic papers ───────────────────────────────────────────────────────
+    { match: (h) => h === 'semanticscholar.org' || h === 'www.semanticscholar.org', extractor: semanticScholarExtractor },
+    { match: (h) => h === 'pubmed.ncbi.nlm.nih.gov', extractor: pubmedExtractor },
+    // ── Crypto ───────────────────────────────────────────────────────────────
+    { match: (h) => h === 'coingecko.com' || h === 'www.coingecko.com', extractor: coinGeckoExtractor },
+    { match: (h) => h === 'coinmarketcap.com' || h === 'www.coinmarketcap.com', extractor: coinGeckoExtractor },
+    // ── Weather ──────────────────────────────────────────────────────────────
+    { match: (h) => h === 'open-meteo.com' || h === 'api.open-meteo.com' || h === 'www.open-meteo.com', extractor: weatherExtractor },
+    { match: (h) => h === 'weather.com' || h === 'www.weather.com', extractor: weatherExtractor },
+    { match: (h) => h === 'accuweather.com' || h === 'www.accuweather.com', extractor: weatherExtractor },
 ];
 /**
  * Returns the domain extractor for a URL, or null if none matches.
@@ -943,21 +962,13 @@ ${commentsMd || '*No comments.*'}`;
             if (repoData.message.includes('secondary rate limit') || repoData.message.includes('abuse'))
                 return null;
         }
-        const readmeData = await fetchJsonWithRetry(`https://api.github.com/repos/${owner}/${repo}/readme`, ghHeaders, 1, 500).catch(() => null);
-        // README content is base64 encoded
-        let readmeText = '';
-        if (readmeData?.content) {
-            try {
-                readmeText = Buffer.from(readmeData.content, 'base64').toString('utf-8').slice(0, 5000);
-            }
-            catch { /* ignore */ }
-        }
         const structured = {
             title: `${owner}/${repo}`,
             name: `${owner}/${repo}`,
             description: repoData.description || '',
             stars: repoData.stargazers_count ?? 0,
             forks: repoData.forks_count ?? 0,
+            watchers: repoData.watchers_count ?? 0,
             language: repoData.language || null,
             topics: repoData.topics || [],
             license: repoData.license?.spdx_id || null,
@@ -968,18 +979,27 @@ ${commentsMd || '*No comments.*'}`;
             homepage: repoData.homepage || null,
             archived: repoData.archived || false,
             fork: repoData.fork || false,
-            readme: readmeText,
+            url: repoData.html_url || `https://github.com/${owner}/${repo}`,
         };
-        const topicsStr = structured.topics.length ? structured.topics.join(', ') : 'none';
-        const cleanContent = `## 📦 Repository: ${structured.name}
-
-${structured.description || '*No description.*'}
-
-⭐ ${structured.stars.toLocaleString()} stars  |  🍴 ${structured.forks.toLocaleString()} forks  |  💻 ${structured.language || 'N/A'}  |  📜 ${structured.license || 'N/A'}
-🏷️ Topics: ${topicsStr}
-🔗 ${structured.homepage || 'No homepage'}  |  Last push: ${structured.lastPush}${structured.archived ? '\n⚠️ **ARCHIVED**' : ''}
-
-${structured.readme ? `### README\n\n${structured.readme}` : ''}`;
+        const topicsStr = structured.topics.length ? structured.topics.slice(0, 8).join(', ') : '';
+        const updatedDate = structured.lastPush ? structured.lastPush.slice(0, 10) : 'N/A';
+        const lines = [
+            `# 💻 ${structured.name}`,
+            '',
+            structured.description ? `**${structured.description}**` : '*No description.*',
+            '',
+            `- ⭐ Stars: ${structured.stars.toLocaleString()} | 🍴 Forks: ${structured.forks.toLocaleString()} | 📝 Language: ${structured.language || 'N/A'}`,
+            `- 📦 License: ${structured.license || 'None'} | 🔄 Updated: ${updatedDate}`,
+            `- 📊 Open Issues: ${structured.openIssues}${structured.archived ? ' | ⚠️ ARCHIVED' : ''}`,
+        ];
+        if (topicsStr)
+            lines.push(`- 🏷️ Topics: ${topicsStr}`);
+        lines.push('');
+        const links = [`[Repository](${structured.url})`];
+        if (structured.homepage)
+            links.push(`[Homepage](${structured.homepage})`);
+        lines.push(`**Links:** ${links.join(' · ')}`);
+        const cleanContent = lines.join('\n');
         return { domain, type: 'repository', structured, cleanContent };
     }
     return null;
@@ -1095,11 +1115,18 @@ ${commentsMd || '*No comments found.*'}`;
             commentCount: s.descendants ?? 0,
             url: s.url || `https://news.ycombinator.com/item?id=${s.id}`,
             hnUrl: `https://news.ycombinator.com/item?id=${s.id}`,
+            domain: s.url ? (() => { try {
+                return new URL(s.url).hostname.replace(/^www\./, '');
+            }
+            catch {
+                return '';
+            } })() : '',
         }));
         const structured = { title: 'Hacker News — Front Page', stories };
+        // Compact format: title (domain) | score pts | N comments
         const cleanContent = `## 🟠 Hacker News — Front Page
 
-${stories.map((s, i) => `${i + 1}. **${s.title}**\n   ↑ ${s.score} | 💬 ${s.commentCount} | by ${s.author}\n   ${s.url}`).join('\n\n')}`;
+${stories.map((s, i) => `${i + 1}. **${s.title}**${s.domain ? ` (${s.domain})` : ''} — ↑${s.score} · 💬${s.commentCount}`).join('\n')}`;
         return { domain, type: 'frontpage', structured, cleanContent };
     }
     // User page: ?id=username
@@ -1141,7 +1168,7 @@ function cleanWikipediaContent(content) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
-async function wikipediaExtractor(_html, url) {
+async function wikipediaExtractor(_html, url, options) {
     const urlObj = new URL(url);
     const pathParts = urlObj.pathname.split('/').filter(Boolean);
     // Only handle article pages: /wiki/Article_Title
@@ -1152,56 +1179,70 @@ async function wikipediaExtractor(_html, url) {
     if (articleTitle.includes(':'))
         return null;
     const lang = urlObj.hostname.split('.')[0] || 'en';
-    const apiUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(articleTitle)}`;
+    const summaryUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(articleTitle)}`;
     // Wikipedia REST API requires a descriptive User-Agent (https://meta.wikimedia.org/wiki/User-Agent_policy)
     const wikiHeaders = { 'User-Agent': 'WebPeel/0.17.1 (https://webpeel.dev; jake@jakeliu.me) Node.js', 'Api-User-Agent': 'WebPeel/0.17.1 (https://webpeel.dev; jake@jakeliu.me)' };
     try {
-        const data = await fetchJson(apiUrl, wikiHeaders);
+        const data = await fetchJson(summaryUrl, wikiHeaders);
         if (!data || data.type === 'https://mediawiki.org/wiki/HyperSwitch/errors/not_found')
             return null;
-        // For full article content, use the mobile-html endpoint (mobile-sections is deprecated)
-        let fullContent = '';
-        let mobileHtmlSize;
-        try {
-            const fullUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/mobile-html/${encodeURIComponent(articleTitle)}`;
-            const fullResult = await simpleFetch(fullUrl, undefined, 15000, {
-                ...wikiHeaders,
-                'Accept': 'text/html',
-            });
-            if (fullResult?.html) {
-                mobileHtmlSize = fullResult.html.length;
-                // Parse sections from the mobile HTML
-                const sectionMatches = fullResult.html.match(/<section[^>]*>([\s\S]*?)<\/section>/gi) || [];
-                for (const section of sectionMatches) {
-                    // Extract section heading
-                    const headingMatch = section.match(/<h[2-6][^>]*id="([^"]*)"[^>]*class="[^"]*pcs-edit-section-title[^"]*"[^>]*>([\s\S]*?)<\/h[2-6]>/i);
-                    const heading = headingMatch ? stripHtml(headingMatch[2]).trim() : '';
-                    // Extract paragraphs
-                    const paragraphs = section.match(/<p[^>]*>([\s\S]*?)<\/p>/gi) || [];
-                    const sectionText = paragraphs.map((p) => stripHtml(p).trim()).filter((t) => t.length > 0).join('\n\n');
-                    if (sectionText) {
-                        const prefix = heading ? `## ${heading}\n\n` : '';
-                        fullContent += `\n\n${prefix}${sectionText}`;
-                    }
-                }
-            }
-        }
-        catch (e) {
-            // mobile-html failed — use summary extract as fallback
-            if (process.env.DEBUG)
-                console.debug('[webpeel]', 'Wikipedia mobile-html failed, using summary:', e instanceof Error ? e.message : e);
-        }
-        // Clean Wikipedia-specific noise
-        fullContent = cleanWikipediaContent(fullContent);
         const structured = {
             title: data.title || articleTitle.replace(/_/g, ' '),
             description: data.description || '',
             extract: data.extract || '',
+            extractHtml: data.extract_html || '',
             thumbnail: data.thumbnail?.source || null,
             url: data.content_urls?.desktop?.page || url,
             lastModified: data.timestamp || null,
+            coordinates: data.coordinates || null,
         };
-        const cleanContent = `# ${structured.title}\n\n${structured.description ? `*${structured.description}*\n\n` : ''}${fullContent || structured.extract}`;
+        // Default: use summary API (200-400 tokens). Only fetch full article if budget > 5000.
+        const budget = options?.budget ?? 0;
+        const useFull = budget > 5000;
+        let bodyContent = structured.extract;
+        let mobileHtmlSize;
+        if (useFull) {
+            try {
+                const fullUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/mobile-html/${encodeURIComponent(articleTitle)}`;
+                const fullResult = await simpleFetch(fullUrl, undefined, 15000, {
+                    ...wikiHeaders,
+                    'Accept': 'text/html',
+                });
+                if (fullResult?.html) {
+                    mobileHtmlSize = fullResult.html.length;
+                    let fullContent = '';
+                    const sectionMatches = fullResult.html.match(/<section[^>]*>([\s\S]*?)<\/section>/gi) || [];
+                    for (const section of sectionMatches) {
+                        const headingMatch = section.match(/<h[2-6][^>]*id="([^"]*)"[^>]*class="[^"]*pcs-edit-section-title[^"]*"[^>]*>([\s\S]*?)<\/h[2-6]>/i);
+                        const heading = headingMatch ? stripHtml(headingMatch[2]).trim() : '';
+                        const paragraphs = section.match(/<p[^>]*>([\s\S]*?)<\/p>/gi) || [];
+                        const sectionText = paragraphs.map((p) => stripHtml(p).trim()).filter((t) => t.length > 0).join('\n\n');
+                        if (sectionText) {
+                            const prefix = heading ? `## ${heading}\n\n` : '';
+                            fullContent += `\n\n${prefix}${sectionText}`;
+                        }
+                    }
+                    bodyContent = cleanWikipediaContent(fullContent) || structured.extract;
+                }
+            }
+            catch (e) {
+                if (process.env.DEBUG)
+                    console.debug('[webpeel]', 'Wikipedia mobile-html failed, using summary:', e instanceof Error ? e.message : e);
+            }
+        }
+        const articleUrl = structured.url;
+        const lines = [
+            `# ${structured.title}`,
+            '',
+        ];
+        if (structured.description)
+            lines.push(`*${structured.description}*`, '');
+        lines.push(bodyContent);
+        if (structured.coordinates) {
+            lines.push('', `📍 Coordinates: ${structured.coordinates.lat}, ${structured.coordinates.lon}`);
+        }
+        lines.push('', `📖 [Read full article on Wikipedia](${articleUrl})`);
+        const cleanContent = lines.join('\n');
         return { domain: 'wikipedia.org', type: 'article', structured, cleanContent, rawHtmlSize: mobileHtmlSize };
     }
     catch (e) {
@@ -1403,6 +1444,67 @@ async function youtubeExtractor(_html, url) {
 async function arxivExtractor(_html, url) {
     const urlObj = new URL(url);
     const path = urlObj.pathname;
+    // --- Search page: /search/?query=... or /search/?searchtype=all&query=... ---
+    if (path.startsWith('/search')) {
+        const rawQuery = urlObj.searchParams.get('query') || '';
+        if (!rawQuery)
+            return null;
+        try {
+            const searchQuery = encodeURIComponent(`all:${rawQuery}`);
+            const apiUrl = `https://export.arxiv.org/api/query?search_query=${searchQuery}&max_results=10&sortBy=relevance`;
+            const result = await simpleFetch(apiUrl, 'WebPeel/0.21', 20000, { Accept: 'application/xml' });
+            if (!result?.html)
+                return null;
+            const xml = result.html;
+            // Parse total results count from opensearch:totalResults
+            const totalMatch = xml.match(/<opensearch:totalResults[^>]*>(\d+)<\/opensearch:totalResults>/);
+            const total = totalMatch ? parseInt(totalMatch[1], 10) : 0;
+            // Parse all entries
+            const entries = [...xml.matchAll(/<entry[\s\S]*?<\/entry>/g)].map(m => m[0]);
+            const papers = entries.map(entryXml => {
+                const getTag = (tag) => {
+                    const match = entryXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+                    return match ? stripHtml(match[1]).trim() : '';
+                };
+                const getAllTags = (tag) => {
+                    const matches = [...entryXml.matchAll(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, 'g'))];
+                    return matches.map(m => stripHtml(m[1]).trim()).filter(Boolean);
+                };
+                const title = getTag('title');
+                const published = getTag('published');
+                const authors = getAllTags('name');
+                const summary = getTag('summary');
+                // Extract arXiv ID from <id> tag
+                const idTag = getTag('id');
+                const idMatch2 = idTag.match(/abs\/(\d{4}\.\d{4,5}(?:v\d+)?)/);
+                const paperId2 = idMatch2 ? idMatch2[1] : '';
+                // Categories
+                const cats = [...entryXml.matchAll(/category[^>]*term="([^"]+)"/g)].map(m => m[1]);
+                return { title, published: published?.split('T')[0], authors, summary, paperId: paperId2, categories: cats };
+            }).filter(p => p.title);
+            if (papers.length === 0)
+                return null;
+            const rows = papers.map((p, i) => {
+                const authorLine = p.authors.length === 0 ? '—'
+                    : p.authors.length === 1 ? p.authors[0]
+                        : `${p.authors[0]} et al.`;
+                const pdfLink = p.paperId ? ` [[PDF](https://arxiv.org/pdf/${p.paperId})]` : '';
+                return `| ${i + 1} | [${p.title}](https://arxiv.org/abs/${p.paperId}) | ${p.published || '?'} | ${authorLine} |${pdfLink}`;
+            }).join('\n');
+            const cleanContent = `# 🔍 arXiv Search — "${rawQuery}"\n\n| # | Paper | Published | Authors |\n|---|-------|-----------|--------|\n${rows}\n\n*Source: arXiv API · Total results: ${total.toLocaleString()}*`;
+            return {
+                domain: 'arxiv.org',
+                type: 'search',
+                structured: { query: rawQuery, total, papers },
+                cleanContent,
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'ArXiv search failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
     // Extract paper ID from URL patterns:
     // /abs/2501.12948, /pdf/2501.12948, /abs/2501.12948v2
     const idMatch = path.match(/\/(abs|pdf|html)\/(\d{4}\.\d{4,5}(?:v\d+)?)/);
@@ -1462,7 +1564,7 @@ async function arxivExtractor(_html, url) {
         const authorLine = authors.length <= 5
             ? authors.join(', ')
             : `${authors.slice(0, 5).join(', ')} et al. (${authors.length} authors)`;
-        const cleanContent = `# ${title}\n\n**Authors:** ${authorLine}\n**Published:** ${published?.split('T')[0] || 'N/A'}${categories.length ? `\n**Categories:** ${categories.join(', ')}` : ''}${doi ? `\n**DOI:** ${doi}` : ''}${journalRef ? `\n**Journal:** ${journalRef}` : ''}\n\n## Abstract\n\n${summary}\n\n📄 [PDF](${structured.pdfUrl}) | [Abstract](${structured.absUrl})`;
+        const cleanContent = `# 📄 arXiv: ${title} (${paperId})\n\n**Authors:** ${authorLine}\n**Submitted:** ${published?.split('T')[0] || 'N/A'}${categories.length ? `\n**Categories:** ${categories.join(', ')}` : ''}${doi ? `\n**DOI:** ${doi}` : ''}${journalRef ? `\n**Journal:** ${journalRef}` : ''}\n\n## Abstract\n\n${summary}\n\n**PDF:** [Download](${structured.pdfUrl}) | **HTML:** [View](https://arxiv.org/html/${paperId})`;
         return { domain: 'arxiv.org', type: 'paper', structured, cleanContent };
     }
     catch (e) {
@@ -3385,3 +3487,1300 @@ Browse newsletters at:
 *WebPeel works best with individual Substack post URLs, not the root homepage.*`;
     return { domain: 'substack.com', type: 'homepage', structured, cleanContent };
 }
+// ---------------------------------------------------------------------------
+// 33. Polymarket extractor — prediction market data via Gamma API
+// ---------------------------------------------------------------------------
+async function polymarketExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'polymarket.com';
+    // Helper: format price as percent
+    const fmtPct = (p) => {
+        const n = typeof p === 'string' ? parseFloat(p) : p;
+        if (isNaN(n))
+            return '?%';
+        return (n * 100).toFixed(1) + '%';
+    };
+    // Helper: format large dollar amount
+    const fmtVol = (v) => {
+        const n = typeof v === 'string' ? parseFloat(v) : v;
+        if (isNaN(n) || n === 0)
+            return '$0';
+        if (n >= 1_000_000)
+            return `$${(n / 1_000_000).toFixed(1)}M`;
+        if (n >= 1_000)
+            return `$${(n / 1_000).toFixed(1)}K`;
+        return `$${n.toFixed(0)}`;
+    };
+    // Helper: format date string
+    const fmtDate = (d) => {
+        if (!d)
+            return '?';
+        return d.slice(0, 10);
+    };
+    // --- Specific event page: /event/<slug> ---
+    const eventMatch = path.match(/^\/event\/([^/?#]+)/);
+    if (eventMatch) {
+        const slug = eventMatch[1];
+        try {
+            // Fetch event by slug from gamma API
+            const events = await fetchJson(`https://gamma-api.polymarket.com/events?slug=${encodeURIComponent(slug)}&limit=1`);
+            if (Array.isArray(events) && events.length > 0) {
+                const event = events[0];
+                const markets = event.markets || [];
+                const structured = {
+                    title: event.title || slug,
+                    slug: event.slug,
+                    volume: event.volume,
+                    volume24hr: event.volume24hr,
+                    endDate: event.endDate,
+                    markets: markets.map((m) => ({
+                        question: m.question,
+                        outcomes: m.outcomes,
+                        outcomePrices: m.outcomePrices,
+                        volume: m.volume,
+                        volume24hr: m.volume24hr,
+                        endDate: m.endDate,
+                        bestBid: m.bestBid,
+                        bestAsk: m.bestAsk,
+                        lastTradePrice: m.lastTradePrice,
+                    })),
+                };
+                const marketsMd = markets.map((m) => {
+                    const outcomes = JSON.parse(m.outcomes || '[]');
+                    const prices = JSON.parse(m.outcomePrices || '[]');
+                    const priceStr = outcomes.map((o, i) => `${o}: **${fmtPct(prices[i] ?? 0)}**`).join(' | ');
+                    const vol24 = m.volume24hr ? ` | Vol 24h: ${fmtVol(m.volume24hr)}` : '';
+                    const endDate = m.endDate ? ` | Ends: ${fmtDate(m.endDate)}` : '';
+                    return `- **${m.question}**\n  ${priceStr}${vol24}${endDate}`;
+                }).join('\n\n');
+                const totalVol24 = fmtVol(event.volume24hr || 0);
+                const totalVol = fmtVol(event.volume || 0);
+                const cleanContent = `# 📊 Polymarket: ${event.title || slug}
+
+**Volume (24h):** ${totalVol24} | **Total Volume:** ${totalVol} | **Ends:** ${fmtDate(event.endDate)}
+
+## Markets
+
+${marketsMd || '*No active markets found.*'}
+
+---
+*Source: [Polymarket](https://polymarket.com/event/${slug}) · Data via Polymarket Gamma API*`;
+                return { domain, type: 'event', structured, cleanContent };
+            }
+            // If event not found by slug, try a keyword search in markets
+            const markets = await fetchJson(`https://gamma-api.polymarket.com/markets?closed=false&limit=10&order=volume24hr&ascending=false&q=${encodeURIComponent(slug.replace(/-/g, ' '))}`);
+            if (Array.isArray(markets) && markets.length > 0) {
+                return buildPolymarketMarketList(markets, domain, `Search: ${slug}`);
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'Polymarket event fetch failed:', e instanceof Error ? e.message : e);
+        }
+    }
+    // --- Main page or /markets: show top markets by 24h volume ---
+    try {
+        const markets = await fetchJson('https://gamma-api.polymarket.com/markets?closed=false&limit=20&order=volume24hr&ascending=false');
+        if (Array.isArray(markets)) {
+            return buildPolymarketMarketList(markets, domain, 'Top Markets');
+        }
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Polymarket markets fetch failed:', e instanceof Error ? e.message : e);
+    }
+    return null;
+}
+function buildPolymarketMarketList(markets, domain, title) {
+    const fmtPct = (p) => {
+        const n = typeof p === 'string' ? parseFloat(p) : p;
+        if (isNaN(n))
+            return '?%';
+        return (n * 100).toFixed(1) + '%';
+    };
+    const fmtVol = (v) => {
+        const n = typeof v === 'string' ? parseFloat(v) : v;
+        if (isNaN(n) || n === 0)
+            return '$0';
+        if (n >= 1_000_000)
+            return `$${(n / 1_000_000).toFixed(1)}M`;
+        if (n >= 1_000)
+            return `$${(n / 1_000).toFixed(1)}K`;
+        return `$${n.toFixed(0)}`;
+    };
+    const rows = markets.slice(0, 15).map((m) => {
+        const outcomes = (() => { try {
+            return JSON.parse(m.outcomes || '[]');
+        }
+        catch {
+            return [];
+        } })();
+        const prices = (() => { try {
+            return JSON.parse(m.outcomePrices || '[]');
+        }
+        catch {
+            return [];
+        } })();
+        const yesPrice = outcomes[0] ? fmtPct(prices[0] ?? 0) : '?%';
+        const vol24 = fmtVol(m.volume24hr || 0);
+        const end = m.endDate ? m.endDate.slice(0, 10) : '?';
+        return `| ${m.question} | ${yesPrice} | ${vol24} | ${end} |`;
+    }).join('\n');
+    const structured = {
+        markets: markets.slice(0, 15).map((m) => ({
+            question: m.question,
+            slug: m.slug,
+            outcomePrices: m.outcomePrices,
+            outcomes: m.outcomes,
+            volume24hr: m.volume24hr,
+            endDate: m.endDate,
+        })),
+        fetchedAt: new Date().toISOString(),
+    };
+    const cleanContent = `# 📊 Polymarket — ${title}
+
+| Question | Yes Price | Vol 24h | End Date |
+|----------|-----------|---------|----------|
+${rows}
+
+---
+*Source: [Polymarket](https://polymarket.com) · Data via Polymarket Gamma API*`;
+    return { domain, type: 'markets', structured, cleanContent };
+}
+// ---------------------------------------------------------------------------
+// 34. Kalshi extractor — prediction market data via Kalshi Elections API
+// ---------------------------------------------------------------------------
+async function kalshiExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'kalshi.com';
+    // Helper: format Kalshi dollar price (they use dollars like 0.78 = 78¢ = 78%)
+    const fmtPct = (v) => {
+        const n = typeof v === 'string' ? parseFloat(v) : v;
+        if (n == null || isNaN(n))
+            return '?%';
+        return (n * 100).toFixed(0) + '%';
+    };
+    const fmtVol = (v) => {
+        const n = typeof v === 'string' ? parseFloat(v) : v;
+        if (n == null || isNaN(n) || n === 0)
+            return '$0';
+        if (n >= 1_000_000)
+            return `$${(n / 1_000_000).toFixed(1)}M`;
+        if (n >= 1_000)
+            return `$${(n / 1_000).toFixed(1)}K`;
+        return `$${n.toFixed(0)}`;
+    };
+    // --- Specific market/event page: /markets/<ticker> or /events/<ticker> ---
+    const tickerMatch = path.match(/^\/(?:markets|events)\/([^/?#]+)/);
+    if (tickerMatch) {
+        const ticker = tickerMatch[1].toUpperCase();
+        try {
+            // Try fetching the specific event by ticker
+            const data = await fetchJson(`https://api.elections.kalshi.com/trade-api/v2/events/${ticker}?with_nested_markets=true`);
+            const event = data?.event;
+            if (event) {
+                const markets = event.markets || [];
+                const structured = {
+                    title: event.title,
+                    ticker: event.event_ticker,
+                    category: event.category,
+                    markets: markets.map((m) => ({
+                        title: m.title,
+                        ticker: m.ticker,
+                        yes_bid: m.yes_bid_dollars,
+                        yes_ask: m.yes_ask_dollars,
+                        volume: m.volume_fp,
+                        volume_24h: m.volume_24h_fp,
+                        last_price: m.last_price_dollars,
+                        expiration: m.expiration_time,
+                    })),
+                };
+                const marketsMd = markets.map((m) => {
+                    const yesBid = fmtPct(m.yes_bid_dollars);
+                    const yesAsk = fmtPct(m.yes_ask_dollars);
+                    const vol = fmtVol(m.volume_fp);
+                    const vol24 = fmtVol(m.volume_24h_fp);
+                    const expiry = m.expiration_time ? m.expiration_time.slice(0, 10) : '?';
+                    return `- **${m.title}**\n  Yes: ${yesBid}–${yesAsk} | Vol: ${vol} | Vol 24h: ${vol24} | Expires: ${expiry}`;
+                }).join('\n\n');
+                const cleanContent = `# 🎯 Kalshi: ${event.title}
+
+**Category:** ${event.category || 'General'} | **Ticker:** ${event.event_ticker}
+
+## Markets
+
+${marketsMd || '*No active markets found.*'}
+
+---
+*Source: [Kalshi](https://kalshi.com/markets/${ticker.toLowerCase()}) · Data via Kalshi Trade API*`;
+                return { domain, type: 'event', structured, cleanContent };
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'Kalshi event fetch failed:', e instanceof Error ? e.message : e);
+        }
+    }
+    // --- Main page or /markets: show top open events ---
+    try {
+        const data = await fetchJson('https://api.elections.kalshi.com/trade-api/v2/events?limit=20&status=open&with_nested_markets=true');
+        const events = data?.events || [];
+        if (events.length > 0) {
+            const rows = events.slice(0, 15).map((e) => {
+                const markets = e.markets || [];
+                const firstMkt = markets[0];
+                const yesBid = firstMkt ? fmtPct(firstMkt.yes_bid_dollars) : '?%';
+                const vol24 = firstMkt ? fmtVol(firstMkt.volume_24h_fp) : '$0';
+                const mktCount = markets.length > 1 ? ` (+${markets.length - 1} more)` : '';
+                return `| ${e.title} | ${yesBid}${mktCount} | ${vol24} | ${e.category || '?'} |`;
+            }).join('\n');
+            const structured = {
+                events: events.slice(0, 15).map((e) => ({
+                    title: e.title,
+                    ticker: e.event_ticker,
+                    category: e.category,
+                    markets: (e.markets || []).length,
+                })),
+                fetchedAt: new Date().toISOString(),
+            };
+            const cleanContent = `# 🎯 Kalshi — Top Open Events
+
+| Event | Yes Price | Vol 24h | Category |
+|-------|-----------|---------|----------|
+${rows}
+
+---
+*Source: [Kalshi](https://kalshi.com/markets) · Data via Kalshi Trade API*`;
+            return { domain, type: 'markets', structured, cleanContent };
+        }
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Kalshi markets fetch failed:', e instanceof Error ? e.message : e);
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// 35. TradingView extractor — stock/index data via TradingView Scanner API
+// ---------------------------------------------------------------------------
+async function tradingViewExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'tradingview.com';
+    const scannerHeaders = {
+        'Origin': 'https://www.tradingview.com',
+        'Referer': 'https://www.tradingview.com/',
+        'Content-Type': 'application/json',
+    };
+    // Helper: format price
+    const fmtPrice = (v) => {
+        if (v == null)
+            return '?';
+        if (v >= 1_000_000_000_000)
+            return `${(v / 1_000_000_000_000).toFixed(2)}T`;
+        if (v >= 1_000_000_000)
+            return `${(v / 1_000_000_000).toFixed(2)}B`;
+        if (v >= 1_000_000)
+            return `${(v / 1_000_000).toFixed(2)}M`;
+        if (v >= 1_000)
+            return `${(v / 1_000).toFixed(2)}K`;
+        return v.toFixed(2);
+    };
+    const fmtChange = (c) => {
+        if (c == null)
+            return '';
+        const sign = c >= 0 ? '+' : '';
+        return `${sign}${c.toFixed(2)}%`;
+    };
+    // --- Symbol page: /symbols/<TICKER>/ or /chart?symbol=<TICKER> ---
+    const symbolMatch = path.match(/^\/symbols\/([^/?#]+)\/?/);
+    const chartSymbolParam = urlObj.searchParams.get('symbol');
+    let ticker = symbolMatch?.[1] || chartSymbolParam || null;
+    if (ticker) {
+        ticker = ticker.toUpperCase().replace(/-/g, '');
+        try {
+            // Try symbol search to resolve exchange
+            const searchResp = await fetch(`https://symbol-search.tradingview.com/symbol_search/?text=${encodeURIComponent(ticker)}&hl=0&lang=en&type=stock,fund,crypto,futures,forex&limit=5`, {
+                headers: {
+                    'User-Agent': 'webpeel/0.21 (https://webpeel.dev)',
+                    'Origin': 'https://www.tradingview.com',
+                    'Referer': 'https://www.tradingview.com/',
+                },
+                signal: AbortSignal.timeout(10000),
+            });
+            const searchData = await searchResp.json().catch(() => []);
+            // Find exact match
+            const exactMatch = searchData.find(s => s.symbol === ticker || s.symbol.replace(/<\/?em>/g, '') === ticker);
+            const symbolInfo = exactMatch || searchData[0];
+            if (symbolInfo) {
+                const exchange = symbolInfo.source_id || symbolInfo.exchange || 'NASDAQ';
+                // Fetch quote data via scanner
+                const scannerUrl = exchange === 'CRYPTO' || exchange === 'COINBASE' || exchange === 'BINANCE'
+                    ? 'https://scanner.tradingview.com/crypto/scan'
+                    : 'https://scanner.tradingview.com/america/scan';
+                const scanBody = {
+                    filter: [{ left: 'name', operation: 'equal', right: symbolInfo.symbol?.replace(/<\/?em>/g, '') || ticker }],
+                    columns: ['name', 'description', 'close', 'open', 'high', 'low', 'volume', 'change', 'change_abs', 'market_cap_basic', 'sector', 'industry', 'country', 'currency'],
+                    range: [0, 1],
+                };
+                const scanResp = await fetch(scannerUrl, {
+                    method: 'POST',
+                    headers: { ...scannerHeaders, 'User-Agent': 'webpeel/0.21 (https://webpeel.dev)' },
+                    body: JSON.stringify(scanBody),
+                    signal: AbortSignal.timeout(10000),
+                });
+                const scanData = await scanResp.json().catch(() => null);
+                const row = scanData?.data?.[0]?.d;
+                if (row) {
+                    const [name, desc, close, open, high, low, volume, changePct, changeAbs, mktCap, sector, industry, country, currency] = row;
+                    const currStr = currency || 'USD';
+                    const mktCapStr = mktCap ? fmtPrice(mktCap) : null;
+                    const structured = {
+                        symbol: name,
+                        description: desc,
+                        price: close,
+                        open,
+                        high,
+                        low,
+                        volume,
+                        change_pct: changePct,
+                        change_abs: changeAbs,
+                        market_cap: mktCap,
+                        sector,
+                        industry,
+                        country,
+                        currency: currStr,
+                        exchange,
+                        fetchedAt: new Date().toISOString(),
+                    };
+                    const changeStr = fmtChange(changePct);
+                    const changeIcon = (changePct ?? 0) >= 0 ? '📈' : '📉';
+                    const cleanContent = `# ${changeIcon} TradingView: ${desc || name} (${name})
+
+## Quote
+- **Price:** ${close?.toFixed(2) ?? '?'} ${currStr}
+- **Change:** ${changeStr} (${changeAbs?.toFixed(2) ?? '?'} ${currStr})
+- **Open:** ${open?.toFixed(2) ?? '?'} | **High:** ${high?.toFixed(2) ?? '?'} | **Low:** ${low?.toFixed(2) ?? '?'}
+- **Volume:** ${fmtPrice(volume ?? 0)}
+${mktCapStr ? `- **Market Cap:** ${mktCapStr} ${currStr}` : ''}
+
+## Details
+${sector ? `- **Sector:** ${sector}` : ''}
+${industry ? `- **Industry:** ${industry}` : ''}
+${country ? `- **Country:** ${country}` : ''}
+- **Exchange:** ${exchange}
+
+---
+*Source: [TradingView](https://www.tradingview.com/symbols/${name}/) · Data via TradingView Scanner API*`;
+                    return { domain, type: 'symbol', structured, cleanContent };
+                }
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'TradingView symbol fetch failed:', e instanceof Error ? e.message : e);
+        }
+    }
+    // --- Markets overview page or fallback: show major indices ---
+    try {
+        // Fetch major indices + top stocks
+        const scanBody = {
+            filter: [
+                { left: 'name', operation: 'in_range', right: ['SPX', 'NDX', 'DJI', 'RUT', 'VIX', 'AAPL', 'MSFT', 'NVDA', 'AMZN', 'GOOGL', 'META', 'TSLA'] },
+            ],
+            columns: ['name', 'description', 'close', 'change', 'volume', 'market_cap_basic'],
+            sort: { sortBy: 'market_cap_basic', sortOrder: 'desc' },
+            range: [0, 20],
+        };
+        const resp = await fetch('https://scanner.tradingview.com/global/scan', {
+            method: 'POST',
+            headers: { ...scannerHeaders, 'User-Agent': 'webpeel/0.21 (https://webpeel.dev)' },
+            body: JSON.stringify(scanBody),
+            signal: AbortSignal.timeout(10000),
+        });
+        const data = await resp.json().catch(() => null);
+        const rows = data?.data || [];
+        if (rows.length > 0) {
+            const tableRows = rows.map((row) => {
+                const [name, desc, close, changePct] = row.d;
+                const changeStr = changePct != null ? `${changePct >= 0 ? '+' : ''}${changePct.toFixed(2)}%` : '?%';
+                const icon = (changePct ?? 0) >= 0 ? '🟢' : '🔴';
+                return `| ${name} | ${desc} | ${close?.toFixed(2) ?? '?'} | ${icon} ${changeStr} |`;
+            }).join('\n');
+            const structured = {
+                symbols: rows.map((r) => ({
+                    symbol: r.d[0],
+                    description: r.d[1],
+                    price: r.d[2],
+                    change_pct: r.d[3],
+                })),
+                fetchedAt: new Date().toISOString(),
+            };
+            const now = new Date().toLocaleString('en-US', { timeZone: 'America/New_York', hour12: false });
+            const cleanContent = `# 📈 TradingView — Market Overview
+
+*As of ${now} ET*
+
+| Symbol | Name | Price | Change |
+|--------|------|-------|--------|
+${tableRows}
+
+---
+*Source: [TradingView](https://www.tradingview.com/markets/) · Data via TradingView Scanner API*`;
+            return { domain, type: 'markets', structured, cleanContent };
+        }
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'TradingView markets fetch failed:', e instanceof Error ? e.message : e);
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// 36. ESPN extractor — live scores, standings, schedules via ESPN public API
+// ---------------------------------------------------------------------------
+/** Map ESPN URL path prefixes to sport/league identifiers for the API. */
+function matchESPN(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return null;
+    }
+    if (!u.hostname.includes('espn.com'))
+        return null;
+    const path = u.pathname.toLowerCase();
+    // Map URL path prefixes to [sport, league]
+    const sportMap = {
+        '/nba': ['basketball', 'nba'],
+        '/wnba': ['basketball', 'wnba'],
+        '/nfl': ['football', 'nfl'],
+        '/mlb': ['baseball', 'mlb'],
+        '/nhl': ['hockey', 'nhl'],
+        '/college-football': ['football', 'college-football'],
+        '/mens-college-basketball': ['basketball', 'mens-college-basketball'],
+        '/womens-college-basketball': ['basketball', 'womens-college-basketball'],
+        '/soccer': ['soccer', 'eng.1'],
+        '/mma': ['mma', 'ufc'],
+    };
+    for (const [prefix, [sport, league]] of Object.entries(sportMap)) {
+        if (path.startsWith(prefix)) {
+            // Override soccer league if explicitly in URL path (e.g. /soccer/scoreboard/_/league/usa.1)
+            let resolvedLeague = league;
+            if (sport === 'soccer') {
+                const leagueMatch = path.match(/\/league\/([^/?#]+)/);
+                if (leagueMatch)
+                    resolvedLeague = leagueMatch[1];
+            }
+            if (path.includes('standings'))
+                return { sport, league: resolvedLeague, type: 'standings' };
+            if (path.includes('/team/') || path.includes('/teams/')) {
+                const nameMatch = path.split('/name/')[1]?.split('/')[0];
+                return { sport, league: resolvedLeague, type: 'team', param: nameMatch };
+            }
+            if (path.includes('scores') || path.includes('scoreboard'))
+                return { sport, league: resolvedLeague, type: 'scoreboard' };
+            return { sport, league: resolvedLeague, type: 'scoreboard' }; // default to scoreboard
+        }
+    }
+    // Fallback: espn.com root or unknown path → NBA scoreboard
+    return { sport: 'basketball', league: 'nba', type: 'scoreboard' };
+}
+/** Sport emoji mapping. */
+function espnSportEmoji(sport, league) {
+    if (league === 'nba' || league === 'wnba')
+        return '🏀';
+    if (sport === 'football')
+        return '🏈';
+    if (sport === 'baseball')
+        return '⚾';
+    if (sport === 'hockey')
+        return '🏒';
+    if (sport === 'soccer')
+        return '⚽';
+    if (sport === 'mma' || league === 'ufc')
+        return '🥊';
+    return '🏆';
+}
+/** Format a UTC ISO date string to "7:30 PM ET" style. */
+function fmtEspnTime(isoDate) {
+    try {
+        const d = new Date(isoDate);
+        return d.toLocaleTimeString('en-US', {
+            timeZone: 'America/New_York',
+            hour: 'numeric',
+            minute: '2-digit',
+            hour12: true,
+        }) + ' ET';
+    }
+    catch {
+        return isoDate;
+    }
+}
+/** Format today's date nicely: "March 18, 2026". */
+function fmtTodayESPN() {
+    return new Date().toLocaleDateString('en-US', {
+        timeZone: 'America/New_York',
+        month: 'long',
+        day: 'numeric',
+        year: 'numeric',
+    });
+}
+async function fetchEspnScoreboard(sport, league) {
+    try {
+        const apiUrl = `https://site.api.espn.com/apis/site/v2/sports/${sport}/${league}/scoreboard`;
+        const data = await fetchJson(apiUrl);
+        const events = data?.events || [];
+        const emoji = espnSportEmoji(sport, league);
+        const leagueName = data?.leagues?.[0]?.name || league.toUpperCase();
+        const today = fmtTodayESPN();
+        if (events.length === 0) {
+            return `# ${emoji} ${leagueName} Scoreboard — ${today}\n\n*No games scheduled today.*`;
+        }
+        const rows = events.map((e) => {
+            const comp = e.competitions?.[0] || {};
+            const status = comp.status?.type || {};
+            const competitors = comp.competitors || [];
+            // Away team first, home team second (standard display)
+            const away = competitors.find((c) => c.homeAway === 'away') || competitors[0];
+            const home = competitors.find((c) => c.homeAway === 'home') || competitors[1];
+            const awayName = away?.team?.displayName || away?.team?.name || '?';
+            const homeName = home?.team?.displayName || home?.team?.name || '?';
+            const gameLabel = `${awayName} at ${homeName}`;
+            let scoreStr = '-';
+            let statusStr = '';
+            const state = status.state || 'pre';
+            const description = status.description || 'Scheduled';
+            if (state === 'pre') {
+                scoreStr = '-';
+                statusStr = fmtEspnTime(comp.startDate || e.date || '');
+            }
+            else if (state === 'in') {
+                const awayScore = away?.score ?? '0';
+                const homeScore = home?.score ?? '0';
+                const awayAbbr = away?.team?.abbreviation || '?';
+                const homeAbbr = home?.team?.abbreviation || '?';
+                scoreStr = `${awayAbbr} ${awayScore}, ${homeAbbr} ${homeScore}`;
+                const period = comp.status?.period ?? '';
+                const clock = comp.status?.displayClock ?? '';
+                statusStr = period && clock ? `Q${period} ${clock}` : 'Live';
+            }
+            else {
+                const awayScore = away?.score ?? '0';
+                const homeScore = home?.score ?? '0';
+                const awayAbbr = away?.team?.abbreviation || '?';
+                const homeAbbr = home?.team?.abbreviation || '?';
+                scoreStr = `${awayAbbr} ${awayScore}, ${homeAbbr} ${homeScore}`;
+                statusStr = description || 'Final';
+            }
+            return `| ${gameLabel} | ${scoreStr} | ${statusStr} |`;
+        }).join('\n');
+        return `# ${emoji} ${leagueName} Scoreboard — ${today}\n\n| Game | Score | Status |\n|------|-------|--------|\n${rows}`;
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'ESPN scoreboard fetch failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}
+async function fetchEspnStandings(sport, league) {
+    try {
+        const apiUrl = `https://site.web.api.espn.com/apis/v2/sports/${sport}/${league}/standings?sort=winpercent:desc`;
+        const data = await fetchJson(apiUrl);
+        const children = data?.children || [];
+        const emoji = espnSportEmoji(sport, league);
+        const leagueName = data?.name || league.toUpperCase();
+        const today = fmtTodayESPN();
+        if (children.length === 0)
+            return null;
+        let output = `# ${emoji} ${leagueName} Standings — ${today}\n\n`;
+        for (const conf of children) {
+            const confName = conf.name || conf.abbreviation || 'Conference';
+            const entries = conf.standings?.entries || [];
+            output += `## ${confName}\n\n`;
+            output += `| # | Team | W | L | PCT | Streak |\n`;
+            output += `|---|------|---|---|-----|--------|\n`;
+            // Sort by playoff seed
+            const sorted = entries.slice().sort((a, b) => {
+                const seedA = a.stats?.find((s) => s.name === 'playoffSeed')?.value ?? 99;
+                const seedB = b.stats?.find((s) => s.name === 'playoffSeed')?.value ?? 99;
+                return seedA - seedB;
+            });
+            for (const entry of sorted) {
+                const team = entry.team?.displayName || '?';
+                const stats = entry.stats || [];
+                const getDisplay = (name) => stats.find((s) => s.name === name)?.displayValue || '?';
+                const getStat = (name) => stats.find((s) => s.name === name)?.value ?? '?';
+                const seed = getStat('playoffSeed');
+                const wins = getDisplay('wins');
+                const losses = getDisplay('losses');
+                const pct = getDisplay('winPercent');
+                const streak = getDisplay('streak');
+                output += `| ${seed} | ${team} | ${wins} | ${losses} | ${pct} | ${streak} |\n`;
+            }
+            output += '\n';
+        }
+        return output.trim();
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'ESPN standings fetch failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}
+async function espnExtractor(_html, url) {
+    const match = matchESPN(url);
+    if (!match)
+        return null;
+    const { sport, league, type } = match;
+    const domain = 'espn.com';
+    if (type === 'standings') {
+        const content = await fetchEspnStandings(sport, league);
+        if (!content)
+            return null;
+        return {
+            domain,
+            type: 'standings',
+            structured: { sport, league, dataType: 'standings' },
+            cleanContent: content,
+        };
+    }
+    if (type === 'team') {
+        // Try to get team info from the teams API
+        try {
+            const teamsUrl = `https://site.api.espn.com/apis/site/v2/sports/${sport}/${league}/teams`;
+            const teamsData = await fetchJson(teamsUrl);
+            const teams = teamsData?.sports?.[0]?.leagues?.[0]?.teams || [];
+            const param = match.param?.toLowerCase();
+            const teamEntry = param
+                ? teams.find((t) => {
+                    const td = t.team || t;
+                    return td.abbreviation?.toLowerCase() === param ||
+                        td.slug?.toLowerCase() === param ||
+                        td.displayName?.toLowerCase().includes(param);
+                })
+                : teams[0];
+            if (teamEntry) {
+                const td = teamEntry.team || teamEntry;
+                const emoji = espnSportEmoji(sport, league);
+                const content = `# ${emoji} ${td.displayName}\n\n**League:** ${league.toUpperCase()}\n\n*For live scores and standings, use:*\n- \`webpeel "https://espn.com/${league}/scoreboard"\`\n- \`webpeel "https://espn.com/${league}/standings"\``;
+                return {
+                    domain,
+                    type: 'team',
+                    structured: { sport, league, teamName: td.displayName, abbreviation: td.abbreviation },
+                    cleanContent: content,
+                };
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'ESPN team fetch failed:', e instanceof Error ? e.message : e);
+        }
+        // Fallback to scoreboard
+    }
+    // Default: scoreboard
+    const content = await fetchEspnScoreboard(sport, league);
+    if (!content)
+        return null;
+    return {
+        domain,
+        type: 'scoreboard',
+        structured: { sport, league, dataType: 'scoreboard' },
+        cleanContent: content,
+    };
+}
+// ---------------------------------------------------------------------------
+// 37. Sports betting sites — helpful redirect message
+// ---------------------------------------------------------------------------
+async function sportsBettingExtractor(_html, url) {
+    let brandName = 'Sports Betting Site';
+    let domain = 'sportsbook';
+    try {
+        const hostname = new URL(url).hostname.replace('www.', '').replace('sportsbook.', '');
+        domain = hostname;
+        if (hostname.includes('draftkings'))
+            brandName = 'DraftKings Sportsbook';
+        else if (hostname.includes('fanduel'))
+            brandName = 'FanDuel Sportsbook';
+        else if (hostname.includes('betmgm'))
+            brandName = 'BetMGM Sportsbook';
+    }
+    catch { /* ignore */ }
+    const cleanContent = `# ⚠️ ${brandName}
+
+${brandName} requires authentication and geo-verification. WebPeel cannot scrape live odds directly.
+
+**For live sports odds, use these alternatives:**
+- \`webpeel "https://espn.com/nba/scoreboard"\` — Live scores and schedules
+- \`webpeel "https://polymarket.com"\` — Prediction market prices
+- The Odds API (theOddsApi.com) — Aggregated odds from all sportsbooks (requires API key)
+
+**For team schedules and standings:**
+- \`webpeel "https://espn.com/nba/standings"\` — NBA standings
+- \`webpeel "https://espn.com/nfl/scoreboard"\` — NFL scores
+- \`webpeel "https://espn.com/mlb/scoreboard"\` — MLB scores`;
+    return {
+        domain,
+        type: 'blocked',
+        structured: { site: brandName, reason: 'authentication and geo-verification required' },
+        cleanContent,
+    };
+}
+// ---------------------------------------------------------------------------
+// Semantic Scholar extractor (Semantic Scholar API — free, no key needed)
+// ---------------------------------------------------------------------------
+async function semanticScholarExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'semanticscholar.org';
+    // --- Paper page: /paper/<title-slug>/<paperId> ---
+    const paperMatch = path.match(/^\/paper\/(?:[^/]+\/)?([a-f0-9]{40})/i);
+    if (paperMatch) {
+        const paperId = paperMatch[1];
+        try {
+            const fields = 'title,abstract,authors,year,citationCount,referenceCount,url,openAccessPdf,venue,publicationDate,tldr';
+            const apiUrl = `https://api.semanticscholar.org/graph/v1/paper/${paperId}?fields=${fields}`;
+            const data = await fetchJson(apiUrl);
+            if (!data)
+                return null;
+            // Rate limited — return null so pipeline falls back to browser rendering
+            if (data.code === '429' || (data.message && String(data.message).includes('Too Many Requests'))) {
+                return null;
+            }
+            if (!data.title)
+                return null;
+            const authors = data.authors || [];
+            const authorNames = authors.map((a) => a.name);
+            const authorLine = authorNames.length <= 5
+                ? authorNames.join(', ')
+                : `${authorNames.slice(0, 5).join(', ')} (+${authorNames.length - 5} more)`;
+            const pdfObj = data.openAccessPdf;
+            const pdfUrl = pdfObj?.url || null;
+            const tldrText = data.tldr?.text || null;
+            const citations = data.citationCount;
+            const citStr = citations != null ? citations.toLocaleString() : '?';
+            const structured = {
+                paperId,
+                title: data.title,
+                authors: authorNames,
+                year: data.year,
+                venue: data.venue,
+                citationCount: data.citationCount,
+                referenceCount: data.referenceCount,
+                abstract: data.abstract,
+                tldr: tldrText,
+                pdfUrl,
+                url: data.url,
+                publicationDate: data.publicationDate,
+            };
+            const lines = [
+                `# 📄 ${data.title}`,
+                '',
+                `**Authors:** ${authorLine}`,
+                `**Year:** ${data.year || '?'} | **Venue:** ${data.venue || 'N/A'} | **Citations:** ${citStr}`,
+            ];
+            if (data.referenceCount != null)
+                lines.push(`**References:** ${data.referenceCount.toLocaleString()}`);
+            if (tldrText) {
+                lines.push('', '## TL;DR', '', tldrText);
+            }
+            if (data.abstract) {
+                lines.push('', '## Abstract', '', data.abstract);
+            }
+            lines.push('');
+            if (pdfUrl)
+                lines.push(`**PDF:** [Open Access](${pdfUrl})`);
+            lines.push(`**Link:** [Semantic Scholar](${data.url || `https://www.semanticscholar.org/paper/${paperId}`})`);
+            return {
+                domain,
+                type: 'paper',
+                structured,
+                cleanContent: lines.join('\n'),
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'Semantic Scholar paper API failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    // --- Search page: /search?q=... ---
+    const query = urlObj.searchParams.get('q') || urlObj.searchParams.get('query');
+    if (path === '/search' || path.startsWith('/search/')) {
+        if (!query)
+            return null;
+        try {
+            const fields = 'title,authors,year,citationCount,url,openAccessPdf';
+            const apiUrl = `https://api.semanticscholar.org/graph/v1/paper/search?query=${encodeURIComponent(query)}&limit=10&fields=${fields}`;
+            const data = await fetchJson(apiUrl);
+            // Rate limited or no data — return null so pipeline falls back to browser rendering
+            if (!data)
+                return null;
+            if (data.code === '429' || (data.message && String(data.message).includes('Too Many Requests'))) {
+                return null;
+            }
+            if (!Array.isArray(data.data))
+                return null;
+            const papers = data.data;
+            const total = data.total || 0;
+            const rows = papers.map((p, i) => {
+                const authors = p.authors || [];
+                const authorLine = authors.length === 0 ? '—'
+                    : authors.length === 1 ? authors[0].name
+                        : `${authors[0].name} et al.`;
+                const paperUrl = p.url || `https://www.semanticscholar.org/paper/${p.paperId}`;
+                const cits = p.citationCount != null ? p.citationCount.toLocaleString() : '?';
+                return `| ${i + 1} | [${p.title}](${paperUrl}) | ${p.year || '?'} | ${cits} | ${authorLine} |`;
+            }).join('\n');
+            const cleanContent = [
+                `# 🔍 Semantic Scholar — "${query}"`,
+                '',
+                '| # | Paper | Year | Citations | Authors |',
+                '|---|-------|------|-----------|---------|',
+                rows,
+                '',
+                `*Source: Semantic Scholar API · Total results: ${total.toLocaleString()}*`,
+            ].join('\n');
+            return {
+                domain,
+                type: 'search',
+                structured: { query, total, papers },
+                cleanContent,
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'Semantic Scholar search API failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// PubMed extractor (NCBI E-utilities API — free, no key needed)
+// ---------------------------------------------------------------------------
+async function pubmedExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'pubmed.ncbi.nlm.nih.gov';
+    // --- Article page: /XXXXXX/ or /XXXXXX ---
+    const pmidMatch = path.match(/^\/(\d+)\/?$/);
+    if (pmidMatch) {
+        const pmid = pmidMatch[1];
+        try {
+            // Fetch summary
+            const summaryUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=${pmid}&retmode=json`;
+            const summaryData = await fetchJson(summaryUrl);
+            if (!summaryData?.result)
+                return null;
+            const result = summaryData.result;
+            const article = result[pmid];
+            if (!article)
+                return null;
+            // Fetch abstract via efetch
+            let abstract = '';
+            try {
+                const efetchUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pubmed&id=${pmid}&retmode=xml&rettype=abstract`;
+                const efetchResult = await simpleFetch(efetchUrl, 'WebPeel/0.21', 15000, { Accept: 'application/xml' });
+                if (efetchResult?.html) {
+                    const abstractMatch = efetchResult.html.match(/<AbstractText[^>]*>([\s\S]*?)<\/AbstractText>/g);
+                    if (abstractMatch) {
+                        abstract = abstractMatch.map((m) => {
+                            const labelMatch = m.match(/Label="([^"]+)"/);
+                            const textMatch = m.match(/<AbstractText[^>]*>([\s\S]*?)<\/AbstractText>/);
+                            const text = textMatch ? stripHtml(textMatch[1]).trim() : '';
+                            return labelMatch ? `**${labelMatch[1]}:** ${text}` : text;
+                        }).join('\n\n');
+                    }
+                }
+            }
+            catch { /* abstract is optional */ }
+            const authors = article.authors || [];
+            const authorNames = authors.filter(a => a.authtype !== 'CollectiveName').map(a => a.name);
+            const authorLine = authorNames.length <= 6
+                ? authorNames.join(', ')
+                : `${authorNames.slice(0, 6).join(', ')} et al.`;
+            const doi = article.elocationid?.replace(/^doi:\s*/i, '') || null;
+            const pubDate = article.pubdate || '?';
+            const journal = article.source || '?';
+            const volume = article.volume ? ` ${article.volume}` : '';
+            const issue = article.issue ? `(${article.issue})` : '';
+            const pages = article.pages ? `:${article.pages}` : '';
+            const structured = {
+                pmid,
+                title: article.title,
+                authors: authorNames,
+                journal,
+                pubDate,
+                volume: article.volume,
+                issue: article.issue,
+                pages: article.pages,
+                doi,
+                abstract: abstract || undefined,
+                url: `https://pubmed.ncbi.nlm.nih.gov/${pmid}/`,
+            };
+            const lines = [
+                `# 🧬 ${article.title}`,
+                '',
+                `**Authors:** ${authorLine}`,
+                `**Journal:** *${journal}*${volume}${issue}${pages} (${pubDate})`,
+                `**PMID:** ${pmid}`,
+            ];
+            if (doi)
+                lines.push(`**DOI:** [${doi}](https://doi.org/${doi})`);
+            if (abstract) {
+                lines.push('', '## Abstract', '', abstract);
+            }
+            lines.push('', `**Link:** [PubMed](https://pubmed.ncbi.nlm.nih.gov/${pmid}/)`);
+            return {
+                domain,
+                type: 'article',
+                structured,
+                cleanContent: lines.join('\n'),
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'PubMed article API failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    // --- Search page: /?term=... or /?query=... ---
+    const term = urlObj.searchParams.get('term') || urlObj.searchParams.get('query');
+    if (term) {
+        try {
+            // Step 1: search for IDs
+            const searchUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term=${encodeURIComponent(term)}&retmode=json&retmax=10`;
+            const searchData = await fetchJson(searchUrl);
+            if (!searchData?.esearchresult)
+                return null;
+            const esearch = searchData.esearchresult;
+            const ids = esearch.idlist || [];
+            const total = parseInt(esearch.count || '0', 10);
+            if (ids.length === 0) {
+                return {
+                    domain,
+                    type: 'search',
+                    structured: { query: term, total: 0, articles: [] },
+                    cleanContent: `# 🔍 PubMed — "${term}"\n\n*No results found.*`,
+                };
+            }
+            // Step 2: fetch summaries
+            const summaryUrl = `https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=pubmed&id=${ids.join(',')}&retmode=json`;
+            const summaryData = await fetchJson(summaryUrl);
+            if (!summaryData?.result)
+                return null;
+            const result = summaryData.result;
+            const articles = (result.uids || ids).map((id) => {
+                const a = result[id];
+                if (!a)
+                    return null;
+                const authors = a.authors || [];
+                return {
+                    pmid: id,
+                    title: a.title,
+                    journal: a.source,
+                    pubDate: a.pubdate,
+                    authors: authors.map(x => x.name),
+                    doi: a.elocationid?.replace(/^doi:\s*/i, '') || null,
+                };
+            }).filter(Boolean);
+            const rows = articles.map((a, i) => {
+                const authorLine = a.authors.length === 0 ? '—'
+                    : a.authors.length === 1 ? a.authors[0]
+                        : `${a.authors[0]} et al.`;
+                const link = `https://pubmed.ncbi.nlm.nih.gov/${a.pmid}/`;
+                return `| ${i + 1} | [${a.title}](${link}) | *${a.journal}* | ${a.pubDate} | ${authorLine} |`;
+            }).join('\n');
+            const cleanContent = [
+                `# 🔍 PubMed — "${term}"`,
+                '',
+                '| # | Article | Journal | Date | Authors |',
+                '|---|---------|---------|------|---------|',
+                rows,
+                '',
+                `*Source: NCBI PubMed E-utilities · Total results: ${total.toLocaleString()}*`,
+            ].join('\n');
+            return {
+                domain,
+                type: 'search',
+                structured: { query: term, total, articles },
+                cleanContent,
+            };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'PubMed search API failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// 38. CoinGecko extractor — crypto prices via free CoinGecko API
+// ---------------------------------------------------------------------------
+async function coinGeckoExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    const domain = 'coingecko.com';
+    const cgHeaders = {
+        'Accept': 'application/json',
+        'User-Agent': 'webpeel/0.21 (https://webpeel.dev)',
+    };
+    // Helper: compact number formatting
+    const fmtMoney = (v) => {
+        if (v == null || isNaN(v))
+            return '?';
+        if (v >= 1_000_000_000_000)
+            return `$${(v / 1_000_000_000_000).toFixed(2)}T`;
+        if (v >= 1_000_000_000)
+            return `$${(v / 1_000_000_000).toFixed(2)}B`;
+        if (v >= 1_000_000)
+            return `$${(v / 1_000_000).toFixed(2)}M`;
+        return `$${v.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+    };
+    const fmtPrice = (v) => {
+        if (v == null || isNaN(v))
+            return '?';
+        if (v >= 1000)
+            return `$${v.toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+        if (v >= 1)
+            return `$${v.toFixed(4)}`;
+        return `$${v.toFixed(8)}`;
+    };
+    const fmtChange = (c) => {
+        if (c == null || isNaN(c))
+            return '?';
+        const sign = c >= 0 ? '+' : '';
+        return `${sign}${c.toFixed(1)}%`;
+    };
+    // Coin detail page: /en/coins/<coin-id>
+    const coinMatch = path.match(/^\/en\/coins\/([^/?#]+)\/?/);
+    if (coinMatch) {
+        const coinId = coinMatch[1].toLowerCase();
+        try {
+            const apiUrl = `https://api.coingecko.com/api/v3/coins/${encodeURIComponent(coinId)}?localization=false&tickers=false&community_data=false&developer_data=false`;
+            const data = await fetchJson(apiUrl, cgHeaders);
+            if (!data || data.error)
+                return null;
+            const md = data.market_data || {};
+            const price = md.current_price?.usd;
+            const change24h = md.price_change_percentage_24h;
+            const change7d = md.price_change_percentage_7d;
+            const marketCap = md.market_cap?.usd;
+            const volume = md.total_volume?.usd;
+            const ath = md.ath?.usd;
+            const circulatingSupply = md.circulating_supply;
+            const maxSupply = md.max_supply;
+            const name = data.name || coinId;
+            const symbol = (data.symbol || '').toUpperCase();
+            const description = data.description?.en?.replace(/<[^>]+>/g, '').split('\r\n')[0]?.slice(0, 500) || '';
+            const updatedAt = data.last_updated || new Date().toISOString();
+            const structuredData = {
+                id: coinId,
+                name,
+                symbol,
+                price_usd: price,
+                change_24h: change24h,
+                change_7d: change7d,
+                market_cap_usd: marketCap,
+                volume_24h_usd: volume,
+                ath_usd: ath,
+                circulating_supply: circulatingSupply,
+                max_supply: maxSupply,
+                last_updated: updatedAt,
+            };
+            let cleanContent = `# 🪙 ${name} (${symbol})\n\n`;
+            cleanContent += `## Quote\n`;
+            cleanContent += `- **Price:** ${fmtPrice(price)}\n`;
+            cleanContent += `- **24h Change:** ${fmtChange(change24h)}\n`;
+            if (change7d != null)
+                cleanContent += `- **7d Change:** ${fmtChange(change7d)}\n`;
+            cleanContent += `- **Market Cap:** ${fmtMoney(marketCap)}\n`;
+            cleanContent += `- **24h Volume:** ${fmtMoney(volume)}\n`;
+            if (ath != null)
+                cleanContent += `- **All-Time High:** ${fmtPrice(ath)}\n`;
+            if (circulatingSupply) {
+                const supply = circulatingSupply >= 1_000_000_000
+                    ? `${(circulatingSupply / 1_000_000_000).toFixed(2)}B`
+                    : circulatingSupply >= 1_000_000
+                        ? `${(circulatingSupply / 1_000_000).toFixed(2)}M`
+                        : circulatingSupply.toLocaleString();
+                cleanContent += `- **Circulating Supply:** ${supply} ${symbol}\n`;
+            }
+            if (description) {
+                cleanContent += `\n## Description\n${description}\n`;
+            }
+            cleanContent += `\n---\n*Source: CoinGecko API · Updated: ${updatedAt}*`;
+            return { domain, type: 'coin', structured: structuredData, cleanContent };
+        }
+        catch (e) {
+            if (process.env.DEBUG)
+                console.debug('[webpeel]', 'CoinGecko coin API failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    // Main page / markets overview: coingecko.com or coingecko.com/en
+    try {
+        const apiUrl = `https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=15&page=1`;
+        const coins = await fetchJson(apiUrl, cgHeaders);
+        if (!Array.isArray(coins) || coins.length === 0)
+            return null;
+        const rows = coins.slice(0, 15).map((c, i) => {
+            const change = c.price_change_percentage_24h;
+            const changeStr = change != null ? `${change >= 0 ? '+' : ''}${change.toFixed(1)}%` : '?';
+            return `| ${i + 1} | ${c.name} (${(c.symbol || '').toUpperCase()}) | ${fmtPrice(c.current_price)} | ${changeStr} | ${fmtMoney(c.market_cap)} |`;
+        });
+        const cleanContent = `# 🪙 CoinGecko — Top Cryptocurrencies\n\n` +
+            `| # | Coin | Price | 24h | Market Cap |\n` +
+            `|---|------|-------|-----|------------|\n` +
+            rows.join('\n') +
+            `\n\n---\n*Source: CoinGecko API · Updated: ${new Date().toISOString()}*`;
+        return {
+            domain,
+            type: 'markets',
+            structured: { coins: coins.slice(0, 15) },
+            cleanContent,
+        };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'CoinGecko markets API failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// 39. Weather extractor — Open-Meteo free API (no key required)
+// ---------------------------------------------------------------------------
+// Weather code descriptions (WMO)
+const WMO_CODES = {
+    0: 'Clear sky', 1: 'Mainly clear', 2: 'Partly cloudy', 3: 'Overcast',
+    45: 'Foggy', 48: 'Icy fog',
+    51: 'Light drizzle', 53: 'Moderate drizzle', 55: 'Dense drizzle',
+    61: 'Slight rain', 63: 'Moderate rain', 65: 'Heavy rain',
+    71: 'Slight snow', 73: 'Moderate snow', 75: 'Heavy snow',
+    80: 'Slight showers', 81: 'Moderate showers', 82: 'Violent showers',
+    85: 'Slight snow showers', 86: 'Heavy snow showers',
+    95: 'Thunderstorm', 96: 'Thunderstorm w/ hail', 99: 'Thunderstorm w/ heavy hail',
+};
+const WEATHER_ICONS = {
+    0: '☀️', 1: '🌤️', 2: '⛅', 3: '☁️',
+    45: '🌫️', 48: '🌫️',
+    51: '🌦️', 53: '🌦️', 55: '🌧️',
+    61: '🌦️', 63: '🌧️', 65: '🌧️',
+    71: '🌨️', 73: '❄️', 75: '❄️',
+    80: '🌦️', 81: '🌧️', 82: '⛈️',
+    85: '🌨️', 86: '❄️',
+    95: '⛈️', 96: '⛈️', 99: '⛈️',
+};
+// Default city coordinates for common weather sites
+const DEFAULT_CITY = { name: 'New York City', lat: 40.7128, lon: -74.0060, tz: 'America/New_York' };
+async function weatherExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const hostname = urlObj.hostname;
+    // Determine lat/lon from URL params (for open-meteo.com direct API links)
+    let lat = null;
+    let lon = null;
+    let cityName = DEFAULT_CITY.name;
+    let timezone = DEFAULT_CITY.tz;
+    if (hostname.includes('open-meteo.com')) {
+        const latParam = urlObj.searchParams.get('latitude');
+        const lonParam = urlObj.searchParams.get('longitude');
+        const tzParam = urlObj.searchParams.get('timezone');
+        if (latParam && lonParam) {
+            lat = parseFloat(latParam);
+            lon = parseFloat(lonParam);
+            cityName = `${lat.toFixed(2)}°N, ${lon.toFixed(2)}°E`;
+            if (tzParam)
+                timezone = tzParam;
+        }
+    }
+    // For weather.com / accuweather: try to extract city from URL path
+    if (hostname.includes('weather.com') || hostname.includes('accuweather.com')) {
+        const path = urlObj.pathname;
+        // weather.com: /weather/today/l/40.71,-74.01:4:US or similar
+        const coordMatch = path.match(/\/l\/(-?\d+\.?\d*),(-?\d+\.?\d*)/);
+        if (coordMatch) {
+            lat = parseFloat(coordMatch[1]);
+            lon = parseFloat(coordMatch[2]);
+            cityName = `${lat.toFixed(2)}, ${lon.toFixed(2)}`;
+        }
+    }
+    // Default to NYC if no coords found
+    if (lat == null || lon == null) {
+        lat = DEFAULT_CITY.lat;
+        lon = DEFAULT_CITY.lon;
+        cityName = DEFAULT_CITY.name;
+        timezone = DEFAULT_CITY.tz;
+    }
+    try {
+        const apiUrl = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&current=temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,weather_code&timezone=${encodeURIComponent(timezone)}&forecast_days=7`;
+        const data = await fetchJson(apiUrl);
+        if (!data || data.error)
+            return null;
+        const current = data.current || {};
+        const daily = data.daily || {};
+        const tempC = current.temperature_2m;
+        const tempF = tempC != null ? Math.round(tempC * 9 / 5 + 32) : null;
+        const humidity = current.relative_humidity_2m;
+        const wind = current.wind_speed_10m;
+        const wCode = current.weather_code;
+        const condition = WMO_CODES[wCode] || 'Unknown';
+        const icon = WEATHER_ICONS[wCode] || '🌡️';
+        let cleanContent = `# ${icon} Weather Forecast — ${cityName}\n\n`;
+        if (tempC != null) {
+            cleanContent += `**Current:** ${tempC}°C (${tempF}°F)`;
+            if (wind != null)
+                cleanContent += `, Wind: ${wind} km/h`;
+            if (humidity != null)
+                cleanContent += `, Humidity: ${humidity}%`;
+            cleanContent += `, ${condition}\n\n`;
+        }
+        if (daily.time?.length) {
+            cleanContent += `| Date | Low | High | Precip | Condition |\n`;
+            cleanContent += `|------|-----|------|--------|----------|\n`;
+            for (let i = 0; i < Math.min(daily.time.length, 7); i++) {
+                const date = daily.time[i];
+                const low = daily.temperature_2m_min?.[i];
+                const high = daily.temperature_2m_max?.[i];
+                const precip = daily.precipitation_sum?.[i];
+                const dayCode = daily.weather_code?.[i];
+                const dayIcon = WEATHER_ICONS[dayCode] || '';
+                const dayCondition = WMO_CODES[dayCode] || '';
+                const lowStr = low != null ? `${low}°C` : '?';
+                const highStr = high != null ? `${high}°C` : '?';
+                const precipStr = precip != null ? `${precip}mm` : '0mm';
+                cleanContent += `| ${date} | ${lowStr} | ${highStr} | ${precipStr} | ${dayIcon} ${dayCondition} |\n`;
+            }
+        }
+        cleanContent += `\n---\n*Source: Open-Meteo API · Coordinates: ${lat}, ${lon} · Updated: ${data.current?.time || new Date().toISOString()}*`;
+        return {
+            domain: 'open-meteo.com',
+            type: 'forecast',
+            structured: {
+                city: cityName,
+                lat,
+                lon,
+                timezone,
+                current: {
+                    temperature_c: tempC,
+                    temperature_f: tempF,
+                    humidity,
+                    wind_speed_kmh: wind,
+                    condition,
+                    weather_code: wCode,
+                },
+                daily: daily,
+            },
+            cleanContent,
+        };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Weather API failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}