pagesight 0.16.0 → 0.18.0

package/src/tools/speed/pagespeed.ts

@@ -0,0 +1,273 @@
+import { type PsiAudit, type PsiAuditDetailItem, type PsiResult } from "../../providers/pagespeed.js";
+export const QUOTA_NOTE =
+  "\n\nNote: No GOOGLE_API_KEY configured — using shared quota (400 req/day). Set your own key to avoid rate limits.";
+
+function scoreLabel(score: number | null): string {
+  if (score === null) return "N/A";
+  const pct = Math.round(score * 100);
+  if (pct >= 90) return `${pct} (good)`;
+  if (pct >= 50) return `${pct} (needs improvement)`;
+  return `${pct} (poor)`;
+}
+
+export function scorePct(score: number | null): number | null {
+  return score === null ? null : Math.round(score * 100);
+}
+
+function cwvRating(category: string): string {
+  if (category === "FAST") return "good";
+  if (category === "AVERAGE") return "needs improvement";
+  if (category === "SLOW") return "poor";
+  return category;
+}
+
+function formatLoadingExperience(label: string, exp: PsiResult["loadingExperience"]): string[] {
+  if (!exp?.metrics || Object.keys(exp.metrics).length === 0) return [];
+
+  const lines: string[] = [`--- ${label} (CrUX Field Data) ---`, ""];
+  lines.push(`Overall: ${cwvRating(exp.overall_category)}`, "");
+
+  const metricNames: Record<string, string> = {
+    CUMULATIVE_LAYOUT_SHIFT_SCORE: "CLS",
+    EXPERIMENTAL_TIME_TO_FIRST_BYTE: "TTFB",
+    FIRST_CONTENTFUL_PAINT_MS: "FCP",
+    FIRST_INPUT_DELAY_MS: "FID",
+    INTERACTION_TO_NEXT_PAINT: "INP",
+    LARGEST_CONTENTFUL_PAINT_MS: "LCP",
+  };
+
+  for (const [key, metric] of Object.entries(exp.metrics)) {
+    const name = metricNames[key] ?? key;
+    const unit = key.includes("LAYOUT_SHIFT") ? "" : "ms";
+    const value = key.includes("LAYOUT_SHIFT") ? (metric.percentile / 100).toFixed(2) : `${metric.percentile}${unit}`;
+    lines.push(`${name}: ${value} (${cwvRating(metric.category)})`);
+  }
+
+  return lines;
+}
+
+function formatOpportunities(audits: Record<string, PsiAudit>): string[] {
+  const opportunities: PsiAudit[] = [];
+
+  for (const audit of Object.values(audits)) {
+    if (audit.score === null || audit.score >= 1) continue;
+    const mode = audit.scoreDisplayMode;
+    const hasItems = (audit.details?.items?.length ?? 0) > 0;
+    const hasNumeric = audit.numericValue && audit.numericValue > 0;
+    if (mode === "metricSavings" || ((mode === "numeric" || mode === "binary") && hasNumeric)) {
+      if (hasNumeric || hasItems) {
+        opportunities.push(audit);
+      }
+    }
+  }
+
+  if (opportunities.length === 0) return [];
+
+  opportunities.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
+
+  const lines: string[] = ["--- Opportunities ---", ""];
+  for (const audit of opportunities.slice(0, 10)) {
+    const severity = (audit.score ?? 0) < 0.5 ? "HIGH" : (audit.score ?? 0) < 0.9 ? "MEDIUM" : "LOW";
+    const unit = audit.numericUnit === "millisecond" ? "ms" : audit.numericUnit === "byte" ? " bytes" : "";
+    const savings = audit.displayValue ?? `${Math.round(audit.numericValue ?? 0)}${unit}`;
+    lines.push(`${severity}  ${audit.title}`);
+    lines.push(`  Potential savings: ${savings}`);
+
+    const items = audit.details?.items;
+    if (items && items.length > 0) {
+      for (const item of items.slice(0, 3)) {
+        lines.push(...formatDetailItem(item));
+      }
+      if (items.length > 3) {
+        lines.push(`  ... and ${items.length - 3} more resources`);
+      }
+    }
+    lines.push("");
+  }
+
+  return lines;
+}
+
+function formatDiagnostics(audits: Record<string, PsiAudit>): string[] {
+  const failing: PsiAudit[] = [];
+
+  for (const audit of Object.values(audits)) {
+    if (
+      audit.score !== null &&
+      audit.score < 0.5 &&
+      (audit.scoreDisplayMode === "numeric" || audit.scoreDisplayMode === "metricSavings") &&
+      audit.displayValue
+    ) {
+      failing.push(audit);
+    }
+  }
+
+  if (failing.length === 0) return [];
+
+  failing.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
+
+  const lines: string[] = ["--- Diagnostics ---", ""];
+  for (const audit of failing.slice(0, 10)) {
+    lines.push(`${audit.title}: ${audit.displayValue}`);
+
+    const linkMatch = audit.description?.match(/\[.*?\]\((https?:\/\/[^)]+)\)/);
+    if (linkMatch) lines.push(`  Learn more: ${linkMatch[1]}`);
+
+    const items = audit.details?.items;
+    if (items && items.length > 0) {
+      for (const item of items.slice(0, 3)) {
+        lines.push(...formatDetailItem(item));
+      }
+      if (items.length > 3) {
+        lines.push(`  ... and ${items.length - 3} more`);
+      }
+    }
+    lines.push("");
+  }
+
+  return lines;
+}
+
+function formatDetailItem(item: PsiAuditDetailItem): string[] {
+  const lines: string[] = [];
+
+  if (item.node) {
+    const n = item.node;
+    if (n.nodeLabel) lines.push(`  Element: "${n.nodeLabel}"`);
+    if (n.selector) lines.push(`  Selector: ${n.selector}`);
+    if (n.snippet) lines.push(`  HTML: ${n.snippet}`);
+    if (n.explanation) lines.push(`  Issue: ${n.explanation}`);
+  } else if (item.url) {
+    const parts = [`  ${item.url}`];
+    if (item.wastedMs) parts.push(`wastedMs=${Math.round(item.wastedMs)}`);
+    if (item.wastedBytes) parts.push(`wastedBytes=${Math.round(item.wastedBytes)}`);
+    if (item.totalBytes) parts.push(`totalBytes=${Math.round(item.totalBytes)}`);
+    lines.push(parts.join("  "));
+  }
+
+  return lines;
+}
+
+function formatFailingAudits(audits: Record<string, PsiAudit>, categoryRefs: string[]): string[] {
+  const failing: PsiAudit[] = [];
+
+  for (const ref of categoryRefs) {
+    const audit = audits[ref];
+    if (audit && audit.score !== null && audit.score < 1) {
+      failing.push(audit);
+    }
+  }
+
+  if (failing.length === 0) return [];
+
+  failing.sort((a, b) => (a.score ?? 0) - (b.score ?? 0));
+
+  const lines: string[] = [];
+  for (const audit of failing) {
+    const severity = audit.score === 0 ? "FAIL" : (audit.score ?? 0) < 0.5 ? "WARN" : "INFO";
+    lines.push(`[${severity}] ${audit.title}`);
+    if (audit.displayValue) lines.push(`  Value: ${audit.displayValue}`);
+
+    // Extract learn-more URL from description markdown
+    const linkMatch = audit.description?.match(/\[.*?\]\((https?:\/\/[^)]+)\)/);
+    if (linkMatch) lines.push(`  Learn more: ${linkMatch[1]}`);
+
+    const items = audit.details?.items;
+    if (items && items.length > 0) {
+      const maxItems = 5;
+      for (const item of items.slice(0, maxItems)) {
+        lines.push(...formatDetailItem(item));
+      }
+      if (items.length > maxItems) {
+        lines.push(`  ... and ${items.length - maxItems} more`);
+      }
+    }
+    lines.push("");
+  }
+
+  return lines;
+}
+
+export function formatPagespeed(url: string, result: PsiResult): string {
+  const lhr = result.lighthouseResult;
+  const lines: string[] = [
+    `=== PageSpeed: ${url} ===`,
+    `Strategy: ${lhr.configSettings.emulatedFormFactor}`,
+    `Lighthouse: ${lhr.lighthouseVersion}`,
+    `Analyzed: ${result.analysisUTCTimestamp}`,
+    "",
+  ];
+
+  // Runtime errors
+  if (lhr.runtimeError) {
+    lines.push(`ERROR: ${lhr.runtimeError.code} — ${lhr.runtimeError.message}`, "");
+  }
+
+  // Warnings
+  if (lhr.runWarnings && lhr.runWarnings.length > 0) {
+    for (const w of lhr.runWarnings) {
+      lines.push(`WARNING: ${w}`);
+    }
+    lines.push("");
+  }
+
+  // Category scores
+  lines.push("--- Scores ---", "");
+  for (const cat of Object.values(lhr.categories)) {
+    lines.push(`${cat.title}: ${scoreLabel(cat.score)}`);
+  }
+  lines.push("");
+
+  // Lab performance metrics
+  const cwvIds = [
+    "first-contentful-paint",
+    "largest-contentful-paint",
+    "total-blocking-time",
+    "cumulative-layout-shift",
+    "speed-index",
+    "interactive",
+  ];
+  const cwvLines: string[] = [];
+  for (const id of cwvIds) {
+    const audit = lhr.audits[id];
+    if (audit?.displayValue) {
+      cwvLines.push(`${audit.title}: ${audit.displayValue} ${scoreLabel(audit.score)}`);
+    }
+  }
+  if (cwvLines.length > 0) {
+    lines.push("--- Lab Performance Metrics ---", "", ...cwvLines, "");
+  }
+
+  // CrUX field data
+  const pageExp = formatLoadingExperience("Page", result.loadingExperience);
+  if (pageExp.length > 0) lines.push(...pageExp, "");
+
+  const originExp = formatLoadingExperience("Origin", result.originLoadingExperience);
+  if (originExp.length > 0) lines.push(...originExp, "");
+
+  // Opportunities
+  const opps = formatOpportunities(lhr.audits);
+  if (opps.length > 0) lines.push(...opps, "");
+
+  // Diagnostics
+  const diags = formatDiagnostics(lhr.audits);
+  if (diags.length > 0) lines.push(...diags, "");
+
+  // Failing audits per non-performance category (a11y, SEO, best practices)
+  for (const cat of Object.values(lhr.categories)) {
+    if (cat.id === "performance" || !cat.auditRefs) continue;
+    const score = cat.score !== null ? Math.round(cat.score * 100) : null;
+    if (score === null || score >= 100) continue;
+
+    const refs = cat.auditRefs.map((r) => r.id);
+    const details = formatFailingAudits(lhr.audits, refs);
+    if (details.length > 0) {
+      lines.push(`--- ${cat.title} Issues ---`, "", ...details);
+    }
+  }
+
+  // Timing
+  lines.push(`Analysis took ${(lhr.timing.total / 1000).toFixed(1)}s`);
+
+  return lines.join("\n");
+}

package/src/tools/speed/schema.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export const speedSchema = {
+  action: z
+    .enum(["pagespeed", "crux", "crux_history"])
+    .optional()
+    .describe("Which analysis to run. Auto-detected: 'pagespeed' when url/urls provided, 'crux' when origin provided."),
+  url: z.string().url().optional().describe("URL to analyze (PageSpeed or CrUX)."),
+  urls: z
+    .array(z.string().url())
+    .min(2)
+    .max(10)
+    .optional()
+    .describe("Multiple URLs (2-10) for batch PageSpeed. 2 = compare, 3+ = summary table."),
+  strategy: z.enum(["mobile", "desktop"]).optional().describe("Device strategy for PageSpeed. Default: 'mobile'."),
+  categories: z
+    .array(z.enum(["performance", "accessibility", "best-practices", "seo"]))
+    .optional()
+    .describe("Lighthouse categories. Default: all four."),
+  locale: z.string().optional().describe("Locale for PageSpeed results."),
+  origin: z.string().optional().describe("Origin for CrUX data (e.g., 'https://example.com'). Triggers CrUX mode."),
+  form_factor: z.enum(["DESKTOP", "PHONE", "TABLET"]).optional().describe("CrUX device filter."),
+  metrics: z
+    .array(
+      z.enum([
+        "cumulative_layout_shift",
+        "first_contentful_paint",
+        "interaction_to_next_paint",
+        "largest_contentful_paint",
+        "experimental_time_to_first_byte",
+        "round_trip_time",
+        "navigation_types",
+        "form_factors",
+      ]),
+    )
+    .optional()
+    .describe("CrUX metrics to query."),
+  periods: z.number().min(1).max(40).optional().describe("CrUX history periods (1-40). Default: 25."),
+};
+export type SpeedOptions = z.infer<z.ZodObject<typeof speedSchema>>;

package/src/tools/speed/tool.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { speedSchema } from "./schema.js";
+import { analyzeSpeed } from "./analyze.js";
+export function registerSpeedTool(server: McpServer): void {
+  server.tool(
+    "speed",
+    "Analyze site performance. Run PageSpeed Insights (lab metrics, Lighthouse scores, opportunities) for single or multiple URLs, or query Chrome UX Report for real-world field data and historical trends.",
+    speedSchema,
+    analyzeSpeed,
+  );
+}

package/src/web/fetch.ts

@@ -0,0 +1,31 @@
+import { readBounded, RequestError } from "../shared/http.js";
+
+export async function fetchText(url: string, maxBytes: number, origin?: string) {
+  const redirects: Array<{ url: string; status: number; location: string }> = [];
+  let current = url;
+  const signal = AbortSignal.timeout(20_000);
+  for (let hop = 0; hop <= 5; hop++) {
+    const parsed = new URL(current);
+    if (
+      !["http:", "https:"].includes(parsed.protocol) ||
+      parsed.username ||
+      parsed.password ||
+      (origin && parsed.origin !== origin)
+    )
+      throw new RequestError("Redirect left the permitted origin or protocol", null, "invalid_redirect");
+    const response = await fetch(current, {
+      signal,
+      redirect: "manual",
+      headers: { "User-Agent": "Pagesight/0.17", Accept: "text/html,application/xml,text/plain" },
+    });
+    const location = response.headers.get("location");
+    if ([301, 302, 303, 307, 308].includes(response.status) && location) {
+      redirects.push({ url: current, status: response.status, location });
+      await response.body?.cancel();
+      current = new URL(location, current).href;
+      continue;
+    }
+    return { response, body: await readBounded(response, maxBytes), finalUrl: current, redirects };
+  }
+  throw new RequestError("Redirect limit exceeded", null, "redirect_limit");
+}

package/src/web/images.ts

@@ -0,0 +1,62 @@
+/** Inspect fetched markup without executing scripts or requesting image URLs. */
+export async function imageEvidence(html: string) {
+  const images: Array<{
+    src: string | null;
+    altPresent: boolean;
+    altText: string | null;
+    inNoscript: boolean;
+    width: string | null;
+    height: string | null;
+    role: string | null;
+    ariaHidden: string | null;
+  }> = [];
+  let omittedImages = 0;
+  const noscript: string[] = [];
+  let currentNoscript = "";
+  const handler = (inNoscript: boolean) => ({
+    element(el: HTMLRewriterTypes.Element) {
+      if (images.length >= 200) {
+        omittedImages++;
+        return;
+      }
+      const altPresent = el.hasAttribute("alt");
+      images.push({
+        src: el.getAttribute("src"),
+        altPresent,
+        altText: altPresent ? (el.getAttribute("alt") ?? "") : null,
+        inNoscript,
+        width: el.getAttribute("width"),
+        height: el.getAttribute("height"),
+        role: el.getAttribute("role"),
+        ariaHidden: el.getAttribute("aria-hidden"),
+      });
+    },
+  });
+  await new HTMLRewriter()
+    .on("img", handler(false))
+    .on("noscript", {
+      element(el) {
+        currentNoscript = "";
+        el.onEndTag(() => {
+          noscript.push(currentNoscript);
+          currentNoscript = "";
+        });
+      },
+      text(chunk) {
+        currentNoscript += chunk.text;
+      },
+    })
+    .transform(new Response(html))
+    .text();
+  if (currentNoscript) noscript.push(currentNoscript);
+  for (const fragment of noscript)
+    await new HTMLRewriter().on("img", handler(true)).transform(new Response(fragment)).text();
+  return {
+    images,
+    omittedImages,
+    truncated: omittedImages > 0,
+    warnings: [
+      "Images are fetched HTML evidence, including noscript fallback markup; scripts and image URLs were not loaded. Empty ALT may be appropriate for decorative images; meaning requires context.",
+    ],
+  };
+}

package/src/web/page-observation.ts

@@ -0,0 +1,69 @@
+import { imageEvidence } from "./images.js";
+import { fetchText } from "./fetch.js";
+
+export async function observePage(url: string) {
+  const { response, body, finalUrl, redirects } = await fetchText(url, 2_000_000);
+  const warnings = ["Fetched HTML only; JavaScript execution and crawler access were not tested."];
+  let title = "";
+  const metadata: { canonical: string | null; description: string | null } = { canonical: null, description: null };
+  const robots: string[] = [];
+  const data: string[] = [];
+  const rewriter = new HTMLRewriter()
+    .on("title", {
+      text(chunk) {
+        title += chunk.text;
+      },
+    })
+    .on('link[rel="canonical"]', {
+      element(el) {
+        const href = el.getAttribute("href");
+        if (href) {
+          try {
+            metadata.canonical = new URL(href, finalUrl).href;
+          } catch {
+            warnings.push("Malformed canonical href; canonical is unknown.");
+          }
+        }
+      },
+    })
+    .on("meta", {
+      element(el) {
+        const name = el.getAttribute("name")?.toLowerCase();
+        const value = el.getAttribute("content");
+        if (name === "description") metadata.description = value;
+        if ((name === "robots" || name === "googlebot") && value) robots.push(`${name}: ${value}`);
+      },
+    })
+    .on('script[type="application/ld+json"]', {
+      text(chunk) {
+        if (!data.length) data.push("");
+        data[data.length - 1] += chunk.text;
+        if (chunk.lastInTextNode) data.push("");
+      },
+    });
+  await rewriter.transform(new Response(body)).text();
+  return {
+    url,
+    finalUrl,
+    status: response.status,
+    redirects,
+    contentType: response.headers.get("content-type"),
+    xRobotsTag: response.headers.get("x-robots-tag"),
+    title: title.trim() || null,
+    description: metadata.description,
+    descriptionLength: metadata.description === null ? null : Array.from(metadata.description).length,
+    canonical: metadata.canonical,
+    robots,
+    sha256: Bun.CryptoHasher.hash("sha256", body, "hex"),
+    bytes: Buffer.byteLength(body),
+    structuredData: data.filter(Boolean).map((text) => {
+      try {
+        return { value: JSON.parse(text), validJson: true };
+      } catch {
+        return { value: null, validJson: false };
+      }
+    }),
+    imageEvidence: await imageEvidence(body),
+    warnings,
+  };
+}

package/src/{lib → web}/robots.ts

@@ -1,5 +1,5 @@
 /**
- * robots.txt parser per RFC 9309
+ * robots.txt parser based on RFC 9309
  * https://www.rfc-editor.org/rfc/rfc9309
  *
  * AI crawler registry sourced from:
@@ -152,17 +152,24 @@ export function parseRobotsTxt(raw: string): RobotsTxt {
   return { groups, sitemaps, raw, errors };
 }
 
-// --- Matching (per RFC 9309) ---
+// --- Matching ---
+
+// RFC 9309 §2.2.2: decode only unreserved ASCII; preserve reserved escapes on both sides.
+function normalizePath(path: string): string {
+  return path.replace(/%[0-9a-f]{2}|\P{ASCII}/giu, (part) => {
+    if (part.startsWith("%")) {
+      const decoded = String.fromCharCode(Number.parseInt(part.slice(1), 16));
+      return /^[a-z0-9._~-]$/i.test(decoded) ? decoded : part.toUpperCase();
+    }
+    return encodeURIComponent(part.toWellFormed());
+  });
+}
 
 function pathMatches(pattern: string, path: string): boolean {
   if (!pattern) return false;
 
-  // RFC 9309 §2.2.2: decode percent-encoded characters for comparison
-  try {
-    path = decodeURIComponent(path);
-  } catch {
-    // malformed encoding, use as-is
-  }
+  path = normalizePath(path);
+  pattern = normalizePath(pattern);
 
   let regex = "^";
   for (let i = 0; i < pattern.length; i++) {
@@ -231,7 +238,7 @@ export function isAllowed(
 
   for (const rule of matchedRules) {
     if (pathMatches(rule.path, path)) {
-      const ruleLength = rule.path.length;
+      const ruleLength = normalizePath(rule.path).length;
       if (ruleLength > bestLength || (ruleLength === bestLength && rule.type === "allow")) {
         bestRule = rule;
         bestLength = ruleLength;
@@ -278,14 +285,15 @@ export async function fetchRobotsTxt(origin: string): Promise<{ robotsTxt: Robot
     redirect: "follow",
   });
 
-  // RFC 9309: 4xx (except 429) = no restrictions (allow all)
-  // 5xx and 429 = assume complete disallow
+  // RFC 9309 §§2.3.1.3–4 distinguish unavailable (4xx) from unreachable (5xx).
+  // Pagesight treats 429 conservatively; Google also excludes it from the allow-on-4xx rule.
+  // https://developers.google.com/search/docs/crawling-indexing/robots/robots_txt#handling-http-status-codes
   if (res.status >= 500 || res.status === 429) {
     const disallowAll: RobotsTxt = {
       groups: [{ userAgents: ["*"], rules: [{ type: "disallow", path: "/" }] }],
       sitemaps: [],
       raw: "",
-      errors: [`Server returned ${res.status} — treating as full disallow per RFC 9309`],
+      errors: [`Server returned ${res.status} — treating as full disallow`],
     };
     return { robotsTxt: disallowAll, statusCode: res.status };
   }

package/src/web/sitemap-inventory.ts

@@ -0,0 +1,64 @@
+import { RequestError } from "../shared/http.js";
+import { parseInventorySitemap } from "./sitemap-parser.js";
+import { fetchText } from "./fetch.js";
+
+export async function observeSitemap(url: string) {
+  const origin = new URL(url).origin;
+  const queue = [url];
+  const scheduled = new Set(queue);
+  let omittedChildReferences = 0;
+  const visited = new Set<string>();
+  const urls = new Set<string>();
+  const documents: Array<{ url: string; status: number; sha256: string; bytes: number }> = [];
+  const errors: Array<{ url: string; code: string }> = [];
+  const futureLastmods = new Set<string>();
+  const today = new Date().toISOString().slice(0, 10);
+  let bytes = 0;
+  while (queue.length && visited.size < 5 && bytes < 8_000_000) {
+    const next = queue.shift();
+    if (!next || visited.has(next)) continue;
+    visited.add(next);
+    try {
+      if (new URL(next).origin !== origin)
+        throw new RequestError("Child sitemap is outside the site origin", null, "outside_origin");
+      const page = await fetchText(next, 8_000_000 - bytes, origin);
+      if (!page.response.ok) throw new RequestError("Sitemap fetch failed", page.response.status);
+      bytes += Buffer.byteLength(page.body);
+      const parsed = parseInventorySitemap(page.body);
+      documents.push({
+        url: page.finalUrl,
+        status: page.response.status,
+        bytes: Buffer.byteLength(page.body),
+        sha256: Bun.CryptoHasher.hash("sha256", page.body, "hex"),
+      });
+      for (const child of parsed.children) {
+        if (scheduled.has(child)) continue;
+        if (scheduled.size >= 5) {
+          omittedChildReferences++;
+          continue;
+        }
+        scheduled.add(child);
+        queue.push(child);
+      }
+      for (const item of parsed.urls) urls.add(item);
+      for (const lastmod of parsed.lastmods) if (lastmod.slice(0, 10) > today) futureLastmods.add(lastmod);
+    } catch (error) {
+      errors.push({ url: next, code: error instanceof RequestError ? error.code : "fetch_failed" });
+    }
+  }
+  return {
+    sitemap: url,
+    complete: queue.length === 0 && errors.length === 0 && omittedChildReferences === 0,
+    documents,
+    urls: [...urls],
+    urlCount: urls.size,
+    bytes,
+    unvisited: queue,
+    omittedChildReferences,
+    errors,
+    futureLastmods: [...futureLastmods],
+    warnings: [
+      "Sitemap membership is not indexing evidence. Inventory is limited to five same-origin XML documents and 8 MB.",
+    ],
+  };
+}

package/src/web/sitemap-parser.ts

@@ -0,0 +1,59 @@
+import { SaxesParser, type SaxesTagNS } from "saxes";
+import { RequestError } from "../shared/http.js";
+
+export function parseInventorySitemap(xml: string) {
+  const parser = new SaxesParser({ xmlns: true });
+  const stack: SaxesTagNS[] = [];
+  const urls: string[] = [];
+  const children: string[] = [];
+  const lastmods: string[] = [];
+  let root = "";
+  let text = "";
+  let locations = 0;
+  const invalid = () => {
+    throw new RequestError("Expected well-formed sitemap XML", null, "invalid_sitemap");
+  };
+  parser.on("error", invalid);
+  parser.on("doctype", invalid);
+  parser.on("opentag", (tag) => {
+    stack.push(tag);
+    if (stack.length === 1) {
+      root = tag.local;
+      if (tag.prefix)
+        throw new RequestError(
+          "Prefixed sitemap XML is not supported by this inventory reader",
+          null,
+          "unsupported_sitemap",
+        );
+      if (
+        !["urlset", "sitemapindex"].includes(root) ||
+        (tag.uri && tag.uri !== "http://www.sitemaps.org/schemas/sitemap/0.9")
+      )
+        invalid();
+    }
+    if (stack.length === 2) {
+      if (tag.local !== (root === "urlset" ? "url" : "sitemap") || tag.uri !== stack[0].uri) invalid();
+      locations = 0;
+    }
+    if (stack.length === 3) text = "";
+    if (stack.length > 3 && ["loc", "lastmod"].includes(stack[2].local) && stack[2].uri === stack[0].uri) invalid();
+  });
+  const append = (value: string) => {
+    if (stack.length === 3) text += value;
+  };
+  parser.on("text", append);
+  parser.on("cdata", append);
+  parser.on("closetag", (tag) => {
+    if (stack.length === 3 && tag.uri === stack[0].uri) {
+      if (tag.local === "loc") {
+        if (++locations !== 1 || !text.trim()) invalid();
+        (root === "urlset" ? urls : children).push(text.trim());
+      }
+      if (tag.local === "lastmod") lastmods.push(text.trim());
+    }
+    if (stack.length === 2 && locations !== 1) invalid();
+    stack.pop();
+  });
+  parser.write(xml).close();
+  return { urls, children, lastmods };
+}