@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/ee/extractors/redfin.js

@@ -0,0 +1,156 @@
+import { simpleFetch } from '../../core/fetcher.js';
+import { fetchRedfinListings, formatRedfinListings } from './zillow.js';
+// ---------------------------------------------------------------------------
+// Redfin extractor — live listings via Redfin's internal stingray API
+// ---------------------------------------------------------------------------
+export async function redfinExtractor(_html, url) {
+    try {
+        const u = new URL(url);
+        const path = u.pathname;
+        // ── Pattern 1: /city/{id}/{state}/{city-name} ───────────────────────────
+        // e.g. redfin.com/city/30749/NY/New-York
+        const cityMatch = path.match(/^\/city\/(\d+)\/([A-Z]{2})\/([^/]+)/);
+        if (cityMatch) {
+            const regionId = cityMatch[1];
+            const stateCode = cityMatch[2];
+            const citySlug = cityMatch[3];
+            const cityName = citySlug.replace(/-/g, ' ');
+            const locationLabel = `${cityName}, ${stateCode}`;
+            const payload = await fetchRedfinListings(regionId, 6 /* city */);
+            if (payload?.homes && payload.homes.length > 0) {
+                return formatRedfinListings(payload.homes, locationLabel, url, payload.searchMedian);
+            }
+        }
+        // ── Pattern 2: /{state}/{city} or /{state}/{city}/filter/... ───────────
+        // e.g. redfin.com/NY/New-York or redfin.com/NY/Brooklyn
+        const stateCity = path.match(/^\/([A-Z]{2})\/([^/]+)(?:\/|$)/);
+        if (stateCity) {
+            const stateCode = stateCity[1];
+            const citySlug = stateCity[2];
+            const cityName = citySlug.replace(/-/g, ' ');
+            const locationLabel = `${cityName}, ${stateCode}`;
+            // No region ID in URL — use known Redfin city region IDs (region_type=6)
+            const cityRegionMap = {
+                'NY-New-York': 30749, 'NY-Brooklyn': 30749, 'NY-Queens': 30749, 'NY-Bronx': 30749,
+                'NY-Staten-Island': 30749, 'NY-Manhattan': 30749,
+                'CA-Los-Angeles': 11203, 'CA-San-Francisco': 17151, 'CA-San-Diego': 18142,
+                'CA-San-Jose': 17420,
+                'TX-Houston': 30772, 'TX-Dallas': 35799, 'TX-Austin': 30818,
+                'FL-Miami': 10201, 'FL-Orlando': 13140, 'FL-Tampa': 18280,
+                'IL-Chicago': 29470, 'WA-Seattle': 16163, 'MA-Boston': 1826,
+                'AZ-Phoenix': 14240, 'PA-Philadelphia': 13364, 'GA-Atlanta': 30756,
+                'CO-Denver': 11093, 'MN-Minneapolis': 18959, 'OR-Portland': 14941,
+                'NV-Las-Vegas': 32820, 'NC-Charlotte': 3105, 'OH-Columbus': 8528,
+            };
+            const marketKey = `${stateCode}-${citySlug}`;
+            const marketId = cityRegionMap[marketKey];
+            if (marketId) {
+                const payload = await fetchRedfinListings(marketId, 6 /* city */);
+                if (payload?.homes && payload.homes.length > 0) {
+                    return formatRedfinListings(payload.homes, locationLabel, url, payload.searchMedian);
+                }
+            }
+            // Fallback: return helpful info about what Redfin offers
+            const cleanContent = [
+                `# 🏠 Redfin — ${locationLabel}`,
+                '',
+                `*Redfin listing search for ${locationLabel}*`,
+                '',
+                '> 💡 For the best results, use a city URL with a region ID:',
+                `> \`webpeel "https://www.redfin.com/city/{id}/${stateCode}/${citySlug}"\``,
+                '',
+                `**[Browse ${cityName} on Redfin](${url})**`,
+            ].join('\n');
+            return {
+                domain: 'redfin.com',
+                type: 'real-estate-search',
+                structured: { city: cityName, state: stateCode },
+                cleanContent,
+            };
+        }
+        // ── Pattern 3: Individual property page ─────────────────────────────────
+        // e.g. /NY/New-York/123-Main-St-10001/home/12345678
+        const propMatch = path.match(/^\/([A-Z]{2})\/([^/]+)\/(.+?)\/home\/(\d+)/);
+        if (propMatch) {
+            const stateCode = propMatch[1];
+            const citySlug = propMatch[2];
+            const addressSlug = propMatch[3];
+            const propertyId = propMatch[4];
+            const address = addressSlug.replace(/-/g, ' ');
+            const city = citySlug.replace(/-/g, ' ');
+            // Use the Redfin GIS API for a single property by ID
+            const apiUrl = `https://www.redfin.com/stingray/api/home/details/aboveTheFold?propertyId=${propertyId}&accessLevel=1`;
+            try {
+                const resp = await simpleFetch(apiUrl, 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36', 30000, { 'Accept': 'application/json', 'Referer': 'https://www.redfin.com/' });
+                if (resp && (!resp.statusCode || resp.statusCode < 400)) {
+                    const raw = resp.html.replace(/^\{\}&&/, '');
+                    const data = JSON.parse(raw);
+                    if (data.resultCode === 0 && data.payload) {
+                        const p = data.payload;
+                        const price = p.basicInfo?.price?.amount;
+                        const beds = p.basicInfo?.beds;
+                        const baths = p.basicInfo?.baths;
+                        const sqft = p.basicInfo?.sqFt;
+                        const status = p.basicInfo?.status;
+                        const desc = p.basicInfo?.description;
+                        const cleanContent = [
+                            `# 🏠 ${address}, ${city}, ${stateCode}`,
+                            '',
+                            price ? `**Price:** $${Number(price).toLocaleString()}` : '',
+                            [beds && `${beds} beds`, baths && `${baths} baths`, sqft && `${Number(sqft).toLocaleString()} sqft`].filter(Boolean).join(' · '),
+                            status ? `**Status:** ${status}` : '',
+                            '',
+                            desc ? `## Description\n\n${desc.slice(0, 800)}${desc.length > 800 ? '…' : ''}` : '',
+                            '',
+                            `[View on Redfin](${url})`,
+                        ].filter(Boolean).join('\n');
+                        return {
+                            domain: 'redfin.com',
+                            type: 'property',
+                            structured: { address, city, state: stateCode, propertyId, price, beds, baths, sqFt: sqft, status },
+                            cleanContent,
+                        };
+                    }
+                }
+            }
+            catch (e) {
+                if (process.env.DEBUG)
+                    console.debug('[webpeel]', 'Redfin property detail error:', e instanceof Error ? e.message : e);
+            }
+            // Fallback for property pages
+            return {
+                domain: 'redfin.com',
+                type: 'property',
+                structured: { address, city, state: stateCode, propertyId },
+                cleanContent: `# 🏠 ${address}, ${city}, ${stateCode}\n\n[View on Redfin](${url})`,
+            };
+        }
+        // ── Pattern 4: Homepage or general search ───────────────────────────────
+        // Return info about how to use Redfin extractor
+        return {
+            domain: 'redfin.com',
+            type: 'homepage',
+            structured: {},
+            cleanContent: [
+                '# 🏠 Redfin — Real Estate Listings',
+                '',
+                'For live MLS listings, use a city or neighborhood URL:',
+                '',
+                '**City search:**',
+                '- `webpeel "https://www.redfin.com/city/30749/NY/New-York"` — NYC listings',
+                '- `webpeel "https://www.redfin.com/city/17184/CA/Los-Angeles"` — LA listings',
+                '',
+                '**State/city search:**',
+                '- `webpeel "https://www.redfin.com/NY/New-York"` — NYC',
+                '- `webpeel "https://www.redfin.com/CA/San-Francisco"` — SF',
+                '',
+                '*Redfin uses live MLS data — no bot detection blocks WebPeel.*',
+            ].join('\n'),
+        };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Redfin extractor error:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

package/dist/ee/extractors/semanticscholar.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function semanticScholarExtractor(_html: string, url: string): Promise<DomainExtractResult | null>;

package/dist/ee/extractors/semanticscholar.js

@@ -0,0 +1,131 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// Semantic Scholar extractor (Semantic Scholar API — free, no key needed)
+// ---------------------------------------------------------------------------
+export 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;
+}

package/dist/ee/extractors/shared.d.ts

@@ -0,0 +1,12 @@
+import { simpleFetch } from '../../core/fetcher.js';
+export { simpleFetch };
+export declare function tryParseJson(text: string): any;
+/** Strip HTML tags from a string. */
+export declare function stripHtml(str: string): string;
+/** Format a Unix timestamp (seconds) as ISO 8601. */
+export declare function unixToIso(sec: number): string;
+/** Fetch JSON from a URL using simpleFetch (reuses WebPeel's HTTP stack). */
+export declare function fetchJson(url: string, customHeaders?: Record<string, string>): Promise<any>;
+/** Fetch JSON with exponential backoff retry on 429 / rate-limit errors. */
+export declare function fetchJsonWithRetry(url: string, headers?: Record<string, string>, retries?: number, baseDelayMs?: number): Promise<any>;
+/** Recursively search an object for a value matching predicate (BFS). */

package/dist/ee/extractors/shared.js

@@ -0,0 +1,76 @@
+import { simpleFetch } from '../../core/fetcher.js';
+export { simpleFetch };
+export function tryParseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/** Strip HTML tags from a string. */
+export function stripHtml(str) {
+    return str.replace(/<[^>]+>/g, '').replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, ' ').trim();
+}
+/** Format a Unix timestamp (seconds) as ISO 8601. */
+export function unixToIso(sec) {
+    return new Date(sec * 1000).toISOString();
+}
+/** Fetch JSON from a URL using simpleFetch (reuses WebPeel's HTTP stack). */
+export async function fetchJson(url, customHeaders) {
+    // Use plain fetch (not simpleFetch) for JSON API calls.
+    // simpleFetch adds stealth browser headers (Sec-CH-UA, Sec-Fetch-*, etc.)
+    // which confuse API endpoints like api.github.com into returning HTML.
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 15000);
+    try {
+        const resp = await fetch(url, {
+            headers: {
+                'User-Agent': 'webpeel/0.21 (https://webpeel.dev)',
+                'Accept': 'application/json',
+                ...customHeaders,
+            },
+            signal: controller.signal,
+            redirect: 'follow',
+        });
+        clearTimeout(timer);
+        // Surface 429 as a thrown error so callers can detect rate-limiting
+        // and the cache wrapper can serve stale results instead of garbage.
+        if (resp.status === 429) {
+            const err = new Error(`429 Too Many Requests: ${url}`);
+            err.statusCode = 429;
+            throw err;
+        }
+        const text = await resp.text();
+        const parsed = tryParseJson(text);
+        if (parsed === null && text.length > 0) {
+            console.warn(`[webpeel:fetchJson] Non-JSON response from ${url} (${text.length} bytes, status: ${resp.status}): ${text.slice(0, 120)}`);
+        }
+        return parsed;
+    }
+    catch (e) {
+        clearTimeout(timer);
+        throw e;
+    }
+}
+/** Fetch JSON with exponential backoff retry on 429 / rate-limit errors. */
+export async function fetchJsonWithRetry(url, headers, retries = 2, baseDelayMs = 1000) {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            const result = await fetchJson(url, headers);
+            return result;
+        }
+        catch (e) {
+            // Retry on rate-limit or transient errors
+            if (attempt < retries && (e.message?.includes('429') || e.message?.includes('rate') || e.message?.includes('Too Many'))) {
+                await new Promise(resolve => setTimeout(resolve, baseDelayMs * Math.pow(2, attempt)));
+                continue;
+            }
+            throw e;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// 1. Twitter / X extractor
+// ---------------------------------------------------------------------------
+/** Recursively search an object for a value matching predicate (BFS). */

package/dist/ee/extractors/soundcloud.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function soundcloudExtractor(_html: string, url: string): Promise<DomainExtractResult | null>;

package/dist/ee/extractors/soundcloud.js

@@ -0,0 +1,34 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 28. SoundCloud extractor (oEmbed)
+// ---------------------------------------------------------------------------
+export async function soundcloudExtractor(_html, url) {
+    try {
+        const oembedUrl = `https://soundcloud.com/oembed?url=${encodeURIComponent(url)}&format=json`;
+        const data = await fetchJson(oembedUrl);
+        if (!data || !data.title)
+            return null;
+        const urlObj = new URL(url);
+        const pathParts = urlObj.pathname.split('/').filter(Boolean);
+        const isPlaylist = pathParts.includes('sets');
+        const contentType = isPlaylist ? 'playlist' : pathParts.length >= 2 ? 'track' : 'profile';
+        const structured = {
+            title: data.title,
+            author: data.author_name || '',
+            authorUrl: data.author_url || '',
+            thumbnailUrl: data.thumbnail_url || '',
+            description: data.description || '',
+            contentType,
+            provider: 'SoundCloud',
+        };
+        const typeEmoji = contentType === 'track' ? '🎵' : contentType === 'playlist' ? '📋' : '🎤';
+        const descLine = structured.description ? `\n\n${structured.description.substring(0, 500)}` : '';
+        const cleanContent = `## ${typeEmoji} SoundCloud ${contentType}: ${structured.title}${descLine}\n\n**Artist:** [${structured.author}](${structured.authorUrl})\n**URL:** ${url}`;
+        return { domain: 'soundcloud.com', type: contentType, structured, cleanContent };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'SoundCloud oEmbed failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

package/dist/ee/extractors/sportsbetting.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function sportsBettingExtractor(_html: string, url: string): Promise<DomainExtractResult | null>;

package/dist/ee/extractors/sportsbetting.js

@@ -0,0 +1,37 @@
+// ---------------------------------------------------------------------------
+// 37. Sports betting sites — helpful redirect message
+// ---------------------------------------------------------------------------
+export 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,
+    };
+}

package/dist/ee/extractors/spotify.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function spotifyExtractor(_html: string, url: string): Promise<DomainExtractResult | null>;

package/dist/ee/extractors/spotify.js

@@ -0,0 +1,34 @@
+import { fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 21. Spotify extractor (oEmbed)
+// ---------------------------------------------------------------------------
+export async function spotifyExtractor(_html, url) {
+    try {
+        const oembedUrl = `https://open.spotify.com/oembed?url=${encodeURIComponent(url)}`;
+        const data = await fetchJson(oembedUrl);
+        if (!data || !data.title)
+            return null;
+        // Detect type from URL path: track, album, playlist, episode, show, artist
+        const pathMatch = url.match(/open\.spotify\.com\/(track|album|playlist|episode|show|artist)\/([A-Za-z0-9]+)/);
+        const contentType = pathMatch?.[1] || 'track';
+        const spotifyId = pathMatch?.[2] || '';
+        const structured = {
+            title: data.title,
+            type: contentType,
+            spotifyId,
+            provider: 'Spotify',
+            thumbnailUrl: data.thumbnail_url || '',
+            thumbnailWidth: data.thumbnail_width || 0,
+            thumbnailHeight: data.thumbnail_height || 0,
+            embedHtml: data.html || '',
+        };
+        const typeEmoji = contentType === 'track' ? '🎵' : contentType === 'album' ? '💿' : contentType === 'playlist' ? '📋' : contentType === 'episode' ? '🎙️' : contentType === 'artist' ? '🎤' : '🎵';
+        const cleanContent = `## ${typeEmoji} Spotify ${contentType.charAt(0).toUpperCase() + contentType.slice(1)}: ${data.title}\n\n**Platform:** Spotify\n**Type:** ${contentType}\n**URL:** ${url}`;
+        return { domain: 'open.spotify.com', type: contentType, structured, cleanContent };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'Spotify oEmbed failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

package/dist/ee/extractors/stackoverflow.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function stackOverflowExtractor(_html: string, url: string): Promise<DomainExtractResult | null>;

package/dist/ee/extractors/stackoverflow.js

@@ -0,0 +1,61 @@
+import { stripHtml, fetchJson } from './shared.js';
+// ---------------------------------------------------------------------------
+// 8. Stack Overflow extractor (StackExchange API)
+// ---------------------------------------------------------------------------
+export async function stackOverflowExtractor(_html, url) {
+    const urlObj = new URL(url);
+    const path = urlObj.pathname;
+    // Match /questions/12345/optional-slug
+    const questionMatch = path.match(/\/questions\/(\d+)/);
+    if (!questionMatch)
+        return null;
+    const questionId = questionMatch[1];
+    try {
+        const apiUrl = `https://api.stackexchange.com/2.3/questions/${questionId}?order=desc&sort=votes&site=stackoverflow&filter=withbody`;
+        const data = await fetchJson(apiUrl);
+        if (!data?.items?.[0])
+            return null;
+        const q = data.items[0];
+        // Also fetch answers
+        let answers = [];
+        try {
+            const answersUrl = `https://api.stackexchange.com/2.3/questions/${questionId}/answers?order=desc&sort=votes&site=stackoverflow&filter=withbody&pagesize=5`;
+            const answersData = await fetchJson(answersUrl);
+            answers = answersData?.items || [];
+        }
+        catch { /* answers optional */ }
+        const structured = {
+            title: stripHtml(q.title || ''),
+            questionId: q.question_id,
+            score: q.score || 0,
+            views: q.view_count || 0,
+            answerCount: q.answer_count || 0,
+            isAnswered: q.is_answered || false,
+            tags: q.tags || [],
+            askedBy: q.owner?.display_name || 'anonymous',
+            askedDate: q.creation_date ? new Date(q.creation_date * 1000).toISOString() : undefined,
+            acceptedAnswerId: q.accepted_answer_id || null,
+            answers: answers.map(a => ({
+                id: a.answer_id,
+                score: a.score,
+                isAccepted: a.is_accepted || false,
+                body: stripHtml(a.body || '').substring(0, 2000),
+                author: a.owner?.display_name || 'anonymous',
+            })),
+        };
+        const questionBody = stripHtml(q.body || '').substring(0, 3000);
+        const tagLine = structured.tags.length ? `**Tags:** ${structured.tags.join(', ')}` : '';
+        let answersContent = '';
+        for (const a of structured.answers.slice(0, 3)) {
+            const acceptedMark = a.isAccepted ? ' ✅ Accepted' : '';
+            answersContent += `\n\n---\n\n### Answer by ${a.author} (Score: ${a.score}${acceptedMark})\n\n${a.body}`;
+        }
+        const cleanContent = `# ${structured.title}\n\n**Score:** ${structured.score} | **Views:** ${structured.views?.toLocaleString()} | **Answers:** ${structured.answerCount}\n${tagLine}\n**Asked by:** ${structured.askedBy}\n\n## Question\n\n${questionBody}${answersContent}`;
+        return { domain: 'stackoverflow.com', type: 'question', structured, cleanContent };
+    }
+    catch (e) {
+        if (process.env.DEBUG)
+            console.debug('[webpeel]', 'StackOverflow API failed:', e instanceof Error ? e.message : e);
+        return null;
+    }
+}

package/dist/ee/extractors/substack.d.ts

@@ -0,0 +1,2 @@
+import type { DomainExtractResult } from './types.js';
+export declare function substackExtractor(html: string, url: string): Promise<DomainExtractResult | null>;