@detiq/crawler 1.1.7 → 1.1.9

package/dist/js-coverage.js

@@ -1,56 +1,60 @@
-async function startCoverage(page) {
-  try {
-    await Promise.all([
-      page.coverage.startJSCoverage({ resetOnNavigation: false }),
-      page.coverage.startCSSCoverage({ resetOnNavigation: false })
-    ]);
-  } catch {
-  }
+/**
+ * JS/CSS coverage collector via Playwright's built-in coverage API.
+ *
+ * For each crawled page, records what percentage of loaded JS/CSS was actually
+ * executed/applied. High unused code % → performance opportunity (code splitting, lazy loading).
+ *
+ * Uses Playwright's page.coverage API (wraps CDP Coverage domain).
+ */
+export async function startCoverage(page) {
+    try {
+        await Promise.all([
+            page.coverage.startJSCoverage({ resetOnNavigation: false }),
+            page.coverage.startCSSCoverage({ resetOnNavigation: false }),
+        ]);
+    }
+    catch { /* coverage not available in all environments */ }
 }
-async function stopAndCollectCoverage(page, pageUrl) {
-  try {
-    const [jsCoverage, cssCoverage] = await Promise.all([
-      page.coverage.stopJSCoverage().catch(() => []),
-      page.coverage.stopCSSCoverage().catch(() => [])
-    ]);
-    const entries = [];
-    for (const entry of jsCoverage) {
-      const totalBytes = entry.text?.length ?? 0;
-      const usedBytes = (entry.ranges ?? []).reduce((sum, r) => sum + (r.end - r.start), 0);
-      if (totalBytes > 0) {
-        entries.push({ url: entry.url, type: "js", totalBytes, usedBytes, unusedPercent: Math.round((1 - usedBytes / totalBytes) * 100) });
-      }
+export async function stopAndCollectCoverage(page, pageUrl) {
+    try {
+        const [jsCoverage, cssCoverage] = await Promise.all([
+            page.coverage.stopJSCoverage().catch(() => []),
+            page.coverage.stopCSSCoverage().catch(() => []),
+        ]);
+        const entries = [];
+        for (const entry of jsCoverage) {
+            const totalBytes = entry.text?.length ?? 0;
+            const usedBytes = (entry.ranges ?? []).reduce((sum, r) => sum + (r.end - r.start), 0);
+            if (totalBytes > 0) {
+                entries.push({ url: entry.url, type: 'js', totalBytes, usedBytes, unusedPercent: Math.round((1 - usedBytes / totalBytes) * 100) });
+            }
+        }
+        for (const entry of cssCoverage) {
+            const totalBytes = entry.text?.length ?? 0;
+            const usedBytes = (entry.ranges ?? []).reduce((sum, r) => sum + (r.end - r.start), 0);
+            if (totalBytes > 0) {
+                entries.push({ url: entry.url, type: 'css', totalBytes, usedBytes, unusedPercent: Math.round((1 - usedBytes / totalBytes) * 100) });
+            }
+        }
+        const jsEntries = entries.filter(e => e.type === 'js');
+        const cssEntries = entries.filter(e => e.type === 'css');
+        const totalJsBytes = jsEntries.reduce((s, e) => s + e.totalBytes, 0);
+        const usedJsBytes = jsEntries.reduce((s, e) => s + e.usedBytes, 0);
+        const totalCssBytes = cssEntries.reduce((s, e) => s + e.totalBytes, 0);
+        const usedCssBytes = cssEntries.reduce((s, e) => s + e.usedBytes, 0);
+        return {
+            pageUrl,
+            entries,
+            totalJsBytes,
+            usedJsBytes,
+            totalCssBytes,
+            usedCssBytes,
+            jsUnusedPercent: totalJsBytes > 0 ? Math.round((1 - usedJsBytes / totalJsBytes) * 100) : 0,
+            cssUnusedPercent: totalCssBytes > 0 ? Math.round((1 - usedCssBytes / totalCssBytes) * 100) : 0,
+            collectedAt: new Date().toISOString(),
+        };
     }
-    for (const entry of cssCoverage) {
-      const totalBytes = entry.text?.length ?? 0;
-      const usedBytes = (entry.ranges ?? []).reduce((sum, r) => sum + (r.end - r.start), 0);
-      if (totalBytes > 0) {
-        entries.push({ url: entry.url, type: "css", totalBytes, usedBytes, unusedPercent: Math.round((1 - usedBytes / totalBytes) * 100) });
-      }
+    catch {
+        return null;
     }
-    const jsEntries = entries.filter((e) => e.type === "js");
-    const cssEntries = entries.filter((e) => e.type === "css");
-    const totalJsBytes = jsEntries.reduce((s, e) => s + e.totalBytes, 0);
-    const usedJsBytes = jsEntries.reduce((s, e) => s + e.usedBytes, 0);
-    const totalCssBytes = cssEntries.reduce((s, e) => s + e.totalBytes, 0);
-    const usedCssBytes = cssEntries.reduce((s, e) => s + e.usedBytes, 0);
-    return {
-      pageUrl,
-      entries,
-      totalJsBytes,
-      usedJsBytes,
-      totalCssBytes,
-      usedCssBytes,
-      jsUnusedPercent: totalJsBytes > 0 ? Math.round((1 - usedJsBytes / totalJsBytes) * 100) : 0,
-      cssUnusedPercent: totalCssBytes > 0 ? Math.round((1 - usedCssBytes / totalCssBytes) * 100) : 0,
-      collectedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  } catch {
-    return null;
-  }
 }
-export {
-  startCoverage,
-  stopAndCollectCoverage
-};
-//# sourceMappingURL=js-coverage.js.map

package/dist/js-router-detector.js

@@ -1,90 +1,121 @@
-import { logger as rootLogger } from "./logger.js";
-const logger = rootLogger.child({ module: "js-router-detector" });
-async function detectJsRoutes(page, origin) {
-  try {
-    const raw = await page.evaluate(() => {
-      const found = [];
-      const windowGlobals = [
-        "__routes__",
-        "__ROUTER__",
-        "__vue_router__",
-        "__router__",
-        "router",
-        "_router",
-        "__reactRouter",
-        "__NEXT_DATA__"
-      ];
-      for (const g of windowGlobals) {
-        try {
-          const val = window[g];
-          if (!val || typeof val !== "object") continue;
-          if (g === "__NEXT_DATA__" && Array.isArray(val.buildManifest?.pages)) {
-            for (const p of val.buildManifest.pages) if (typeof p === "string") found.push(p);
-            continue;
-          }
-          const routeArr = (Array.isArray(val.options?.routes) ? val.options.routes : null) ?? (Array.isArray(val.routes) ? val.routes : null) ?? (typeof val.getRoutes === "function" ? val.getRoutes() : null);
-          if (!Array.isArray(routeArr)) continue;
-          const flatRoutes = (arr, prefix = "") => {
-            for (const r of arr) {
-              if (!r || typeof r !== "object") continue;
-              const path = r.path ?? r.href ?? r.url ?? "";
-              const full = path.startsWith("/") ? path : `${prefix}/${path}`.replace(/\/\//g, "/");
-              if (full && full !== "/") found.push(full);
-              if (Array.isArray(r.children)) flatRoutes(r.children, full);
+/**
+ * P2: JS Router Detection
+ *
+ * Scans the loaded page for client-side route tables declared by React Router v6,
+ * Vue Router, Angular Router, or custom window globals. Supplements the existing
+ * history.pushState interception (which only captures runtime navigation) with a
+ * static analysis of routes declared in the JS bundle.
+ *
+ * Called once per page after goto(). Runs entirely in-browser via page.evaluate().
+ * Adds discovered routes to the BFS frontier so the crawler visits them.
+ */
+import { logger as rootLogger } from './logger.js';
+const logger = rootLogger.child({ module: 'js-router-detector' });
+/**
+ * Extract absolute page URLs from the current page's JS router config.
+ * Returns deduplicated absolute URLs (same origin). Dynamic segments (:id, *)
+ * are skipped — the crawler can't resolve them without knowing valid IDs.
+ */
+export async function detectJsRoutes(page, origin) {
+    try {
+        const raw = await page.evaluate(() => {
+            const found = [];
+            // 1. Check common framework globals ─────────────────────────────────────
+            const windowGlobals = [
+                '__routes__', '__ROUTER__', '__vue_router__', '__router__',
+                'router', '_router', '__reactRouter', '__NEXT_DATA__',
+            ];
+            for (const g of windowGlobals) {
+                try {
+                    const val = window[g];
+                    if (!val || typeof val !== 'object')
+                        continue;
+                    // Next.js page manifest
+                    if (g === '__NEXT_DATA__' && Array.isArray(val.buildManifest?.pages)) {
+                        for (const p of val.buildManifest.pages)
+                            if (typeof p === 'string')
+                                found.push(p);
+                        continue;
+                    }
+                    // Router objects: options.routes, routes, getRoutes()
+                    const routeArr = (Array.isArray(val.options?.routes) ? val.options.routes : null) ??
+                        (Array.isArray(val.routes) ? val.routes : null) ??
+                        (typeof val.getRoutes === 'function' ? val.getRoutes() : null);
+                    if (!Array.isArray(routeArr))
+                        continue;
+                    const flatRoutes = (arr, prefix = '') => {
+                        for (const r of arr) {
+                            if (!r || typeof r !== 'object')
+                                continue;
+                            const path = r.path ?? r.href ?? r.url ?? '';
+                            const full = path.startsWith('/') ? path : `${prefix}/${path}`.replace(/\/\//g, '/');
+                            if (full && full !== '/')
+                                found.push(full);
+                            if (Array.isArray(r.children))
+                                flatRoutes(r.children, full);
+                        }
+                    };
+                    flatRoutes(routeArr);
+                }
+                catch { /* skip corrupt globals */ }
+            }
+            // 2. Scan inline <script> content for route patterns ───────────────────
+            // Two-pass: regex first, if >3 found trust them. Below 3 → skip (too noisy).
+            const routePatterns = [
+                /\bpath\s*:\s*['"](\/?[\w\-\/\.~@]+)['"]/g,
+                /\broute\s*\(\s*['"](\/?[\w\-\/\.~@]+)['"]/g,
+                /<Route[^>]+path\s*=\s*['"](\/?[\w\-\/\.~@]+)['"]/g,
+                /to\s*:\s*['"](\/?[\w\-\/\.~@]+)['"]/g,
+            ];
+            const scripts = Array.from(document.querySelectorAll('script:not([src])'));
+            for (const el of scripts.slice(0, 15)) {
+                const src = el.textContent ?? '';
+                if (src.length < 100 || src.length > 800_000)
+                    continue;
+                for (const pat of routePatterns) {
+                    const hits = [];
+                    let m;
+                    pat.lastIndex = 0;
+                    while ((m = pat.exec(src)) !== null && hits.length < 100) {
+                        if (m[1] && m[1].startsWith('/') && m[1].length > 1)
+                            hits.push(m[1]);
+                    }
+                    // Only trust if we found >2 hits (reduces false positives)
+                    if (hits.length > 2)
+                        for (const h of hits)
+                            found.push(h);
+                }
+            }
+            return found;
+        });
+        // Post-process: resolve to absolute, dedup, drop dynamic segments
+        const DYNAMIC = /[*:?]/;
+        const ASSET = /\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|map|json|xml)$/i;
+        const seen = new Set();
+        const result = [];
+        for (const r of raw) {
+            if (!r || typeof r !== 'string' || DYNAMIC.test(r) || ASSET.test(r))
+                continue;
+            const abs = r.startsWith('http') ? r : `${origin}${r.startsWith('/') ? '' : '/'}${r}`;
+            try {
+                const parsed = new URL(abs);
+                if (parsed.origin !== origin)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            if (!seen.has(abs)) {
+                seen.add(abs);
+                result.push(abs);
             }
-          };
-          flatRoutes(routeArr);
-        } catch {
-        }
-      }
-      const routePatterns = [
-        /\bpath\s*:\s*['"](\/?[\w\-\/\.~@]+)['"]/g,
-        /\broute\s*\(\s*['"](\/?[\w\-\/\.~@]+)['"]/g,
-        /<Route[^>]+path\s*=\s*['"](\/?[\w\-\/\.~@]+)['"]/g,
-        /to\s*:\s*['"](\/?[\w\-\/\.~@]+)['"]/g
-      ];
-      const scripts = Array.from(document.querySelectorAll("script:not([src])"));
-      for (const el of scripts.slice(0, 15)) {
-        const src = el.textContent ?? "";
-        if (src.length < 100 || src.length > 8e5) continue;
-        for (const pat of routePatterns) {
-          const hits = [];
-          let m;
-          pat.lastIndex = 0;
-          while ((m = pat.exec(src)) !== null && hits.length < 100) {
-            if (m[1] && m[1].startsWith("/") && m[1].length > 1) hits.push(m[1]);
-          }
-          if (hits.length > 2) for (const h of hits) found.push(h);
         }
-      }
-      return found;
-    });
-    const DYNAMIC = /[*:?]/;
-    const ASSET = /\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|map|json|xml)$/i;
-    const seen = /* @__PURE__ */ new Set();
-    const result = [];
-    for (const r of raw) {
-      if (!r || typeof r !== "string" || DYNAMIC.test(r) || ASSET.test(r)) continue;
-      const abs = r.startsWith("http") ? r : `${origin}${r.startsWith("/") ? "" : "/"}${r}`;
-      try {
-        const parsed = new URL(abs);
-        if (parsed.origin !== origin) continue;
-      } catch {
-        continue;
-      }
-      if (!seen.has(abs)) {
-        seen.add(abs);
-        result.push(abs);
-      }
+        if (result.length > 0)
+            logger.info({ count: result.length }, '[P2] JS router: routes detected');
+        return result;
+    }
+    catch (err) {
+        logger.warn({ err: String(err) }, '[P2] JS router detection failed — non-fatal');
+        return [];
     }
-    if (result.length > 0) logger.info({ count: result.length }, "[P2] JS router: routes detected");
-    return result;
-  } catch (err) {
-    logger.warn({ err: String(err) }, "[P2] JS router detection failed \u2014 non-fatal");
-    return [];
-  }
 }
-export {
-  detectJsRoutes
-};
-//# sourceMappingURL=js-router-detector.js.map

package/dist/language-detector.js

@@ -1,57 +1,69 @@
+/**
+ * Language detector — identify page language from HTML attributes and content analysis.
+ *
+ * Sources (in priority order):
+ * 1. <html lang="..."> attribute
+ * 2. <meta http-equiv="Content-Language"> header
+ * 3. hreflang alternate links
+ * 4. Content-based n-gram fingerprint (detects top 20 languages)
+ *
+ * Used to: route pages to the correct markdown processor, group screens by locale,
+ * and detect missing hreflang implementations.
+ */
+// Frequency signatures for n-gram based detection
+// Common trigrams by language (simplified — not production-grade)
 const LANG_SIGNATURES = {
-  en: /\b(the|and|for|are|but|not|you|all|can|had|her|was|one|our|out|day|get|has|him|his|how)\b/gi,
-  es: /\b(que|con|una|por|del|las|los|para|como|pero|más|este|esto|sus|ser|hay|sobre|entre|también)\b/gi,
-  fr: /\b(les|des|une|est|dans|pour|qui|par|sur|avec|que|pas|son|tout|mais|bien|comme|vous)\b/gi,
-  de: /\b(die|der|und|den|das|ein|ist|von|mit|dem|auf|sich|des|aber|auch|bei|aus|nach)\b/gi,
-  pt: /\b(que|não|uma|com|por|dos|para|como|mais|mas|seu|sua|nas|nos|ele|ela|são)\b/gi,
-  it: /\b(che|con|del|per|una|nel|non|sono|gli|dei|alla|delle|questa|questo|come|più)\b/gi,
-  nl: /\b(van|het|een|zijn|maar|ook|dan|door|op|uit|aan|bij|om|al|veel|haar|hun)\b/gi,
-  ja: /[぀-ゟ゠-ヿ]/g,
-  zh: /[一-鿿]/g,
-  ar: /[؀-ۿ]/g,
-  hi: /[ऀ-ॿ]/g,
-  ko: /[가-힯ᄀ-ᇿ]/g
+    en: /\b(the|and|for|are|but|not|you|all|can|had|her|was|one|our|out|day|get|has|him|his|how)\b/gi,
+    es: /\b(que|con|una|por|del|las|los|para|como|pero|más|este|esto|sus|ser|hay|sobre|entre|también)\b/gi,
+    fr: /\b(les|des|une|est|dans|pour|qui|par|sur|avec|que|pas|son|tout|mais|bien|comme|vous)\b/gi,
+    de: /\b(die|der|und|den|das|ein|ist|von|mit|dem|auf|sich|des|aber|auch|bei|aus|nach)\b/gi,
+    pt: /\b(que|não|uma|com|por|dos|para|como|mais|mas|seu|sua|nas|nos|ele|ela|são)\b/gi,
+    it: /\b(che|con|del|per|una|nel|non|sono|gli|dei|alla|delle|questa|questo|come|più)\b/gi,
+    nl: /\b(van|het|een|zijn|maar|ook|dan|door|op|uit|aan|bij|om|al|veel|haar|hun)\b/gi,
+    ja: /[぀-ゟ゠-ヿ]/g,
+    zh: /[一-鿿]/g,
+    ar: /[؀-ۿ]/g,
+    hi: /[ऀ-ॿ]/g,
+    ko: /[가-힯ᄀ-ᇿ]/g,
 };
 function detectFromContent(text) {
-  if (!text || text.length < 50) return "en";
-  let best = "en";
-  let bestScore = 0;
-  for (const [lang, re] of Object.entries(LANG_SIGNATURES)) {
-    const matches = (text.match(re) ?? []).length;
-    const score = matches / Math.max(text.length / 100, 1);
-    if (score > bestScore) {
-      bestScore = score;
-      best = lang;
+    if (!text || text.length < 50)
+        return 'en';
+    let best = 'en';
+    let bestScore = 0;
+    for (const [lang, re] of Object.entries(LANG_SIGNATURES)) {
+        const matches = (text.match(re) ?? []).length;
+        const score = matches / Math.max(text.length / 100, 1);
+        if (score > bestScore) {
+            bestScore = score;
+            best = lang;
+        }
     }
-  }
-  return best;
+    return best;
 }
-async function detectLanguage(page, url) {
-  const data = await page.evaluate(() => {
-    const htmlLang = document.documentElement.lang?.toLowerCase().split("-")[0] ?? "";
-    const metaLang = document.querySelector('meta[http-equiv="Content-Language"]')?.content?.toLowerCase().split("-")[0] ?? "";
-    const alternates = {};
-    document.querySelectorAll('link[rel="alternate"][hreflang]').forEach((el) => {
-      const lang = el.getAttribute("hreflang")?.toLowerCase();
-      const href = el.getAttribute("href") ?? "";
-      if (lang && lang !== "x-default") alternates[lang] = href;
-    });
-    const bodyText = (document.body?.innerText ?? "").slice(0, 2e3);
-    return { htmlLang, metaLang, alternates, bodyText };
-  }).catch(() => ({ htmlLang: "", metaLang: "", alternates: {}, bodyText: "" }));
-  const declaredLang = data.htmlLang || data.metaLang || "";
-  const detectedLang = detectFromContent(data.bodyText);
-  const confidence = declaredLang ? "high" : data.bodyText.length > 200 ? "medium" : "low";
-  return {
-    url,
-    declaredLang,
-    detectedLang: declaredLang || detectedLang,
-    confidence,
-    alternates: data.alternates,
-    isMultilingual: Object.keys(data.alternates).length > 1
-  };
+export async function detectLanguage(page, url) {
+    const data = await page.evaluate(() => {
+        const htmlLang = document.documentElement.lang?.toLowerCase().split('-')[0] ?? '';
+        const metaLang = document.querySelector('meta[http-equiv="Content-Language"]')?.content?.toLowerCase().split('-')[0] ?? '';
+        const alternates = {};
+        document.querySelectorAll('link[rel="alternate"][hreflang]').forEach((el) => {
+            const lang = el.getAttribute('hreflang')?.toLowerCase();
+            const href = el.getAttribute('href') ?? '';
+            if (lang && lang !== 'x-default')
+                alternates[lang] = href;
+        });
+        const bodyText = (document.body?.innerText ?? '').slice(0, 2000);
+        return { htmlLang, metaLang, alternates, bodyText };
+    }).catch(() => ({ htmlLang: '', metaLang: '', alternates: {}, bodyText: '' }));
+    const declaredLang = data.htmlLang || data.metaLang || '';
+    const detectedLang = detectFromContent(data.bodyText);
+    const confidence = declaredLang ? 'high' : data.bodyText.length > 200 ? 'medium' : 'low';
+    return {
+        url,
+        declaredLang,
+        detectedLang: declaredLang || detectedLang,
+        confidence,
+        alternates: data.alternates,
+        isMultilingual: Object.keys(data.alternates).length > 1,
+    };
 }
-export {
-  detectLanguage
-};
-//# sourceMappingURL=language-detector.js.map

package/dist/link-classifier.js

@@ -1,40 +1,58 @@
+/**
+ * Link classifier — assigns priority and category to discovered URLs.
+ *
+ * Categories:
+ * - 'nav'       : site navigation (homepage, top-level pages) — highest priority
+ * - 'auth'      : login/register/password flows — high priority
+ * - 'app'       : authenticated app screens — high priority
+ * - 'content'   : blog/docs/articles — medium priority
+ * - 'api'       : REST/GraphQL API endpoints — detected, not crawled as screens
+ * - 'resource'  : static assets (JS/CSS/img/fonts) — skip
+ * - 'external'  : different domain — skip unless cross-domain crawl enabled
+ * - 'low-value' : pagination, sort, filter query strings — deprioritize
+ */
 const RESOURCE_EXT = /\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot|mp4|mp3|pdf|zip|gz|tar|exe|dmg|apk)(\?|$)/i;
 const API_PATTERN = /\/(api|graphql|gql|rest|v\d+)\//i;
 const AUTH_PATTERN = /\/(login|signin|sign-in|register|signup|sign-up|auth|oauth|sso|password|forgot|reset|logout|signout)\b/i;
 const LOW_VALUE_PATTERN = /[?&](page|p|offset|sort|order|filter|q|search|tag|category|color|size|brand)=/i;
 const PAGINATION_PATTERN = /\/page\/\d+|\/p\/\d+|\bpage=\d+/i;
-function classifyLink(url, baseUrl) {
-  let parsed;
-  let baseHost;
-  try {
-    parsed = new URL(url);
-    baseHost = new URL(baseUrl).hostname;
-  } catch {
-    return { url, category: "low-value", priority: 0, reason: "invalid URL" };
-  }
-  const path = parsed.pathname + parsed.search;
-  const isExternal = parsed.hostname !== baseHost;
-  if (isExternal) return { url, category: "external", priority: 0, reason: "different domain" };
-  if (RESOURCE_EXT.test(path)) return { url, category: "resource", priority: 0, reason: "static asset extension" };
-  if (API_PATTERN.test(path)) return { url, category: "api", priority: 10, reason: "API path pattern" };
-  if (AUTH_PATTERN.test(path)) return { url, category: "auth", priority: 90, reason: "auth flow pattern" };
-  if (PAGINATION_PATTERN.test(path)) return { url, category: "low-value", priority: 15, reason: "pagination" };
-  if (LOW_VALUE_PATTERN.test(path)) return { url, category: "low-value", priority: 20, reason: "filter/sort query param" };
-  const segments = parsed.pathname.split("/").filter(Boolean);
-  if (segments.length === 0) return { url, category: "nav", priority: 100, reason: "homepage" };
-  if (segments.length === 1) return { url, category: "nav", priority: 80, reason: "top-level nav" };
-  if (segments.length <= 3) return { url, category: "app", priority: 60, reason: "app screen" };
-  return { url, category: "content", priority: 40, reason: "deep content page" };
+export function classifyLink(url, baseUrl) {
+    let parsed;
+    let baseHost;
+    try {
+        parsed = new URL(url);
+        baseHost = new URL(baseUrl).hostname;
+    }
+    catch {
+        return { url, category: 'low-value', priority: 0, reason: 'invalid URL' };
+    }
+    const path = parsed.pathname + parsed.search;
+    const isExternal = parsed.hostname !== baseHost;
+    if (isExternal)
+        return { url, category: 'external', priority: 0, reason: 'different domain' };
+    if (RESOURCE_EXT.test(path))
+        return { url, category: 'resource', priority: 0, reason: 'static asset extension' };
+    if (API_PATTERN.test(path))
+        return { url, category: 'api', priority: 10, reason: 'API path pattern' };
+    if (AUTH_PATTERN.test(path))
+        return { url, category: 'auth', priority: 90, reason: 'auth flow pattern' };
+    if (PAGINATION_PATTERN.test(path))
+        return { url, category: 'low-value', priority: 15, reason: 'pagination' };
+    if (LOW_VALUE_PATTERN.test(path))
+        return { url, category: 'low-value', priority: 20, reason: 'filter/sort query param' };
+    const segments = parsed.pathname.split('/').filter(Boolean);
+    if (segments.length === 0)
+        return { url, category: 'nav', priority: 100, reason: 'homepage' };
+    if (segments.length === 1)
+        return { url, category: 'nav', priority: 80, reason: 'top-level nav' };
+    if (segments.length <= 3)
+        return { url, category: 'app', priority: 60, reason: 'app screen' };
+    return { url, category: 'content', priority: 40, reason: 'deep content page' };
 }
-function classifyLinks(urls, baseUrl) {
-  return urls.map((u) => classifyLink(u, baseUrl)).sort((a, b) => b.priority - a.priority);
+export function classifyLinks(urls, baseUrl) {
+    return urls.map(u => classifyLink(u, baseUrl))
+        .sort((a, b) => b.priority - a.priority);
 }
-function filterCrawlable(classified) {
-  return classified.filter((l) => l.category !== "resource" && l.category !== "external" && l.category !== "api");
+export function filterCrawlable(classified) {
+    return classified.filter(l => l.category !== 'resource' && l.category !== 'external' && l.category !== 'api');
 }
-export {
-  classifyLink,
-  classifyLinks,
-  filterCrawlable
-};
-//# sourceMappingURL=link-classifier.js.map