@v1nvn/readability-mcp 0.14.0

package/dist/assets/extract-BKl4PzEI.js

@@ -0,0 +1,2734 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { Readability, isProbablyReaderable } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+import { readFileSync } from "node:fs";
+import { stringify } from "yaml";
+import DOMPurify from "dompurify";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+var package_default = {
+	name: "@v1nvn/readability-mcp",
+	version: "0.14.0",
+	description: "MCP server that turns rendered (post-JS) HTML into clean Markdown + metadata via Readability, Turndown, and DOMPurify.",
+	type: "module",
+	main: "dist/index.js",
+	bin: "dist/index.js",
+	scripts: {
+		"build": "vite build",
+		"bench": "vite-node test/bench/run.ts",
+		"dev": "vite-node src/dev.ts",
+		"start": "node dist/index.js",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:update-goldens": "UPDATE_GOLDENS=1 vitest run",
+		"coverage": "vitest run --coverage"
+	},
+	keywords: [
+		"mcp",
+		"readability",
+		"markdown",
+		"turndown",
+		"model-context-protocol"
+	],
+	author: "v1nvn",
+	license: "MIT",
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/v1nvn/agentic.git",
+		"directory": "packages/readability-mcp"
+	},
+	files: ["dist"],
+	publishConfig: { "access": "public" },
+	engines: { "node": ">=22" },
+	dependencies: {
+		"@modelcontextprotocol/sdk": "^1.29.0",
+		"@mozilla/readability": "^0.6.0",
+		"dompurify": "^3.4.12",
+		"jsdom": "^29.1.1",
+		"remark-gfm": "^4.0.1",
+		"remark-parse": "^11.0.0",
+		"turndown": "^7.2.4",
+		"turndown-plugin-gfm": "^1.0.2",
+		"unified": "^11.0.5",
+		"yaml": "^2.9.0",
+		"zod": "^4.4.3"
+	},
+	devDependencies: {
+		"@types/mdast": "^4.0.4",
+		"@types/turndown": "^5.0.6",
+		"@vitest/coverage-v8": "^4.1.10",
+		"vite": "^8.1.4",
+		"vite-node": "^6.0.0",
+		"vitest": "^4.1.10"
+	}
+};
+//#endregion
+//#region src/config.ts
+var VALID_LEVELS = [
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"silent"
+];
+var LEVEL_RANK = {
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40,
+	silent: Number.MAX_SAFE_INTEGER
+};
+var DEFAULT_LOG_LEVEL = "info";
+function resolveLogLevel(env) {
+	const raw = env.READABILITY_MCP_LOG_LEVEL;
+	if (raw && VALID_LEVELS.includes(raw)) return raw;
+	return DEFAULT_LOG_LEVEL;
+}
+var SERVER_TITLE = "Readability MCP";
+var SERVER_DESCRIPTION = "Turn already-rendered (post-JavaScript) HTML into clean, LLM-friendly Markdown plus metadata, via Mozilla Readability, Turndown, and DOMPurify. Makes no outbound requests — input is the rendered HTML, read from a file path (localPath) so the page bytes never enter the model context.";
+var SERVER_INSTRUCTIONS = `Eleven always-on tools, all fed a file path (localPath) holding already-rendered HTML (e.g. document.documentElement.outerHTML written to disk by a browser/devtools capture) — except \`chunk_text\`, which operates on already-extracted text. A sampling-gated \`summarize\` adds a twelfth when (and only when) the host advertises the MCP \`sampling\` capability. The server never fetches URLs.
+
+- extract: main tool. Runs Readability to pull the article and returns Markdown + metadata + diagnostics. Use by default for article-like pages. Pass the \`chunk\` option to also emit token-bounded chunks for RAG/embedding.
+- extract_links: return a structured list of anchor links ({text, href, rel, isExternal}) from the raw DOM — hrefs absolutized against baseUrl; pairs with chrome-devtools for crawl/navigation decisions.
+- extract_list: second engine for feed/index/search/HN-style pages Readability cannot turn into one article. Returns {items:[{title,url,snippet,score}], diagnostics} — the same-shape sibling-anchor cluster with the most items wins. Reports \`detected:false\` on article pages.
+- extract_grid: detect and extract a CSS-grid / div "table" — the div equivalent of \`extract_tables\` for SPAs that render data into repeating \`<div>\` rows. Auto-detects the largest same-shape sibling group of ≥3 rows (each ≥2 cells) or takes explicit \`rowSelector\` + \`cellSelector\`; renders through the same gfm/csv/json matrix renderer.
+- extract_metadata: return only the bibliographic metadata (title, byline, siteName, lang, publishedTime, excerpt, canonical, baseUrl) without running Readability — fast pre-check for crawlers/citation.
+- extract_section: return one section by CSS selector OR heading text. Selector mode is a straight pass-through to extract’s selectors.include; heading mode spans the matched heading to the next same-or-higher level (case-insensitive, first match wins).
+- extract_tables: extract every <table> on the page (page-wide walk → gfm/csv/json), reusing the same rowspan/colspan-aware matrix serializer as the \`tables\` option on \`extract\`. Captures tables outside the article body — nav, aside, boilerplate — that the \`tables\` option never sees.
+- explain: post-mortem for an extraction — surfaces Readability’s REAL per-candidate contentScore values, the chosen root, a removed-nodes breakdown, gating/pagination signals, and the pre-Readability HTML snapshot. Same normalize + Readability path as \`extract\`, no fallback cascade/Turndown.
+- html_to_markdown: convert an arbitrary HTML fragment to Markdown with NO Readability scoring (e.g. a snippet already isolated via devtools).
+- outline: cheap heading pre-check (h1-h6 with stable anchor ids) before paying for full extraction.
+- chunk_text: split already-extracted text into token-bounded chunks (each with index, tokenCount, and nearest preceding heading) for embedding/RAG.
+
+Sampling-gated (listed only when the client advertises \`sampling\` on initialize):
+- summarize: delegate to the HOST’s model via \`sampling/createMessage\` — input {text, maxTokens?}, typically the output of \`extract\`/\`html_to_markdown\`. The server embeds no model and calls no provider directly; the host picks the model and may prompt the user first.
+
+Rounding out the surface:
+- resources: \`extract({cache:true})\` caches results as addressable \`readability://page/{hash}\` Resources; \`diagnostics.cache = {hit, normalizedHash, originalHash}\`. Re-renders that differ only in nonce/CSP/generated-id collapse to the same key (normalized-hash keying).
+
+The optional baseUrl is origin context only (absolutizes relative links); it is never fetched. Every tool returns MCP structured content (metadata, diagnostics) validated by an output schema, plus a readable payload in content[0].text. Failures surface as { isError: true } results, never thrown across the wire.`;
+function loadConfig(env = process.env) {
+	return {
+		name: "readability-mcp",
+		version: package_default.version,
+		title: SERVER_TITLE,
+		description: SERVER_DESCRIPTION,
+		instructions: SERVER_INSTRUCTIONS,
+		logLevel: resolveLogLevel(env)
+	};
+}
+function levelEnabled(config, level) {
+	return LEVEL_RANK[level] >= LEVEL_RANK[config.logLevel];
+}
+//#endregion
+//#region src/resources.ts
+var MAX_ENTRIES = 256;
+var TTL_MS = 18e5;
+var RESOURCE_SCHEME = "readability://page/";
+var entries = /* @__PURE__ */ new Map();
+function evictExpired(now) {
+	for (const [key, entry] of entries) if (entry.expiresAt <= now) entries.delete(key);
+}
+function touch(key, entry) {
+	entries.delete(key);
+	entries.set(key, entry);
+}
+function pruneToMax() {
+	while (entries.size > MAX_ENTRIES) {
+		const oldest = entries.keys().next();
+		if (oldest.done) break;
+		entries.delete(oldest.value);
+	}
+}
+function normalizeForHash(html) {
+	let s = html;
+	s = s.replace(/<script\b(?![^>]*type\s*=\s*["']application\/ld\+json["'])[^>]*>[\s\S]*?<\/script>/gi, "");
+	s = s.replace(/<script\b(?![^>]*type\s*=\s*["']application\/ld\+json["'])[^>]*\/?>/gi, "");
+	s = s.replace(/<meta\b[^>]*http-equiv=["']?content-security-policy["']?[^>]*>/gi, "");
+	s = s.replace(/\snonce\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+	s = s.replace(/\sdata-(?:v|css|svelte|h)-[a-z0-9]{6,}(?:\s*=\s*("[^"]*"|'[^']*'|[^\s>]+))?/gi, "");
+	s = s.replace(/\sid\s*=\s*(":[A-Za-z0-9_-]+:"|':[A-Za-z0-9_-]+:'|__next_[A-Za-z0-9_-]+)/g, "");
+	s = s.replace(/\sid\s*=\s*("react[A-Z]_[A-Za-z0-9_]+"|'react[A-Z]_[A-Za-z0-9_]+')/gi, "");
+	s = s.replace(/\s+/g, " ");
+	return s.trim();
+}
+function sha256(text) {
+	return createHash("sha256").update(text).digest("hex");
+}
+function normalizedHashOf(html) {
+	return sha256(normalizeForHash(html));
+}
+function originalHashOf(html) {
+	return sha256(html.trim());
+}
+function buildArgsFingerprint(args) {
+	const sel = args.selectors ? {
+		exclude: args.selectors.exclude ?? [],
+		include: args.selectors.include ?? ""
+	} : null;
+	const fp = {
+		chunk: args.chunk ? {
+			maxTokens: args.chunk.maxTokens,
+			overlap: args.chunk.overlap,
+			strategy: args.chunk.strategy
+		} : null,
+		cleanChrome: args.cleanChrome,
+		codeBlockStyle: args.codeBlockStyle,
+		debug: args.debug,
+		extraction: args.extraction,
+		format: args.format,
+		gfm: args.gfm,
+		headingStyle: args.headingStyle,
+		imageInventory: args.imageInventory,
+		images: args.images,
+		keepClasses: args.keepClasses,
+		maxChars: args.maxChars ?? null,
+		maxNodes: args.maxNodes ?? null,
+		metadataMode: args.metadataMode,
+		minArticleLength: args.minArticleLength ?? null,
+		readabilityOverrides: args.readabilityOverrides ?? null,
+		sanitize: args.sanitize,
+		selectors: sel,
+		tables: args.tables ?? null,
+		baseUrl: args.baseUrl ?? null,
+		wordsPerMinute: args.wordsPerMinute
+	};
+	return JSON.stringify(fp);
+}
+function computeHashes(html) {
+	return {
+		normalizedHash: normalizedHashOf(html),
+		originalHash: originalHashOf(html)
+	};
+}
+function combineKey(normalizedHash, argsFingerprint) {
+	return sha256(`${normalizedHash}:${argsFingerprint}`);
+}
+function lookup(html, args) {
+	const now = Date.now();
+	evictExpired(now);
+	const { normalizedHash, originalHash } = computeHashes(html);
+	const cacheKey = combineKey(normalizedHash, buildArgsFingerprint(args));
+	const entry = entries.get(cacheKey);
+	if (!entry || entry.expiresAt <= now) {
+		if (entry) entries.delete(cacheKey);
+		return;
+	}
+	touch(cacheKey, entry);
+	return {
+		entry,
+		normalizedHash,
+		originalHash
+	};
+}
+function storeResult(html, args, result) {
+	const now = Date.now();
+	evictExpired(now);
+	const { normalizedHash, originalHash } = computeHashes(html);
+	const argsFingerprint = buildArgsFingerprint(args);
+	const cacheKey = combineKey(normalizedHash, argsFingerprint);
+	const entry = {
+		argsFingerprint,
+		cacheKey,
+		contentText: result.contentText,
+		expiresAt: now + TTL_MS,
+		normalizedHash,
+		originalHash,
+		structuredContent: result.structuredContent
+	};
+	entries.set(cacheKey, entry);
+	pruneToMax();
+	return {
+		normalizedHash,
+		originalHash
+	};
+}
+function getEntryByHash(hash) {
+	for (const entry of entries.values()) if (entry.normalizedHash === hash || entry.cacheKey === hash) return entry;
+}
+function listEntries() {
+	evictExpired(Date.now());
+	return [...entries.values()];
+}
+var PAGE_CACHE_TEMPLATE = new ResourceTemplate("readability://page/{hash}", { list: () => ({ resources: listEntries().map((entry) => ({
+	description: `Cached extract for normalized hash ${entry.normalizedHash.slice(0, 12)}…`,
+	mimeType: "text/markdown",
+	name: entry.normalizedHash,
+	uri: `${RESOURCE_SCHEME}${entry.cacheKey}`
+})) }) });
+function registerCacheResources(server) {
+	return server.registerResource("page-cache", PAGE_CACHE_TEMPLATE, {
+		title: "Cached page extractions",
+		description: "Addressable cache of `extract` results called with cache:true. Each entry is keyed by the volatility-normalized hash of the HTML plus the output options; the URI path segment is the combined cache key.",
+		mimeType: "text/markdown"
+	}, (uri, variables) => {
+		const entry = getEntryByHash(String(variables.hash));
+		if (!entry) return { contents: [{
+			uri: uri.href,
+			text: ""
+		}] };
+		return { contents: [{
+			uri: uri.href,
+			mimeType: "text/markdown",
+			text: entry.contentText
+		}] };
+	});
+}
+function registerResources(server) {
+	return [registerCacheResources(server)];
+}
+//#endregion
+//#region src/errors.ts
+var ExtractionError = class extends Error {
+	cause;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "ExtractionError";
+		this.cause = options.cause;
+	}
+};
+function describeError(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+function toErrorResult(err) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: `${err instanceof ExtractionError ? err.name : "Error"}: ${describeError(err)}`
+		}]
+	};
+}
+//#endregion
+//#region src/logger.ts
+var LEVEL_LABEL = {
+	debug: "DEBUG",
+	info: "INFO",
+	warn: "WARN",
+	error: "ERROR"
+};
+function format(level, message) {
+	return `${LEVEL_LABEL[level]} ${message}`;
+}
+function emit(writer, level, message) {
+	writer(format(level, message));
+}
+var Logger = class {
+	stderr;
+	constructor(stderr = (line) => process.stderr.write(`${line}\n`)) {
+		this.stderr = stderr;
+	}
+	debug(message) {
+		if (levelEnabled(activeConfig, "debug")) emit(this.stderr, "debug", message);
+	}
+	error(message) {
+		if (levelEnabled(activeConfig, "error")) emit(this.stderr, "error", message);
+	}
+	info(message) {
+		if (levelEnabled(activeConfig, "info")) emit(this.stderr, "info", message);
+	}
+	warn(message) {
+		if (levelEnabled(activeConfig, "warn")) emit(this.stderr, "warn", message);
+	}
+};
+var activeConfig = loadConfig();
+var logger = new Logger();
+//#endregion
+//#region src/policy/markdown.ts
+var processor = unified().use(remarkParse).use(remarkGfm);
+var HEADING_MARKERS = /^#{1,6}\s+/;
+function parseBlocks(source) {
+	const tree = processor.parse(source);
+	const blocks = [];
+	for (const node of tree.children) {
+		const start = node.position?.start.offset;
+		const end = node.position?.end.offset;
+		if (start === void 0 || end === void 0) continue;
+		const kind = node.type === "code" ? "code" : node.type === "heading" ? "heading" : "other";
+		const depth = node.type === "heading" ? node.depth : 0;
+		blocks.push({
+			depth,
+			end,
+			kind,
+			start
+		});
+	}
+	return blocks;
+}
+function headingText(raw) {
+	return raw.replace(HEADING_MARKERS, "").trim();
+}
+function hardSplitLines(text, maxChars) {
+	const pieces = [];
+	let buffer = "";
+	function flush() {
+		if (buffer) {
+			pieces.push(buffer);
+			buffer = "";
+		}
+	}
+	for (const line of text.split("\n")) {
+		if (line.length > maxChars) {
+			flush();
+			for (let i = 0; i < line.length; i += maxChars) pieces.push(line.slice(i, i + maxChars));
+			continue;
+		}
+		const candidate = buffer ? `${buffer}\n${line}` : line;
+		if (candidate.length > maxChars) {
+			flush();
+			buffer = line;
+		} else buffer = candidate;
+	}
+	flush();
+	return pieces;
+}
+//#endregion
+//#region src/policy/chunk.ts
+var HEADING_FIRST_LINE = /^#{1,6}\s/;
+function splitBlocks(markdown) {
+	const parts = markdown.split(/\n{2,}/);
+	const blocks = [];
+	let heading = "";
+	for (const part of parts) {
+		const text = part.trim();
+		if (!text) continue;
+		if (HEADING_FIRST_LINE.test(text)) heading = headingText(text);
+		blocks.push({
+			headingContext: heading,
+			text
+		});
+	}
+	return blocks;
+}
+function splitOversizedBlock(block, maxChars) {
+	return hardSplitLines(block.text, maxChars).map((text) => ({
+		headingContext: block.headingContext,
+		text
+	}));
+}
+function toUnits(blocks, maxChars) {
+	const units = [];
+	for (const block of blocks) if (block.text.length <= maxChars) units.push(block);
+	else units.push(...splitOversizedBlock(block, maxChars));
+	return units;
+}
+function chunkMarkdownChar(markdown, options) {
+	if (!markdown) return [];
+	const maxChars = Math.max(1, Math.floor(options.maxTokens)) * 4;
+	const overlapTokens = Math.max(0, Math.floor(options.overlap));
+	const overlapChars = Math.min(overlapTokens * 4, maxChars - 1);
+	const blocks = splitBlocks(markdown);
+	if (blocks.length === 0) return [];
+	const units = toUnits(blocks, maxChars);
+	if (units.length === 0) return [];
+	const chunks = [];
+	let i = 0;
+	let overlapText = "";
+	let overlapHeading = "";
+	while (i < units.length) {
+		const spans = [];
+		let chunkText = "";
+		if (overlapText) {
+			chunkText = overlapText;
+			spans.push({
+				end: overlapText.length,
+				headingContext: overlapHeading,
+				start: 0
+			});
+		}
+		const firstUnit = units[i];
+		const sepLen = chunkText ? 2 : 0;
+		if (chunkText && chunkText.length + sepLen + firstUnit.text.length > maxChars) {
+			chunkText = "";
+			spans.length = 0;
+		}
+		{
+			const sep = chunkText ? "\n\n" : "";
+			const start = chunkText.length + sep.length;
+			chunkText = chunkText + sep + firstUnit.text;
+			spans.push({
+				end: chunkText.length,
+				headingContext: firstUnit.headingContext,
+				start
+			});
+			i += 1;
+		}
+		while (i < units.length) {
+			const unit = units[i];
+			const candidate = `${chunkText}\n\n${unit.text}`;
+			if (candidate.length > maxChars) break;
+			const start = chunkText.length + 2;
+			chunkText = candidate;
+			spans.push({
+				end: chunkText.length,
+				headingContext: unit.headingContext,
+				start
+			});
+			i += 1;
+		}
+		const text = chunkText.trim();
+		if (text) chunks.push({
+			headingContext: spans[0]?.headingContext ?? "",
+			index: chunks.length,
+			text,
+			tokenCount: Math.round(text.length / 4)
+		});
+		if (overlapChars > 0 && i < units.length) {
+			const overlapStart = Math.max(0, chunkText.length - overlapChars);
+			overlapHeading = (spans.find((span) => overlapStart >= span.start && overlapStart < span.end) ?? spans.find((span) => span.start >= overlapStart))?.headingContext ?? "";
+			overlapText = chunkText.slice(overlapStart).replace(/^\n+/, "");
+		} else {
+			overlapText = "";
+			overlapHeading = "";
+		}
+	}
+	return chunks;
+}
+function parseSemanticUnits(markdown) {
+	const units = [];
+	const stack = [];
+	function context() {
+		return stack.map((h) => h.text).join(" > ");
+	}
+	for (const block of parseBlocks(markdown)) {
+		const text = markdown.slice(block.start, block.end);
+		if (block.kind === "heading") {
+			while (stack.length > 0 && stack[stack.length - 1].level >= block.depth) stack.pop();
+			stack.push({
+				level: block.depth,
+				text: headingText(text)
+			});
+			units.push({
+				headingContext: context(),
+				kind: "heading",
+				text
+			});
+			continue;
+		}
+		units.push({
+			headingContext: context(),
+			kind: block.kind === "code" ? "code" : "text",
+			text
+		});
+	}
+	return units;
+}
+function groupSections(units) {
+	const sections = [];
+	let current = [];
+	let currentContext = "";
+	function flush() {
+		if (current.length > 0) {
+			sections.push({
+				headingContext: currentContext,
+				units: current
+			});
+			current = [];
+		}
+	}
+	for (const unit of units) if (unit.kind === "heading") {
+		flush();
+		current = [unit];
+		currentContext = unit.headingContext;
+	} else {
+		if (current.length === 0) currentContext = unit.headingContext;
+		current.push(unit);
+	}
+	flush();
+	return sections;
+}
+function joinedLength(units) {
+	if (units.length === 0) return 0;
+	let total = units[0].text.length;
+	for (let i = 1; i < units.length; i++) total += 2 + units[i].text.length;
+	return total;
+}
+function splitOversizedTextUnit(unit, maxChars) {
+	return hardSplitLines(unit.text, maxChars).map((text) => ({
+		headingContext: unit.headingContext,
+		kind: "text",
+		text
+	}));
+}
+function buildBaseGroups(sections, maxChars) {
+	const groups = [];
+	let current = [];
+	let currentLen = 0;
+	function emit() {
+		if (current.length > 0) {
+			groups.push(current);
+			current = [];
+			currentLen = 0;
+		}
+	}
+	function append(unit) {
+		const sep = current.length > 0 ? 2 : 0;
+		current.push(unit);
+		currentLen += sep + unit.text.length;
+	}
+	for (const section of sections) {
+		const sectionLen = joinedLength(section.units);
+		const sep = current.length > 0 ? 2 : 0;
+		if (currentLen + sep + sectionLen <= maxChars) {
+			for (const unit of section.units) append(unit);
+			continue;
+		}
+		emit();
+		if (sectionLen <= maxChars) {
+			for (const unit of section.units) append(unit);
+			continue;
+		}
+		const [headingUnit, ...body] = section.units;
+		current.push(headingUnit);
+		currentLen = headingUnit.text.length;
+		for (const unit of body) {
+			if (unit.kind === "code" && unit.text.length > maxChars) {
+				emit();
+				groups.push([unit]);
+				continue;
+			}
+			const sepNow = current.length > 0 ? 2 : 0;
+			if (unit.text.length <= maxChars && currentLen + sepNow + unit.text.length <= maxChars) {
+				append(unit);
+				continue;
+			}
+			const pieces = unit.text.length > maxChars ? splitOversizedTextUnit(unit, maxChars) : [unit];
+			for (const piece of pieces) {
+				const pieceSep = current.length > 0 ? 2 : 0;
+				if (current.length > 0 && currentLen + pieceSep + piece.text.length > maxChars) emit();
+				append(piece);
+			}
+		}
+	}
+	emit();
+	return groups;
+}
+function applySemanticOverlap(groups, overlapChars) {
+	const result = [];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		const carrier = [];
+		if (i > 0 && overlapChars > 0) {
+			const prev = groups[i - 1];
+			let end = prev.length;
+			while (end > 0 && prev[end - 1].kind === "code") end -= 1;
+			let carrierLen = 0;
+			for (let j = end - 1; j >= 0; j--) {
+				const unit = prev[j];
+				if (unit.kind !== "text") break;
+				const sep = carrier.length > 0 ? 2 : 0;
+				if (carrierLen + sep + unit.text.length > overlapChars) break;
+				carrier.unshift(unit);
+				carrierLen += sep + unit.text.length;
+			}
+		}
+		const units = carrier.length === 0 ? group : [...carrier, ...group];
+		result.push({
+			headingContext: group[0]?.headingContext ?? "",
+			units
+		});
+	}
+	return result;
+}
+function chunkMarkdownSemantic(markdown, options) {
+	if (!markdown) return [];
+	const maxChars = Math.max(1, Math.floor(options.maxTokens)) * 4;
+	const overlapTokens = Math.max(0, Math.floor(options.overlap));
+	const overlapChars = Math.min(overlapTokens * 4, maxChars - 1);
+	const units = parseSemanticUnits(markdown);
+	if (units.length === 0) return [];
+	const groups = applySemanticOverlap(buildBaseGroups(groupSections(units), maxChars), overlapChars);
+	const chunks = [];
+	for (const group of groups) {
+		if (group.units.length === 0) continue;
+		const text = group.units.map((unit) => unit.text).join("\n\n").trim();
+		if (!text) continue;
+		chunks.push({
+			headingContext: group.headingContext,
+			index: chunks.length,
+			text,
+			tokenCount: Math.round(text.length / 4)
+		});
+	}
+	return chunks;
+}
+function chunkMarkdown(markdown, options) {
+	if (options.strategy === "semantic") return chunkMarkdownSemantic(markdown, options);
+	return chunkMarkdownChar(markdown, options);
+}
+//#endregion
+//#region src/tools/schemas.ts
+var formatSchema = z.enum([
+	"html",
+	"json",
+	"markdown",
+	"text"
+]);
+var metadataModeSchema = z.enum([
+	"json",
+	"none",
+	"yaml"
+]);
+var extractionSchema = z.enum([
+	"aggressive",
+	"balanced",
+	"conservative"
+]);
+var headingStyleSchema = z.enum(["atx", "setext"]);
+var codeBlockStyleSchema = z.enum(["fenced", "indented"]);
+var imageModeSchema = z.enum([
+	"drop",
+	"keep",
+	"reference",
+	"src-only"
+]);
+var tableFormatSchema = z.enum([
+	"csv",
+	"gfm",
+	"json"
+]);
+var localPathField = z.string().describe("Absolute or relative path to a file holding the already-rendered (post-JavaScript) HTML to process, e.g. `document.documentElement.outerHTML` written to disk by a browser/devtools capture. Read by the server so the page bytes never enter the model context — only this path string does. Resolved relative to the server process working directory; the server makes no outbound requests.");
+var selectorsSchema = z.object({
+	include: z.string().optional().describe("CSS selector restricting extraction to a matching subtree (e.g. \"main\", \"article\", \".post\"). The first match replaces the document body before processing."),
+	exclude: z.array(z.string()).optional().describe("CSS selectors for boilerplate to remove before extraction (e.g. [\"nav\", \"footer\", \"[role=banner]\"]).")
+}).optional().describe("Scope the extracted/converted content by CSS selector before processing.");
+var readabilityOverridesSchema = z.record(z.string(), z.unknown()).optional().describe("Escape hatch: a record spread verbatim into the Readability options. Unstable and unvalidated; overrides the extraction/keepClasses/maxNodes/minArticleLength knobs.");
+var chunkStrategySchema = z.enum(["char", "semantic"]);
+var chunkOptionsSchema = z.object({
+	maxTokens: z.number().int().min(1).describe("Per-chunk token budget. Each chunk.text is sized so Math.round(text.length/4) stays within this bound (hard cap; oversized blocks are split by line, then hard-split)."),
+	overlap: z.number().int().min(0).describe("Tokens to overlap between consecutive chunks (>=0). The trailing overlapChars of chunk N becomes the leading context of chunk N+1, preserving cross-chunk coherence at a cost of redundant tokens.").default(0),
+	strategy: chunkStrategySchema.describe("Chunking strategy. 'semantic' (default) breaks on heading/section boundaries and never splits a fenced code block; 'char' greedily groups blank-line-separated blocks under a chars/4 token budget (may split a code block).").default("semantic")
+}).describe("Token-bounded chunking options for splitting the extracted markdown into RAG/embedding-ready slices.");
+var turndownOptionsShape = {
+	debug: z.boolean().describe("Emit per-stage timings (normalize, readability, sanitize, turndown, metadata) under diagnostics.trace. Debug-only — leaves trace absent by default.").default(false),
+	cleanChrome: z.boolean().describe("Strip browser chrome (scrollbars, consent/cookie banners, fixed nav and overlays) before conversion. These elements poison Readability density scoring and clutter fragment output.").default(true),
+	codeBlockStyle: codeBlockStyleSchema.describe("Markdown code-block style: 'fenced' (triple backticks) or 'indented' (four-space).").default("fenced"),
+	format: formatSchema.describe("Returned payload format: 'markdown' (default), 'html', 'text', or 'json' (emits {metadata, content, diagnostics}).").default("markdown"),
+	gfm: z.boolean().describe("Enable GitHub-Flavored Markdown: tables, strikethrough, and task lists.").default(true),
+	headingStyle: headingStyleSchema.describe("Markdown heading style: 'atx' (#) or 'setext' (underlining with = / -).").default("atx"),
+	images: imageModeSchema.describe("Image handling: 'keep' (inline ![alt](url)), 'drop', 'src-only' (bare URL text), or 'reference' (link-reference style).").default("keep"),
+	maxChars: z.number().int().min(0).describe("Truncate markdown/text output at a block boundary; never splits a fenced code block. Ignored for html/json formats.").optional(),
+	metadataMode: metadataModeSchema.describe("Prepend a metadata block to the markdown/text payload: 'none' (default), 'yaml', or 'json'.").default("none"),
+	sanitize: z.boolean().describe("Run DOMPurify over the extracted/fragment HTML before conversion (strips scripts, event handlers, and iframes).").default(true),
+	tables: tableFormatSchema.describe("Render <table> elements via a rowspan/colspan-aware matrix: \"gfm\" (default native GFM table), \"csv\" (RFC-4180-ish code block), or \"json\" (array of row objects keyed by the header). When unset, tables pass through Turndown's native rule unchanged.").optional(),
+	baseUrl: z.url().describe("Base URL for absolutizing relative links and images. NEVER fetched — origin context only.").optional(),
+	wordsPerMinute: z.number().int().min(1).describe("Reading speed (words per minute) used to compute metadata.readingTimeMin.").default(200)
+};
+var extractInputShape = {
+	localPath: localPathField,
+	...turndownOptionsShape,
+	cache: z.boolean().describe("When true, cache the result keyed by a normalized hash of the HTML plus the output-affecting options; repeat calls with the same normalized HTML hit the cache and report diagnostics.cache (hit/miss + both hashes). The cache is in-memory and bounded; entries are also exposed as readability://page/{hash} resources.").default(false),
+	extraction: extractionSchema.describe("Readability scoring aggressiveness: 'balanced' (default), 'aggressive', or 'conservative'. Maps to Readability's scorer knobs.").default("balanced"),
+	keepClasses: z.boolean().describe("Retain all CSS classes on extracted nodes. Defaults false, which strips non-language classes.").default(false),
+	maxNodes: z.number().int().min(0).describe("Hard cap on elements parsed (Readability maxElemsToParse). Safety/perf guard for very large documents.").optional(),
+	minArticleLength: z.number().int().min(0).describe("Minimum article character length below which extraction falls back to the selector cascade (Readability charThreshold).").optional(),
+	readabilityOverrides: readabilityOverridesSchema,
+	selectors: selectorsSchema,
+	chunk: chunkOptionsSchema.optional().describe("Split the extracted markdown into token-bounded chunks (RAG/embedding-ready). When set, structuredContent.chunks is populated. Only applies to format:\"markdown\" | \"text\"; HTML/JSON payloads carry no markdown body to slice and leave chunks unset."),
+	imageInventory: z.boolean().describe("Emit structuredContent.images: a list of {src (absolute, resolved), alt, width?, height?, caption} for every <img> in the extracted article. Independent of the `images` option (which governs inline rendering). Placeholders are skipped.").default(false)
+};
+var extractInputSchema = z.object(extractInputShape);
+var htmlToMarkdownInputShape = {
+	localPath: localPathField,
+	...turndownOptionsShape,
+	selectors: selectorsSchema
+};
+var htmlToMarkdownInputSchema = z.object(htmlToMarkdownInputShape);
+var outlineInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL, carried through to metadata.baseUrl and used to absolutize links. NEVER fetched — origin context only.").optional(),
+	selectors: selectorsSchema
+};
+var outlineInputSchema = z.object(outlineInputShape);
+var extractMetadataInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL, carried through to metadata.baseUrl and used to absolutize links. NEVER fetched — origin context only.").optional()
+};
+var extractMetadataInputSchema = z.object(extractMetadataInputShape);
+var extractLinksInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL for absolutizing relative hrefs and computing isExternal. NEVER fetched — origin context only.").optional(),
+	sameOriginOnly: z.boolean().describe("Drop cross-origin links; keep same-origin, relative, and fragment links.").default(false),
+	selectors: selectorsSchema
+};
+var extractLinksInputSchema = z.object(extractLinksInputShape);
+var chunkTextInputShape = {
+	text: z.string().describe("Already-extracted text to split (e.g. markdown from `extract` or any plain text). No HTML parsing or Readability scoring is applied — the input is chunked verbatim."),
+	maxTokens: z.number().int().min(1).describe("Per-chunk token budget. Each chunk.text is sized so Math.round(text.length/4) stays within this bound (hard cap; oversized blocks are split by line, then hard-split).").default(500),
+	overlap: z.number().int().min(0).describe("Tokens to overlap between consecutive chunks (>=0). The trailing overlapChars of chunk N becomes the leading context of chunk N+1.").default(0),
+	strategy: chunkStrategySchema.describe("Chunking strategy. 'semantic' (default) breaks on heading/section boundaries and never splits a fenced code block; 'char' greedily groups blank-line-separated blocks under a chars/4 token budget.").default("semantic")
+};
+var chunkTextInputSchema = z.object(chunkTextInputShape);
+var extractSectionInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL for absolutizing relative links and images. NEVER fetched — origin context only.").optional(),
+	selector: z.string().describe("CSS selector scoping extraction to one subtree; passed straight through as selectors.include. Provide exactly one of selector/heading.").optional(),
+	heading: z.string().describe("Heading text selecting one section; the section spans from this heading to the next same-or-higher-level heading. Case-insensitive; first match wins. Provide exactly one of selector/heading.").optional()
+};
+var extractSectionInputSchema = z.object(extractSectionInputShape).superRefine((value, ctx) => {
+	if (value.selector !== void 0 === (value.heading !== void 0)) ctx.addIssue({
+		code: "custom",
+		message: "Provide exactly one of `selector` or `heading` (both set or both unset is invalid).",
+		path: ["selector"]
+	});
+});
+var extractTablesInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL, carried through to metadata.baseUrl. NEVER fetched — origin context only.").optional(),
+	format: tableFormatSchema.describe("Output format for every table: \"gfm\" (default — native GFM table with a delimiter row), \"csv\" (RFC-4180-ish, quoted fields), or \"json\" (array of row objects keyed by the header row).").default("gfm"),
+	selectors: selectorsSchema
+};
+var extractTablesInputSchema = z.object(extractTablesInputShape);
+var extractListInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL for absolutizing item hrefs against. NEVER fetched — origin context only.").optional(),
+	selectors: selectorsSchema
+};
+var extractListInputSchema = z.object(extractListInputShape);
+var extractGridInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL, carried through to metadata.baseUrl. NEVER fetched — origin context only.").optional(),
+	format: tableFormatSchema.describe("Output format for the grid: \"gfm\" (default — native GFM table with a delimiter row), \"csv\" (RFC-4180-ish, quoted fields), or \"json\" (array of row objects keyed by the header row).").default("gfm"),
+	selectors: selectorsSchema,
+	rowSelector: z.string().describe("CSS selector for repeating row containers. When set WITH cellSelector, selector mode is used (no auto-detection). Example: '[class*=\"estimate-row\"]'.").optional(),
+	cellSelector: z.string().describe("CSS selector for cells within each row (scoped to the row subtree). Required together with rowSelector for selector mode. Example: '[class*=\"cell\"]'.").optional()
+};
+var extractGridInputSchema = z.object(extractGridInputShape).superRefine((value, ctx) => {
+	if (value.rowSelector !== void 0 !== (value.cellSelector !== void 0)) ctx.addIssue({
+		code: "custom",
+		message: "Provide both `rowSelector` and `cellSelector` for selector mode, or neither for auto-detection (setting only one is invalid).",
+		path: ["rowSelector"]
+	});
+});
+//#endregion
+//#region src/tools/output-schema.ts
+var metadataObjectSchema = z.object({
+	byline: z.string().optional().describe("Article author(s), resolved from JSON-LD, OpenGraph, <meta>, or Readability."),
+	canonical: z.string().optional().describe("Declared canonical URL from <link rel=\"canonical\"> (or og:url as fallback). Distinct from baseUrl, which is the origin context passed in."),
+	estimator: z.string().optional().describe("Name of the heuristic backing tokenEstimate (e.g. \"chars/4\")."),
+	excerpt: z.string().optional().describe("Short article summary produced by Readability."),
+	lang: z.string().optional().describe("Detected document language."),
+	publishedTime: z.string().optional().describe("Publication timestamp resolved from JSON-LD, <meta>, or <time> elements."),
+	readingTimeMin: z.number().int().optional().describe("Estimated reading time in minutes, derived from wordCount and wordsPerMinute."),
+	siteName: z.string().optional().describe("Publishing site name, resolved from OpenGraph or <meta>."),
+	structured: z.record(z.string(), z.unknown()).optional().describe("Parsed schema.org JSON-LD primary object (Recipe/Product/Event/HowTo/Article…) when present — the raw graph node with @context stripped and @type normalized to a \"+\"-joined string. Absent when the page has no recognizable structured data."),
+	title: z.string().optional().describe("Article title, resolved by priority cascade (JSON-LD → OpenGraph → Twitter → <meta> → Readability → <title>)."),
+	tokenEstimate: z.number().int().optional().describe("Rough output token count (chars/4 by default) for context budgeting."),
+	baseUrl: z.string().optional().describe("The baseUrl passed in (origin context)."),
+	wordCount: z.number().int().optional().describe("Number of whitespace-separated words in the extracted text.")
+}).describe("Resolved article metadata. Each field is the first non-empty value across a priority cascade.");
+var chunkObjectSchema = z.object({
+	index: z.number().int().min(0).describe("Zero-based chunk position within the emitted sequence."),
+	text: z.string().describe("The chunk body (markdown or text), trimmed, sized to stay within the requested token budget."),
+	tokenCount: z.number().int().min(0).describe("Estimated token count of text (chars/4), same heuristic as metadata.tokenEstimate."),
+	headingContext: z.string().describe("Nearest preceding markdown heading text in effect at the chunk’s first block. Empty string when the chunk precedes any heading; carried from the overlap source when a chunk begins with overlap text.")
+}).describe("One token-bounded slice of the extracted markdown, with its section heading for context.");
+var imageEntrySchema = z.object({
+	src: z.string().describe("Absolute (resolved) image URL, absolutized against baseUrl."),
+	alt: z.string().describe("The img alt attribute, or empty string when absent."),
+	width: z.number().int().optional().describe("Pixel dimension from the attribute, when present."),
+	height: z.number().int().optional().describe("Pixel dimension from the attribute, when present."),
+	caption: z.string().describe("figcaption text from the enclosing <figure>, else alt.")
+}).describe("One extracted image with resolved source and caption.");
+var outputSchemaShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("The human/LLM-readable payload — Markdown/html/text, or the serialized JSON when format=json."),
+	chunks: z.array(chunkObjectSchema).optional().describe("Token-bounded chunks of the extracted markdown, populated by `extract` only when the `chunk` option is set and the format yields a markdown/text body. Absent for html_to_markdown and for html/json extract formats."),
+	images: z.array(imageEntrySchema).optional().describe("Inventory of article images (absolute src, alt, dimensions, caption); populated only when imageInventory:true is passed to extract."),
+	metadata: metadataObjectSchema,
+	diagnostics: z.object({
+		boilerplateRemoved: z.number().int().optional().describe("Count of boilerplate blocks (related-posts, newsletter signup, read-next) stripped before conversion."),
+		cache: z.object({
+			hit: z.boolean().describe("True when this call was served from the in-memory cache without re-running the pipeline."),
+			normalizedHash: z.string().describe("sha256 of the volatility-normalized HTML (whitespace collapsed, scripts/nonce/CSP/generated ids stripped) — the actual cache key, shared across re-renders that differ only in volatile markup."),
+			originalHash: z.string().describe("sha256 of the raw HTML as passed (trimmed). Differs from normalizedHash when volatile markup (nonce/CSP/generated ids) was collapsed; equal when the input was already stable. Used to diagnose should-have-hit-but-didn’t misses.")
+		}).optional().describe("Cache signal — populated only by `extract` when called with cache:true. Absent otherwise (goldens, default path, and other tools never emit this field)."),
+		chromeRemoved: z.number().int().optional().describe("Count of browser-chrome nodes stripped before conversion (scrollbars, consent banners, overlays)."),
+		extractedNode: z.string().optional().describe("DOM root extraction came from: \"readability\" (main path), a fallback selector (e.g. \"article\", \"main\"), or \"fragment\" for html_to_markdown."),
+		fallbackUsed: z.boolean().describe("True if Readability parse failed and a selector cascade salvaged content. Always true for html_to_markdown."),
+		gated: z.object({
+			likely: z.boolean().describe("True when heuristics strongly suggest the content is paywalled or truncated."),
+			reason: z.string().describe("Short label naming the detected signal (e.g. \"paywall overlay\", \"metered paywall message\").")
+		}).optional().describe("Likely paywall / gating signal. The extraction may be partial; the host can re-capture after authenticating. Detection only — this server never fetches or authenticates."),
+		imagesResolved: z.number().int().optional().describe("Count of lazy/placeholder images resolved to their real src before conversion."),
+		pagination: z.object({
+			type: z.enum(["infinite", "paginated"]).describe("Kind of pagination signal detected in the document."),
+			nextUrl: z.string().optional().describe("Absolute URL of the detected next page (paginated only). Mirrors the href found in the DOM; never fetched by this server."),
+			selector: z.string().optional().describe("CSS selector of the detected load-more / infinite-scroll sentinel (infinite only).")
+		}).optional().describe("Detected pagination or infinite-scroll signal. Detection only — the host drives loading; this server never fetches."),
+		readerable: z.boolean().optional().describe("Readability isProbablyReaderable verdict on the document (extract main path only)."),
+		removedNodes: z.number().int().optional().describe("Net element count removed across the whole pipeline (delta vs. the parsed document)."),
+		sanitization: z.object({
+			iframes: z.number().int().describe("<iframe> elements removed by sanitization."),
+			scripts: z.number().int().describe("<script> and event-handler nodes removed by sanitization.")
+		}).optional().describe("Counts of nodes removed by DOMPurify sanitization."),
+		truncated: z.boolean().describe("True if the payload was truncated by maxChars."),
+		trace: z.array(z.object({
+			stage: z.string().describe("Pipeline stage name (e.g. \"normalize\", \"readability\", \"sanitize\", \"turndown\", \"metadata\")."),
+			ms: z.number().describe("Wall-clock duration of the stage in milliseconds, measured via performance.now().")
+		}).describe("One timed pipeline stage.")).optional().describe("Per-stage timings emitted only when debug:true is passed to extract/html_to_markdown. Stages are non-overlapping and ordered; absent otherwise.")
+	}).describe("Pipeline telemetry describing what was extracted, sanitized, and removed.")
+};
+z.object(outputSchemaShape);
+var outlineOutputShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("Indented-bullet table of contents, one line per heading, nested by depth."),
+	outline: z.array(z.object({
+		level: z.number().int().min(1).max(6).describe("Heading level (1–6)."),
+		text: z.string().describe("Heading text content."),
+		anchor: z.string().describe("Stable anchor id: the heading own id, a descendant permalink fragment, or a slug of the text (deduped -1, -2, … for generated slugs).")
+	}).describe("A single document heading with its stable anchor.")).describe("Document headings (h1–h6) in document order, each with a stable anchor id."),
+	metadata: z.object({
+		title: z.string().optional().describe("Document title from <title>, falling back to the first <h1>."),
+		baseUrl: z.string().optional().describe("The baseUrl passed in (origin context, never fetched).")
+	}).describe("Outline document metadata.")
+};
+z.object(outlineOutputShape);
+var extractMetadataOutputShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("Human-readable key:value rendering of the metadata block, so content[0].text is never empty."),
+	metadata: metadataObjectSchema
+};
+z.object(extractMetadataOutputShape);
+var chunkTextOutputShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("Readable index of the chunks (one numbered section per chunk, each prefixed with its heading context), so content[0].text is always scannable."),
+	chunks: z.array(chunkObjectSchema).describe("The emitted chunks in order. Empty array when the input contains no non-whitespace content.")
+};
+z.object(chunkTextOutputShape);
+var linkObjectSchema = z.object({
+	text: z.string().describe("Anchor text content, whitespace-collapsed and trimmed (capped at 300 chars)."),
+	href: z.string().describe("Absolute href (resolved against baseUrl when provided); unchanged when baseUrl is absent or the pair fails to parse."),
+	rel: z.string().describe("The raw rel attribute value (e.g. \"noopener noreferrer\", \"nofollow\"), or the empty string when absent."),
+	isExternal: z.boolean().describe("True when baseUrl is provided and the href parses to a different origin than baseUrl. False for relative, fragment, same-origin, non-http(s) (mailto/tel/javascript), and malformed hrefs.")
+}).describe("A single anchor link with its text, absolute href, rel, and origin.");
+var extractLinksOutputShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("Readable rendering of the link list (one `- [text](href)` line per link), so content[0].text is never empty."),
+	links: z.array(linkObjectSchema).describe("Anchors in document order, hrefs absolutized against baseUrl. No deduplication."),
+	metadata: z.object({ baseUrl: z.string().optional().describe("The baseUrl passed in (origin context, never fetched).") }).describe("Extract-links document metadata.")
+};
+z.object(extractLinksOutputShape);
+var tableEntrySchema = z.object({
+	index: z.number().int().min(0).describe("0-based position among emitted tables."),
+	rows: z.number().int().min(0).describe("Row count of the matrix (after rowspan/colspan resolution)."),
+	cols: z.number().int().min(0).describe("Column count of the matrix (after colspan resolution)."),
+	markdown: z.string().describe("The table rendered in the requested format (gfm/csv/json).")
+}).describe("One extracted table with its dimensions and rendered form.");
+var extractTablesOutputShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("All tables rendered in the requested format, joined by blank lines; \"(no tables found)\" when none."),
+	tables: z.array(tableEntrySchema).describe("Every <table> on the page (rowspan/colspan-resolved), in document order."),
+	metadata: z.object({
+		baseUrl: z.string().optional().describe("The baseUrl passed in (origin context)."),
+		format: tableFormatSchema.describe("The requested render format."),
+		tableCount: z.number().int().describe("Number of tables emitted.")
+	}).describe("Tables-tool metadata.")
+};
+z.object(extractTablesOutputShape);
+var gridEntrySchema = z.object({
+	rows: z.number().int().min(0).describe("Row count of the detected grid (after ragged-row padding)."),
+	cols: z.number().int().min(0).describe("Column count of the detected grid (max cell width across rows)."),
+	markdown: z.string().describe("The grid rendered in the requested format (gfm/csv/json).")
+}).describe("One detected grid with its dimensions and rendered form.");
+var extractGridOutputShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("The grid rendered in the requested format, or \"(no repeating grid found)\" when no grid is detected."),
+	grid: gridEntrySchema.describe("The detected grid (dimensions + rendered markdown). Rows/cols are 0 and markdown is empty when nothing is detected."),
+	diagnostics: z.object({
+		confidence: z.enum([
+			"high",
+			"low",
+			"medium"
+		]).describe("`high` when ≥6 detected data rows, `medium` when ≥3 (minRows), `low` otherwise. Counts the detected cluster only — a recovered header row is inference and does not raise it. `low` for non-grid pages."),
+		containerSelector: z.string().describe("CSS-ish hint (tag#id.class) of the winning container, or the rowSelector in selector mode. Empty when not detected."),
+		detected: z.boolean().describe("True when a repeating grid was found (≥3 same-shape sibling rows each with ≥2 direct element-children, outside nav/header/footer/aside)."),
+		rowCount: z.number().int().describe("Number of rows emitted, including any recovered header row. 0 when not detected."),
+		colCount: z.number().int().describe("Number of columns (max cell width across rows). 0 when not detected."),
+		rowTag: z.string().describe("Uppercase DOM tag name of the repeating row container (e.g. \"DIV\", \"TR\", \"LI\"). Empty when not detected."),
+		note: z.string().describe("Short human-readable status: the detection reason when detected, or the rejection reason when not.")
+	}).describe("Grid-detection telemetry describing the winning candidate."),
+	metadata: z.object({
+		baseUrl: z.string().optional().describe("The baseUrl passed in (origin context, never fetched)."),
+		format: tableFormatSchema.describe("The requested render format."),
+		detected: z.boolean().describe("Mirrors diagnostics.detected.")
+	}).describe("Extract-grid document metadata.")
+};
+z.object(extractGridOutputShape);
+var listItemSchema = z.object({
+	score: z.number().int().describe("Item substance score: primary-anchor text length + non-link body text length. Long titles (real feed items) score higher than short nav labels; items with both a long title and surrounding body text (snippets, excerpts) score highest."),
+	snippet: z.string().describe("Item body text with the title peeled off, whitespace-collapsed and clipped at 200 chars. Empty when the item is title-only."),
+	title: z.string().describe("Primary anchor text (longest-text <a> in the item, whitespace-collapsed). Always non-empty for emitted items."),
+	url: z.string().describe("Absolute href of the primary anchor, resolved against baseUrl. Always non-empty for emitted items.")
+}).describe("One detected list item with its title, URL, snippet, and score.");
+var extractListOutputShape = {
+	schemaVersion: z.literal(1).describe("Structured-content schema version. Bumps only on breaking shape changes to this object."),
+	content: z.string().describe("Readable rendering of the items (one numbered `title — url` line per item, each followed by an indented snippet), or a single `not a list: …` line when no list structure is detected."),
+	items: z.array(listItemSchema).describe("Detected list items in document order. Empty when the page has no repeated same-shape sibling structure with anchors (e.g. article pages)."),
+	diagnostics: z.object({
+		confidence: z.enum([
+			"high",
+			"low",
+			"medium"
+		]).describe("`high` when ≥6 items and avg score ≥30, `medium` when ≥3 items, `low` otherwise. `low` for non-list pages."),
+		containerSelector: z.string().describe("CSS-ish hint (tag#id.class) of the winning container. Empty when not detected."),
+		detected: z.boolean().describe("True when a list/feed/index structure was found (≥3 same-shape siblings each with a navigation anchor, outside nav/header/footer/aside)."),
+		itemCount: z.number().int().describe("Number of items emitted. 0 when not detected."),
+		itemTag: z.string().describe("Uppercase DOM tag name of the winning sibling group (e.g. \"TR\", \"LI\", \"ARTICLE\", \"DIV\"). Empty when not detected."),
+		note: z.string().describe("Short human-readable status: the detection reason when detected, or the rejection reason when not.")
+	}).describe("List-detection telemetry describing the winning candidate."),
+	metadata: z.object({ baseUrl: z.string().optional().describe("The baseUrl passed in (origin context, never fetched).") }).describe("Extract-list document metadata.")
+};
+z.object(extractListOutputShape);
+//#endregion
+//#region src/pipeline/dom.ts
+function buildDocument(html, baseUrl) {
+	const dom = new JSDOM(html, { url: baseUrl });
+	return {
+		document: dom.window.document,
+		window: dom.window
+	};
+}
+function isElement(node) {
+	return node.nodeType === 1;
+}
+//#endregion
+//#region src/policy/math.ts
+var MARKER_CLASS = "rdrm-math";
+var DISPLAY_ATTR = "data-display";
+var KATEX_CLASS = "katex";
+var KATEX_DISPLAY_CLASS = "katex-display";
+var TEX_ANNOTATION_SELECTOR = "annotation[encoding=\"application/x-tex\"]";
+var MATHJAX_INLINE_TYPE = "math/tex";
+var MATHJAX_DISPLAY_TYPE = "math/tex; mode=display";
+var MATHML_DISPLAY_SELECTOR = ".ltx_equation, .ltx_displaymath, .equation-display, .math-display";
+var BROKEN_PLACEHOLDER = "[?]";
+function createMarker(document, tex, display) {
+	const marker = document.createElement("span");
+	marker.className = MARKER_CLASS;
+	marker.setAttribute(DISPLAY_ATTR, display ? "true" : "false");
+	marker.textContent = tex;
+	return marker;
+}
+function convertAnnotations(document) {
+	const annotations = document.querySelectorAll(TEX_ANNOTATION_SELECTOR);
+	for (const annotation of Array.from(annotations)) {
+		if (!annotation.isConnected) continue;
+		try {
+			const katex = annotation.closest(`.${KATEX_CLASS}`);
+			const math = annotation.closest("math");
+			let container = annotation;
+			let display = false;
+			if (katex) {
+				container = katex;
+				display = katex.closest(`.${KATEX_DISPLAY_CLASS}`) !== null;
+			} else if (math) {
+				container = math;
+				display = math.getAttribute("display") === "block" || math.closest(MATHML_DISPLAY_SELECTOR) !== null;
+			}
+			const tex = annotation.textContent.trim() || (math?.getAttribute("alttext") ?? "").trim();
+			container.replaceWith(createMarker(document, tex || BROKEN_PLACEHOLDER, display));
+		} catch {
+			annotation.replaceWith(createMarker(document, BROKEN_PLACEHOLDER, false));
+		}
+	}
+}
+function convertOrphanedKatex(document) {
+	for (const katex of Array.from(document.getElementsByClassName(KATEX_CLASS))) {
+		if (!katex.isConnected) continue;
+		try {
+			const display = katex.closest(`.${KATEX_DISPLAY_CLASS}`) !== null;
+			katex.replaceWith(createMarker(document, BROKEN_PLACEHOLDER, display));
+		} catch {}
+	}
+}
+function convertMathJax(document) {
+	const scripts = document.querySelectorAll(`script[type="${MATHJAX_INLINE_TYPE}"], script[type="${MATHJAX_DISPLAY_TYPE}"]`);
+	for (const script of Array.from(scripts)) {
+		if (!script.isConnected) continue;
+		try {
+			const display = (script.getAttribute("type") ?? "").includes("mode=display");
+			const tex = script.textContent.trim();
+			script.replaceWith(createMarker(document, tex || BROKEN_PLACEHOLDER, display));
+		} catch {
+			script.replaceWith(createMarker(document, BROKEN_PLACEHOLDER, false));
+		}
+	}
+}
+function extractMath(document) {
+	convertAnnotations(document);
+	convertOrphanedKatex(document);
+	convertMathJax(document);
+}
+//#endregion
+//#region src/policy/resolver.ts
+var DEFAULT_CHAR_THRESHOLD = 500;
+var DEFAULT_N_TOP_CANDIDATES = 5;
+var CLASSES_TO_PRESERVE = [
+	"hljs",
+	"language-asm",
+	"language-assembly",
+	"language-bash",
+	"language-c",
+	"language-clojure",
+	"language-cpp",
+	"language-cs",
+	"language-csharp",
+	"language-css",
+	"language-dart",
+	"language-diff",
+	"language-dockerfile",
+	"language-elixir",
+	"language-erlang",
+	"language-go",
+	"language-graphql",
+	"language-haskell",
+	"language-html",
+	"language-ini",
+	"language-java",
+	"language-javascript",
+	"language-js",
+	"language-jsx",
+	"language-json",
+	"language-kotlin",
+	"language-lisp",
+	"language-lua",
+	"language-md",
+	"language-markdown",
+	"language-objc",
+	"language-objectivec",
+	"language-perl",
+	"language-php",
+	"language-plaintext",
+	"language-powershell",
+	"language-py",
+	"language-python",
+	"language-r",
+	"language-rb",
+	"language-rs",
+	"language-ruby",
+	"language-rust",
+	"language-scala",
+	"language-sh",
+	"language-shell",
+	"language-sql",
+	"language-swift",
+	"language-text",
+	"language-toml",
+	"language-ts",
+	"language-tsx",
+	"language-typescript",
+	"language-vim",
+	"language-wasm",
+	"language-xml",
+	"language-yaml",
+	"language-yml",
+	"rdrm-math"
+];
+var KNOWN_LANGUAGE_TOKENS = new Set(CLASSES_TO_PRESERVE.filter((c) => c.startsWith("language-")).map((c) => c.slice(9)));
+function knobsForMode(mode) {
+	switch (mode) {
+		case "aggressive": return {
+			charThreshold: Math.round(DEFAULT_CHAR_THRESHOLD / 2),
+			nbTopCandidates: 10
+		};
+		case "balanced": return null;
+		case "conservative": return {
+			charThreshold: DEFAULT_CHAR_THRESHOLD * 2,
+			nbTopCandidates: Math.max(1, Math.round(DEFAULT_N_TOP_CANDIDATES / 2))
+		};
+	}
+}
+function resolveReadabilityOptions(input) {
+	const modeKnobs = knobsForMode(input.extraction ?? "balanced");
+	const keepClasses = input.keepClasses ?? false;
+	const charThreshold = input.minArticleLength !== void 0 ? input.minArticleLength : modeKnobs?.charThreshold;
+	const nbTopCandidates = modeKnobs?.nbTopCandidates;
+	return {
+		classesToPreserve: keepClasses ? [] : [...CLASSES_TO_PRESERVE],
+		keepClasses,
+		...charThreshold !== void 0 ? { charThreshold } : {},
+		...nbTopCandidates !== void 0 ? { nbTopCandidates } : {},
+		...input.maxNodes !== void 0 ? { maxElemsToParse: input.maxNodes } : {},
+		...input.readabilityOverrides ?? {}
+	};
+}
+//#endregion
+//#region src/pipeline/normalize.ts
+var NONCE_ATTR = "nonce";
+function normalizeDocument(document, options) {
+	extractMath(document);
+	const baseEls = document.querySelectorAll("base");
+	const scriptEls = document.querySelectorAll("script:not([type=\"application/ld+json\"])");
+	baseEls.forEach((el) => {
+		el.remove();
+	});
+	scriptEls.forEach((el) => {
+		el.remove();
+	});
+	document.querySelectorAll(`[${NONCE_ATTR}]`).forEach((el) => {
+		el.removeAttribute(NONCE_ATTR);
+	});
+	const chromeRemoved = options?.cleanChrome === false ? 0 : stripChrome(document);
+	return {
+		boilerplateRemoved: stripBoilerplate(document),
+		chromeRemoved,
+		iframes: 0,
+		scripts: scriptEls.length
+	};
+}
+var CONSENT_SELECTORS = [
+	"[role=\"dialog\"]",
+	"[aria-modal=\"true\"]",
+	"#onetrust-banner-sdk",
+	"#onetrust-consent-sdk",
+	"#onetrust-pc-sdk",
+	".cc-window",
+	".cc-banner",
+	".cc-revoke",
+	".osano-cm-window",
+	".osano-cm-dialog",
+	".qc-cmp2-container",
+	".qc-cmp-ui-container",
+	"#sp_message_container",
+	"[id^=\"sp_message_container_\"]",
+	"#didomi-host",
+	".didomi-popup-container",
+	"#truste-consent-track",
+	"#consent_blackbar",
+	"#cookie-banner",
+	".cookie-banner",
+	"#consent-banner",
+	".consent-banner",
+	".cookie-bar",
+	".gdpr-banner",
+	".privacy-banner"
+];
+function isFullViewportOverlay(style) {
+	if (!/position\s*:\s*(?:fixed|sticky)/i.test(style)) return false;
+	const zIndexMatch = /z-index\s*:\s*(\d+)/i.exec(style);
+	if (!zIndexMatch || Number.parseInt(zIndexMatch[1], 10) < 1e3) return false;
+	if (/inset\s*:\s*0/i.test(style)) return true;
+	const widthFull = /width\s*:\s*100(?:%|vw)/i.test(style) || /left\s*:\s*0/i.test(style) && /right\s*:\s*0/i.test(style);
+	const heightFull = /height\s*:\s*100(?:%|vh)/i.test(style) || /top\s*:\s*0/i.test(style) && /bottom\s*:\s*0/i.test(style);
+	return widthFull && heightFull;
+}
+function stripChrome(document) {
+	let removed = 0;
+	const consentEls = document.querySelectorAll(CONSENT_SELECTORS.join(","));
+	for (const el of consentEls) {
+		if (!el.isConnected) continue;
+		el.remove();
+		removed++;
+	}
+	const styledEls = document.querySelectorAll("[style]");
+	for (const el of styledEls) {
+		if (!el.isConnected) continue;
+		if (isFullViewportOverlay(el.getAttribute("style") ?? "")) {
+			el.remove();
+			removed++;
+		}
+	}
+	return removed;
+}
+var BOILERPLATE_TOKENS = [
+	"newsletter",
+	"newsletter-signup",
+	"mailing-list",
+	"email-signup",
+	"subscribe-form",
+	"signup-form",
+	"related-posts",
+	"related-post",
+	"read-next",
+	"more-from",
+	"you-might-also",
+	"recommended-posts",
+	"recommended"
+];
+function signatureMatches(el) {
+	const signature = `${el.getAttribute("class") ?? ""} ${el.getAttribute("id") ?? ""}`.toLowerCase();
+	return BOILERPLATE_TOKENS.some((token) => signature.includes(token));
+}
+var BOILERPLATE_CONTAINER_TAGS = /* @__PURE__ */ new Set([
+	"ASIDE",
+	"DIV",
+	"FORM",
+	"NAV",
+	"OL",
+	"SECTION",
+	"UL"
+]);
+function stripBoilerplate(document) {
+	const limit = .25 * document.body.textContent.length;
+	let removed = 0;
+	for (const el of document.querySelectorAll("[class],[id]")) {
+		if (!el.isConnected) continue;
+		if (!BOILERPLATE_CONTAINER_TAGS.has(el.tagName)) continue;
+		if (!signatureMatches(el)) continue;
+		let ancestor = el.parentElement;
+		while (ancestor && !signatureMatches(ancestor)) ancestor = ancestor.parentElement;
+		if (ancestor) continue;
+		if (el.textContent.length >= limit) continue;
+		el.remove();
+		removed++;
+	}
+	return removed;
+}
+function applySelectors(document, selectors) {
+	if (!selectors) return;
+	if (selectors.exclude) for (const selector of selectors.exclude) document.querySelectorAll(selector).forEach((el) => {
+		el.remove();
+	});
+	if (selectors.include) {
+		const body = document.body;
+		const root = body.querySelector(selectors.include);
+		if (root && root !== body) {
+			body.innerHTML = "";
+			body.appendChild(root);
+		}
+	}
+}
+var PLACEHOLDER_TOKENS = [
+	"placeholder",
+	"blank",
+	"spacer",
+	"lazy",
+	"loading",
+	"1x1",
+	"transparent",
+	"pixel",
+	"dummy"
+];
+function isPlaceholderSrc(src) {
+	if (!src) return true;
+	if (src.startsWith("data:")) return true;
+	const lowered = src.toLowerCase();
+	return PLACEHOLDER_TOKENS.some((token) => lowered.includes(token));
+}
+function usableAttr(el, names) {
+	for (const name of names) {
+		const value = el.getAttribute(name);
+		if (value) return value;
+	}
+}
+function pickLargestSrcset(srcset) {
+	let bestUrl;
+	let bestValue = -1;
+	let firstUrl;
+	let sawDescriptor = false;
+	for (const raw of srcset.split(",")) {
+		const entry = raw.trim();
+		if (!entry) continue;
+		const splitAt = entry.search(/\s/);
+		const rawUrl = splitAt === -1 ? entry : entry.slice(0, splitAt);
+		const descriptor = splitAt === -1 ? "" : entry.slice(splitAt).trim();
+		const url = rawUrl.length >= 2 && (rawUrl.startsWith("\"") && rawUrl.endsWith("\"") || rawUrl.startsWith("'") && rawUrl.endsWith("'")) ? rawUrl.slice(1, -1) : rawUrl;
+		if (!url) continue;
+		if (firstUrl === void 0) firstUrl = url;
+		if (!descriptor) continue;
+		const value = /^(\d+(?:\.\d+)?)[wx]$/.exec(descriptor);
+		if (!value) continue;
+		sawDescriptor = true;
+		const numeric = Number.parseFloat(value[1]);
+		if (numeric > bestValue) {
+			bestValue = numeric;
+			bestUrl = url;
+		}
+	}
+	return sawDescriptor ? bestUrl : firstUrl;
+}
+function resolveFromPicture(img) {
+	const picture = img.closest("picture");
+	if (!picture) return;
+	for (const source of picture.querySelectorAll("source")) {
+		if (source.hasAttribute("media")) continue;
+		const srcset = source.getAttribute("srcset");
+		if (srcset) {
+			const url = pickLargestSrcset(srcset);
+			if (url) return url;
+		}
+	}
+}
+function resolveRealSource(img) {
+	const dataSrc = usableAttr(img, ["data-src"]);
+	if (dataSrc) return dataSrc;
+	const fromPicture = resolveFromPicture(img);
+	if (fromPicture) return fromPicture;
+	const ownSrcset = img.getAttribute("srcset");
+	if (ownSrcset) {
+		const url = pickLargestSrcset(ownSrcset);
+		if (url) return url;
+	}
+	return usableAttr(img, ["data-original", "data-lazy-src"]);
+}
+function resolveLazyImages(document) {
+	let resolved = 0;
+	for (const img of document.querySelectorAll("img")) {
+		const currentSrc = img.getAttribute("src") ?? "";
+		if (!isPlaceholderSrc(currentSrc)) continue;
+		const real = resolveRealSource(img);
+		if (real && real !== currentSrc) {
+			img.setAttribute("src", real);
+			resolved++;
+		}
+	}
+	return resolved;
+}
+var HIGHLIGHT_SOURCE_PREFIX = "highlight-source-";
+var LANGUAGE_PREFIX = "language-";
+var LANG_PREFIX = "lang-";
+var SP_PREFIX = "sp-";
+var BRUSH_RE = /brush:\s*([A-Za-z][\w-]*)/;
+var BOGUS_TOKENS = /* @__PURE__ */ new Set([
+	"",
+	"highlight",
+	"source",
+	"sp"
+]);
+function isValidToken(token) {
+	return !BOGUS_TOKENS.has(token);
+}
+function hasLanguageClass(el) {
+	for (const cls of el.classList) if (cls !== LANGUAGE_PREFIX && cls.startsWith(LANGUAGE_PREFIX)) return true;
+	return false;
+}
+function collectClassSources(pre, code) {
+	const sources = [{
+		classes: [...pre.classList],
+		raw: pre.getAttribute("class") ?? ""
+	}];
+	let depth = 0;
+	let el = pre.parentElement;
+	while (el && depth < 2) {
+		sources.push({
+			classes: [...el.classList],
+			raw: el.getAttribute("class") ?? ""
+		});
+		depth++;
+		if (el.tagName === "DIV" && [...el.classList].some((c) => c.startsWith("highlight"))) break;
+		el = el.parentElement;
+	}
+	if (code) sources.push({
+		classes: [...code.classList],
+		raw: code.getAttribute("class") ?? ""
+	});
+	return sources;
+}
+function resolveCodeToken(pre, code) {
+	const sources = collectClassSources(pre, code);
+	function findByPrefix(prefix) {
+		for (const src of sources) for (const cls of src.classes) if (cls.startsWith(prefix)) {
+			const token = cls.slice(prefix.length).toLowerCase();
+			if (isValidToken(token)) return token;
+		}
+		return null;
+	}
+	const highlightToken = findByPrefix(HIGHLIGHT_SOURCE_PREFIX);
+	if (highlightToken) return {
+		token: highlightToken,
+		fromHighlightSource: true
+	};
+	const languageToken = findByPrefix(LANGUAGE_PREFIX);
+	if (languageToken) return {
+		token: languageToken,
+		fromHighlightSource: false
+	};
+	const langToken = findByPrefix(LANG_PREFIX);
+	if (langToken) return {
+		token: langToken,
+		fromHighlightSource: false
+	};
+	for (const src of sources) for (const cls of src.classes) {
+		if (!cls.startsWith(SP_PREFIX)) continue;
+		const token = cls.slice(3).toLowerCase();
+		if (KNOWN_LANGUAGE_TOKENS.has(token)) return {
+			token,
+			fromHighlightSource: false
+		};
+	}
+	for (const src of sources) {
+		const match = BRUSH_RE.exec(src.raw);
+		if (match) {
+			const token = match[1].toLowerCase();
+			if (isValidToken(token)) return {
+				token,
+				fromHighlightSource: false
+			};
+		}
+	}
+	return null;
+}
+function canonicalizePre(pre) {
+	const code = pre.querySelector("code");
+	if (code && hasLanguageClass(code)) return false;
+	const match = resolveCodeToken(pre, code);
+	if (!match) return false;
+	let target = code;
+	if (!target) {
+		target = pre.ownerDocument.createElement("code");
+		while (pre.firstChild) target.appendChild(pre.firstChild);
+		pre.appendChild(target);
+	}
+	const classes = [`language-${match.token}`];
+	if (target.classList.contains("hljs")) classes.push("hljs");
+	target.setAttribute("class", classes.join(" "));
+	if (match.fromHighlightSource) {
+		const parent = pre.parentElement;
+		if (parent?.tagName === "DIV" && [...parent.classList].some((c) => c.startsWith("highlight"))) parent.replaceWith(pre);
+	}
+	return true;
+}
+function canonicalizeCodeBlocks(document) {
+	let count = 0;
+	for (const pre of document.querySelectorAll("pre")) {
+		if (!pre.isConnected) continue;
+		try {
+			if (canonicalizePre(pre)) count++;
+		} catch {}
+	}
+	return count;
+}
+//#endregion
+//#region src/pipeline/readability.ts
+function isReaderable(document) {
+	return isProbablyReaderable(document);
+}
+function parseArticle(document, options) {
+	const clone = document.cloneNode(true);
+	return new Readability(clone, options).parse();
+}
+//#endregion
+//#region src/policy/diagnostics.ts
+function countElements(html, window) {
+	if (!window || !html) return 0;
+	const template = window.document.createElement("div");
+	template.innerHTML = html;
+	return template.querySelectorAll("*").length;
+}
+function assembleDiagnostics(input) {
+	const articleElementCount = countElements(input.articleHtml ?? "", input.window);
+	const removedNodes = Math.max(0, (input.documentElementCount ?? 0) - articleElementCount);
+	return {
+		readerable: input.readerable,
+		extractedNode: input.extractedNode,
+		fallbackUsed: input.fallbackUsed ?? false,
+		gated: input.gated,
+		imagesResolved: input.imagesResolved,
+		pagination: input.pagination,
+		removedNodes,
+		boilerplateRemoved: input.boilerplateRemoved,
+		chromeRemoved: input.chromeRemoved,
+		sanitization: input.sanitization,
+		trace: input.trace,
+		truncated: input.truncated ?? false,
+		...input.cache ? { cache: input.cache } : {}
+	};
+}
+var TraceCollector = class {
+	enabled;
+	entries = [];
+	constructor(enabled) {
+		this.enabled = enabled;
+	}
+	collect() {
+		return this.enabled ? this.entries : void 0;
+	}
+	run(stage, fn) {
+		if (!this.enabled) return fn();
+		const start = performance.now();
+		try {
+			return fn();
+		} finally {
+			this.entries.push({
+				ms: performance.now() - start,
+				stage
+			});
+		}
+	}
+};
+//#endregion
+//#region src/policy/gating.ts
+var PAYWALL_SELECTORS = [
+	"[class*=\"paywall\"]",
+	"[id*=\"paywall\"]",
+	".piano",
+	"#piano",
+	".tp-modal",
+	".tp-active",
+	"[id*=\"piano\"]",
+	"[class*=\"piano\"]",
+	"[class*=\"subscribe-wall\"]",
+	"[id*=\"subscribe-wall\"]",
+	"[class*=\"metered-wall\"]",
+	"[id*=\"metered-wall\"]",
+	".leaky-paywall"
+];
+var METERED_TEXT_RE = /(\d+)\s*(?:free\s*)?(?:articles?|stories?)\s*(?:left|remaining)|you\s+have\s+reached\s+(?:your\s+)?(?:free\s+)?(?:article\s+|story\s+)?limit|subscribe\s+to\s+(?:continue\s+)?reading|read\s+the\s+full\s+(?:article|story)|unlock\s+(?:this|full|all)\s+(?:article|story|content)|keep\s+reading\s+with/i;
+function findPaywallOverlay(document) {
+	for (const selector of PAYWALL_SELECTORS) if (document.querySelector(selector)?.isConnected) return {
+		likely: true,
+		reason: "paywall overlay"
+	};
+}
+function findMeteredMessage(document) {
+	const text = document.body.textContent;
+	if (METERED_TEXT_RE.test(text)) return {
+		likely: true,
+		reason: "metered paywall message"
+	};
+}
+function detectGating(document) {
+	return findPaywallOverlay(document) ?? findMeteredMessage(document);
+}
+//#endregion
+//#region src/pipeline/urls.ts
+function absolutize(src, baseUrl) {
+	if (!src || !baseUrl) return src;
+	try {
+		return new URL(src, baseUrl).href;
+	} catch {
+		return src;
+	}
+}
+//#endregion
+//#region src/policy/pagination.ts
+var NEXT_LINK_TEXT_RE = /^(next(\s+page)?|older(\s+posts?)?|[›»→]|next\s*[›»→]|older\s*[›»→])$/i;
+function usableHref(href) {
+	if (!href || href === "#") return;
+	return href;
+}
+function findPaginated(document, baseUrl) {
+	const linkNext = document.querySelector("link[rel=\"next\"][href]");
+	if (linkNext) {
+		const href = usableHref(linkNext.getAttribute("href"));
+		if (href) return {
+			type: "paginated",
+			nextUrl: absolutize(href, baseUrl)
+		};
+	}
+	const aRelNext = document.querySelector("a[rel=\"next\"][href]");
+	if (aRelNext) {
+		const href = usableHref(aRelNext.getAttribute("href"));
+		if (href) return {
+			type: "paginated",
+			nextUrl: absolutize(href, baseUrl)
+		};
+	}
+	for (const anchor of document.querySelectorAll("a[href]")) {
+		const text = anchor.textContent.trim();
+		if (!text || !NEXT_LINK_TEXT_RE.test(text)) continue;
+		const href = usableHref(anchor.getAttribute("href"));
+		if (!href) continue;
+		return {
+			type: "paginated",
+			nextUrl: absolutize(href, baseUrl)
+		};
+	}
+}
+var INFINITE_ATTR_SELECTORS = [
+	"[data-load-more]",
+	"[data-infinite-scroll]",
+	"[data-pagination]",
+	"[infinite-scroll]"
+];
+var INFINITE_SUBSTRING_SELECTORS = [
+	"[class*=\"load-more\"]",
+	"[class*=\"loadmore\"]",
+	"[class*=\"infinite\"]",
+	"[id*=\"load-more\"]",
+	"[class*=\"sentinel\"]"
+];
+var LOAD_MORE_BUTTON_RE = /^(load more|show more|view more|more results|load more comments)$/i;
+function findInfinite(document) {
+	for (const selector of INFINITE_ATTR_SELECTORS) if (document.querySelector(selector)?.isConnected) return {
+		selector,
+		type: "infinite"
+	};
+	for (const selector of INFINITE_SUBSTRING_SELECTORS) if (document.querySelector(selector)?.isConnected) return {
+		selector,
+		type: "infinite"
+	};
+	for (const button of document.querySelectorAll("button")) {
+		const text = button.textContent.trim();
+		if (text && LOAD_MORE_BUTTON_RE.test(text)) return {
+			selector: "button",
+			type: "infinite"
+		};
+	}
+}
+function detectPagination(document, baseUrl) {
+	return findPaginated(document, baseUrl) ?? findInfinite(document);
+}
+//#endregion
+//#region src/tools/html-source.ts
+function readHtmlFile(localPath) {
+	const raw = readFileSync(localPath, "utf8");
+	const trimmed = raw.trim();
+	if (trimmed.length < 2 || trimmed.at(0) !== "\"" || trimmed.at(-1) !== "\"") return raw;
+	try {
+		const parsed = JSON.parse(trimmed);
+		return typeof parsed === "string" ? parsed : raw;
+	} catch {
+		return raw;
+	}
+}
+//#endregion
+//#region src/policy/cell-text.ts
+var CELL_CHROME_SELECTOR = "[aria-label], [data-tooltip], [data-toggle=\"tooltip\"], .tooltip, .badge";
+function normalize(text) {
+	return text.replace(/\s+/g, " ").trim();
+}
+function nonEmptyHrefs(cell) {
+	const anchors = cell.tagName === "A" ? [cell, ...Array.from(cell.querySelectorAll("a[href]"))] : Array.from(cell.querySelectorAll("a[href]"));
+	const hrefs = [];
+	for (const a of anchors) {
+		const href = (a.getAttribute("href") ?? "").trim();
+		if (href !== "") hrefs.push(href);
+	}
+	return hrefs;
+}
+function resolveCellText(cell) {
+	const full = normalize(cell.textContent);
+	let resolved = full;
+	if (full !== "") {
+		const clone = cell.cloneNode(true);
+		clone.querySelectorAll(CELL_CHROME_SELECTOR).forEach((el) => {
+			el.remove();
+		});
+		const stripped = normalize(clone.textContent);
+		resolved = stripped !== "" ? stripped : full;
+	}
+	if (resolved === "") {
+		const hrefs = nonEmptyHrefs(cell);
+		if (hrefs.length > 0) return hrefs.join(" ");
+	}
+	return resolved;
+}
+//#endregion
+//#region src/policy/tables.ts
+var SECTION_TAGS = /* @__PURE__ */ new Set([
+	"TBODY",
+	"TFOOT",
+	"THEAD"
+]);
+var CELL_TAGS = /* @__PURE__ */ new Set(["TD", "TH"]);
+function spanOf(cell, attr) {
+	const raw = cell.getAttribute(attr);
+	if (raw === null) return 1;
+	const parsed = Number.parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) return 1;
+	return parsed;
+}
+function collectRows(table) {
+	const rows = [];
+	for (const child of Array.from(table.children)) if (child.tagName === "TR") rows.push(child);
+	else if (SECTION_TAGS.has(child.tagName)) {
+		for (const tr of Array.from(child.children)) if (tr.tagName === "TR") rows.push(tr);
+	}
+	return rows;
+}
+function cellsOf(tr) {
+	return Array.from(tr.children).filter((child) => CELL_TAGS.has(child.tagName));
+}
+function parseTableMatrix(table) {
+	return buildCellGrid(table).map((row) => row.map((cell) => cell === null ? "" : resolveCellText(cell)));
+}
+function escapeGfmCell(text) {
+	return text.replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+}
+function renderTableGfm(matrix) {
+	if (matrix.length === 0) return "";
+	const cols = matrix[0].length;
+	const lines = [];
+	lines.push(`| ${matrix[0].map(escapeGfmCell).join(" | ")} |`);
+	lines.push(`| ${Array.from({ length: cols }, () => "---").join(" | ")} |`);
+	for (let r = 1; r < matrix.length; r++) lines.push(`| ${matrix[r].map(escapeGfmCell).join(" | ")} |`);
+	return lines.join("\n");
+}
+function escapeCsvField(text) {
+	if (/[",\r\n]/.test(text)) return `"${text.replace(/"/g, "\"\"")}"`;
+	return text;
+}
+function renderTableCsv(matrix) {
+	if (matrix.length === 0) return "";
+	return matrix.map((row) => row.map(escapeCsvField).join(",")).join("\n");
+}
+function headerKeys(header) {
+	return header.map((cell, i) => cell === "" ? `column_${i}` : cell);
+}
+function buildCellGrid(table) {
+	const rows = collectRows(table);
+	if (rows.length === 0) return [];
+	const grid = [];
+	const occupied = [];
+	let maxCols = 0;
+	for (let r = 0; r < rows.length; r++) {
+		while (grid.length <= r) {
+			grid.push([]);
+			occupied.push([]);
+		}
+		const rowCells = grid[r];
+		const rowOccupied = occupied[r];
+		let col = 0;
+		for (const cell of cellsOf(rows[r])) {
+			while (rowOccupied[col]) col++;
+			const rowspan = spanOf(cell, "rowspan");
+			const colspan = spanOf(cell, "colspan");
+			rowCells[col] = cell;
+			rowOccupied[col] = true;
+			for (let dr = 0; dr < rowspan; dr++) for (let dc = 0; dc < colspan; dc++) {
+				if (dr === 0 && dc === 0) continue;
+				const rr = r + dr;
+				while (grid.length <= rr) {
+					grid.push([]);
+					occupied.push([]);
+				}
+				const occ = occupied[rr];
+				while (occ.length <= col + dc) {
+					occ.push(false);
+					grid[rr].push(null);
+				}
+				occ[col + dc] = true;
+			}
+			col += colspan;
+			if (col > maxCols) maxCols = col;
+		}
+	}
+	const dense = [];
+	for (const row of grid) dense.push(Array.from({ length: maxCols }, (_, i) => row[i] ?? null));
+	return dense;
+}
+function isHeaderRow(tr) {
+	const cells = cellsOf(tr);
+	return cells.length > 0 && cells.every((c) => c.tagName === "TH");
+}
+function slugify(text) {
+	return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function readCellLabel(cell) {
+	return cell.getAttribute("aria-label") ?? cell.getAttribute("title") ?? cell.getAttribute("data-label");
+}
+function resolveHeaderKeys(table, matrix) {
+	if (matrix.length === 0) return [];
+	const width = matrix[0].length;
+	const keys = headerKeys(matrix[0]);
+	const rows = collectRows(table);
+	if (rows.length === 0) return keys;
+	const cellGrid = buildCellGrid(table);
+	const parents = Array.from({ length: width }, () => "");
+	const parentChildren = /* @__PURE__ */ new Map();
+	{
+		let col = 0;
+		for (const cell of cellsOf(rows[0])) {
+			const colspan = spanOf(cell, "colspan");
+			const text = resolveCellText(cell);
+			if (colspan > 1 && text) {
+				const slug = slugify(text);
+				const kids = [];
+				for (let dc = 0; dc < colspan && col + dc < width; dc++) {
+					parents[col + dc] = slug;
+					kids.push(col + dc);
+				}
+				parentChildren.set(slug, kids);
+			}
+			col += colspan;
+		}
+	}
+	const hasSubRow = rows.length > 1 && isHeaderRow(rows[1]);
+	for (let c = 0; c < width; c++) {
+		const dataCell = cellGrid[1]?.[c];
+		if (dataCell) {
+			const label = readCellLabel(dataCell);
+			if (label) {
+				keys[c] = label;
+				continue;
+			}
+		}
+		const parent = parents[c];
+		if (!parent) continue;
+		if (hasSubRow) {
+			const sub = matrix[1][c] ? slugify(matrix[1][c]) : "";
+			if (sub) {
+				keys[c] = `${parent}_${sub}`;
+				continue;
+			}
+		}
+		if (matrix[0][c] === "") {
+			const kids = parentChildren.get(parent);
+			const idx = kids ? kids.indexOf(c) + 1 : c;
+			keys[c] = `${parent}_${idx}`;
+		}
+	}
+	return keys;
+}
+function resolveJsonKeys(matrix, keys) {
+	const width = matrix[0].length;
+	if (!keys) return headerKeys(matrix[0]);
+	return Array.from({ length: width }, (_, i) => keys[i] ?? `column_${i}`);
+}
+function renderTableJson(matrix, keys) {
+	if (matrix.length < 2) return "[]";
+	const resolved = resolveJsonKeys(matrix, keys);
+	const records = [];
+	for (let r = 1; r < matrix.length; r++) {
+		const row = matrix[r];
+		const record = {};
+		for (let c = 0; c < resolved.length; c++) record[resolved[c]] = row[c] ?? "";
+		records.push(record);
+	}
+	return JSON.stringify(records, null, 2);
+}
+function renderTable(matrix, format, keys) {
+	switch (format) {
+		case "csv": return renderTableCsv(matrix);
+		case "gfm": return renderTableGfm(matrix);
+		case "json": return renderTableJson(matrix, keys);
+	}
+}
+//#endregion
+//#region src/policy/text.ts
+var TOKEN_ESTIMATOR = "chars/4";
+function estimateTokens(textContent) {
+	return {
+		tokenEstimate: Math.round(textContent.length / 4),
+		estimator: TOKEN_ESTIMATOR
+	};
+}
+function countWords(text) {
+	return (text.match(/\S+/g) ?? []).length;
+}
+function nonEmpty(value) {
+	return value?.trim() ? value : void 0;
+}
+function computeTextMetrics(text, wordsPerMinute) {
+	const wordCount = countWords(text);
+	return {
+		wordCount,
+		readingTimeMin: wordCount === 0 ? 0 : Math.max(1, Math.round(wordCount / wordsPerMinute)),
+		...estimateTokens(text)
+	};
+}
+//#endregion
+//#region src/policy/metadata.ts
+var ARTICLE_TYPES = /* @__PURE__ */ new Set([
+	"Article",
+	"BlogPosting",
+	"NewsArticle",
+	"Report",
+	"ScholarlyArticle",
+	"SocialMediaPosting",
+	"TechArticle",
+	"WebPage"
+]);
+function first(...values) {
+	for (const value of values) {
+		const picked = nonEmpty(value);
+		if (picked) return picked;
+	}
+}
+function metaProperty(document, property) {
+	return nonEmpty(document.querySelector(`meta[property="${property}"]`)?.getAttribute("content") ?? void 0);
+}
+function metaName(document, name) {
+	return nonEmpty(document.querySelector(`meta[name="${name}"]`)?.getAttribute("content") ?? void 0);
+}
+function parseJsonLd(document) {
+	const nodes = document.querySelectorAll("script[type=\"application/ld+json\"]");
+	const out = [];
+	nodes.forEach((node) => {
+		const raw = node.textContent;
+		if (!raw.trim()) return;
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		collectObjects(parsed, out);
+	});
+	return out;
+}
+function collectObjects(value, out) {
+	if (!value || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (const item of value) collectObjects(item, out);
+		return;
+	}
+	if ("@graph" in value) collectObjects(value["@graph"], out);
+	out.push(value);
+}
+function typeMatches(type) {
+	return (Array.isArray(type) ? type : [type]).some((t) => typeof t === "string" && ARTICLE_TYPES.has(t));
+}
+function pickArticleNode(candidates) {
+	if (candidates.length === 0) return;
+	return candidates.find((node) => typeMatches(node["@type"])) ?? candidates[0];
+}
+var STRUCTURED_PRIORITY = [
+	"Recipe",
+	"Product",
+	"Event",
+	"HowTo",
+	"Course",
+	"Movie",
+	"Book",
+	"MusicRecording",
+	"JobPosting",
+	"FAQPage",
+	...ARTICLE_TYPES
+];
+function nodeTypeList(node) {
+	const type = node["@type"];
+	if (Array.isArray(type)) return type.filter((t) => typeof t === "string");
+	return typeof type === "string" ? [type] : [];
+}
+function pickStructuredObject(candidates) {
+	for (const priorityType of STRUCTURED_PRIORITY) {
+		const hit = candidates.find((node) => nodeTypeList(node).includes(priorityType));
+		if (hit) return hit;
+	}
+}
+function cleanStructured(obj) {
+	const out = {};
+	for (const [key, value] of Object.entries(obj)) {
+		if (key === "@context") continue;
+		if (key === "@type") {
+			out[key] = (Array.isArray(value) ? value.filter((t) => typeof t === "string") : typeof value === "string" ? [value] : []).join("+");
+			continue;
+		}
+		out[key] = value;
+	}
+	return out;
+}
+function resolveJsonLdAuthor(author) {
+	const names = [];
+	function visit(value) {
+		if (typeof value === "string") {
+			const trimmed = value.trim();
+			if (trimmed) names.push(trimmed);
+			return;
+		}
+		if (!value || typeof value !== "object") return;
+		if (Array.isArray(value)) {
+			value.forEach(visit);
+			return;
+		}
+		const list = value["@list"];
+		if (Array.isArray(list)) {
+			list.forEach(visit);
+			return;
+		}
+		const name = value.name;
+		if (typeof name === "string") {
+			const trimmed = name.trim();
+			if (trimmed) names.push(trimmed);
+		}
+	}
+	visit(author);
+	return names.length > 0 ? names.join(", ") : void 0;
+}
+function asString(value) {
+	return typeof value === "string" ? nonEmpty(value) : void 0;
+}
+function field(obj, key) {
+	if (!obj || typeof obj !== "object" || Array.isArray(obj)) return;
+	return obj[key];
+}
+function resolveMetadata(input) {
+	const { document, readability } = input;
+	const jsonLdObjects = parseJsonLd(document);
+	const jsonLd = pickArticleNode(jsonLdObjects);
+	const structuredRaw = pickStructuredObject(jsonLdObjects);
+	const htmlLang = nonEmpty(document.documentElement.getAttribute("lang") ?? void 0);
+	const titleFromTitleTag = nonEmpty(document.title);
+	return {
+		title: first(asString(jsonLd?.headline), metaProperty(document, "og:title"), metaName(document, "twitter:title"), readability?.title ?? void 0, titleFromTitleTag),
+		byline: first(jsonLd ? resolveJsonLdAuthor(jsonLd.author) : void 0, metaProperty(document, "article:author"), metaName(document, "author"), readability?.byline ?? void 0),
+		siteName: first(asString(field(field(jsonLd, "publisher"), "name")), metaProperty(document, "og:site_name"), readability?.siteName ?? void 0),
+		lang: first(asString(jsonLd?.inLanguage), htmlLang, readability?.lang ?? void 0),
+		publishedTime: first(asString(jsonLd?.datePublished), metaProperty(document, "article:published_time"), nonEmpty(document.querySelector("time[datetime]")?.getAttribute("datetime") ?? void 0), readability?.publishedTime ?? void 0),
+		excerpt: first(asString(jsonLd?.description), metaProperty(document, "og:description"), metaName(document, "twitter:description"), metaName(document, "description"), readability?.excerpt ?? void 0),
+		canonical: first(nonEmpty(document.querySelector("link[rel=\"canonical\"]")?.getAttribute("href") ?? void 0), metaProperty(document, "og:url")),
+		baseUrl: input.baseUrl,
+		wordCount: input.wordCount,
+		readingTimeMin: input.readingTimeMin,
+		...estimateTokens(input.textContent),
+		...structuredRaw ? { structured: cleanStructured(structuredRaw) } : {}
+	};
+}
+//#endregion
+//#region src/output/format.ts
+function dropEchoedTitle(body, title) {
+	const blocks = parseBlocks(body);
+	if (blocks.length === 0) return body;
+	const first = blocks[0];
+	if (first.kind === "heading" && headingText(body.slice(first.start, first.end)) === title.trim()) return body.slice(first.end).replace(/^\n+/, "");
+	return body;
+}
+function renderMarkdown(input) {
+	const title = input.metadata.title?.trim();
+	let body = input.markdown;
+	if (title) {
+		body = dropEchoedTitle(body, title);
+		return `# ${title}\n\n${body}`.replace(/\n+$/, "\n");
+	}
+	return body.replace(/\n+$/, "\n");
+}
+var METADATA_KEYS = [
+	"title",
+	"byline",
+	"siteName",
+	"lang",
+	"publishedTime",
+	"excerpt",
+	"canonical",
+	"baseUrl",
+	"wordCount",
+	"readingTimeMin",
+	"tokenEstimate",
+	"estimator"
+];
+function pickMetadata(metadata) {
+	const picked = {};
+	for (const key of METADATA_KEYS) {
+		const value = metadata[key];
+		if (value !== void 0) picked[key] = value;
+	}
+	return picked;
+}
+function yamlFrontmatter(metadata) {
+	return `---\n${stringify(pickMetadata(metadata), { lineWidth: 0 })}---\n`;
+}
+function jsonFrontmatter(metadata) {
+	return "```json\n" + JSON.stringify(pickMetadata(metadata), null, 2) + "\n```\n";
+}
+function withFrontmatter(payload, mode, metadata) {
+	if (mode === "yaml") return `${yamlFrontmatter(metadata)}${payload}`;
+	if (mode === "json") return `${jsonFrontmatter(metadata)}\n${payload}`;
+	return payload;
+}
+function formatPayload(input) {
+	let payload;
+	switch (input.format) {
+		case "html": return input.sanitizedHtml;
+		case "json": {
+			const body = {
+				metadata: input.metadata,
+				content: input.markdown,
+				diagnostics: input.diagnostics
+			};
+			return JSON.stringify(body, null, 2);
+		}
+		case "text":
+			payload = input.textContent;
+			break;
+		default: payload = renderMarkdown(input);
+	}
+	return withFrontmatter(payload, input.metadataMode, input.metadata);
+}
+//#endregion
+//#region src/pipeline/sanitize.ts
+function countRemoved(removed, tagName) {
+	let count = 0;
+	for (const entry of removed) if ("element" in entry && entry.element.nodeName.toUpperCase() === tagName) count += 1;
+	return count;
+}
+function sanitizeHtml(dirty, window) {
+	const purify = DOMPurify(window);
+	return {
+		html: purify.sanitize(dirty),
+		iframesRemoved: countRemoved(purify.removed, "IFRAME"),
+		scriptsRemoved: countRemoved(purify.removed, "SCRIPT")
+	};
+}
+//#endregion
+//#region src/policy/footnotes.ts
+var FOOTNOTE_SIGNAL_RE = /cite_note|cite_ref|class="footnotes"|class="references"|data-footnote|role="doc-endnote|<sup\b[^>]*>\s*<a\s[^>]*href="#/i;
+var DEFINITION_CONTAINER_SELECTORS = [
+	"ol.footnotes",
+	"ol[class*=\"footnotes\"]",
+	"ol.references",
+	"ol[class*=\"references\"]",
+	"section[class*=\"footnote\"]",
+	"div[class*=\"footnote\"]",
+	"[role=\"doc-endnotes\"]",
+	"[role=\"doc-bibliography\"]"
+];
+var STANDALONE_DEF_ID_RE = /^(?:fn|cite_note|footnote|note)[:_-]/i;
+var BACKREF_LEADING_RE = /^(?:↑\s?|↩\s?|\^\s|Jump to\s*)/;
+function cleanDefText(text) {
+	return text.replace(/\s+/g, " ").trim().replace(BACKREF_LEADING_RE, "");
+}
+function collectDefinitions(document) {
+	const containers = /* @__PURE__ */ new Set();
+	const defs = /* @__PURE__ */ new Map();
+	const standaloneIds = /* @__PURE__ */ new Set();
+	for (const selector of DEFINITION_CONTAINER_SELECTORS) {
+		let matched;
+		try {
+			matched = document.querySelectorAll(selector);
+		} catch {
+			continue;
+		}
+		for (const container of Array.from(matched)) {
+			if (!containers.has(container)) containers.add(container);
+			for (const item of Array.from(container.querySelectorAll("li, [role=\"doc-endnote\"]"))) {
+				const id = item.id;
+				if (!id || defs.has(id)) continue;
+				const text = cleanDefText(item.textContent);
+				if (text) defs.set(id, text);
+			}
+		}
+	}
+	for (const li of Array.from(document.querySelectorAll("li[id]"))) {
+		const id = li.id;
+		if (!id || defs.has(id) || !STANDALONE_DEF_ID_RE.test(id)) continue;
+		const text = cleanDefText(li.textContent);
+		if (text) {
+			defs.set(id, text);
+			standaloneIds.add(id);
+		}
+	}
+	return {
+		containers,
+		defs,
+		standaloneIds
+	};
+}
+function processFootnotes(html) {
+	if (!html || !FOOTNOTE_SIGNAL_RE.test(html)) return null;
+	let document;
+	try {
+		document = buildDocument(html).document;
+	} catch {
+		return null;
+	}
+	const { containers, defs, standaloneIds } = collectDefinitions(document);
+	if (defs.size === 0) return null;
+	const refHits = [];
+	const defIdToNumber = /* @__PURE__ */ new Map();
+	for (const sup of Array.from(document.querySelectorAll("sup"))) {
+		if (!sup.isConnected) continue;
+		try {
+			const anchor = sup.querySelector("a[href^=\"#\"]");
+			if (!anchor) continue;
+			const frag = (anchor.getAttribute("href") ?? "").slice(1);
+			if (!frag || !defs.has(frag)) continue;
+			let n = defIdToNumber.get(frag);
+			if (n === void 0) {
+				n = defIdToNumber.size + 1;
+				defIdToNumber.set(frag, n);
+			}
+			refHits.push({
+				defId: frag,
+				n,
+				sup
+			});
+		} catch {}
+	}
+	if (refHits.length === 0) return null;
+	for (const { n, sup } of refHits) try {
+		sup.replaceWith(document.createTextNode(`[^${n}]`));
+	} catch {}
+	for (const container of containers) if (container.isConnected) container.remove();
+	for (const id of standaloneIds) {
+		const el = document.getElementById(id);
+		if (el?.isConnected) el.remove();
+	}
+	const numberToDefId = /* @__PURE__ */ new Map();
+	for (const [id, n] of defIdToNumber) numberToDefId.set(n, id);
+	const footnoteDefs = [];
+	for (let n = 1; n <= numberToDefId.size; n++) {
+		const id = numberToDefId.get(n);
+		if (id === void 0) break;
+		const text = defs.get(id);
+		if (text !== void 0) footnoteDefs.push(text);
+	}
+	return {
+		footnoteDefs,
+		html: document.body.innerHTML
+	};
+}
+//#endregion
+//#region src/pipeline/turndown.ts
+function toMarkdown(html, options) {
+	const service = new TurndownService({
+		bulletListMarker: "-",
+		codeBlockStyle: options?.codeBlockStyle ?? "fenced",
+		emDelimiter: "_",
+		fence: "```",
+		headingStyle: options?.headingStyle ?? "atx",
+		strongDelimiter: "**"
+	});
+	if (options?.gfm !== false) service.use(gfm);
+	const tableFormat = options?.tables;
+	if (tableFormat !== void 0) service.addRule("tableMatrix", {
+		filter: (node) => node.nodeName === "TABLE",
+		replacement: (_content, node) => {
+			const matrix = parseTableMatrix(node);
+			if (matrix.length === 0) return "";
+			const body = renderTable(matrix, tableFormat);
+			if (tableFormat === "gfm") return `\n\n${body}\n\n`;
+			return `\n\n\`\`\`${tableFormat}\n${body}\n\`\`\`\n\n`;
+		}
+	});
+	const imageMode = options?.images;
+	const baseUrl = options?.baseUrl;
+	const references = [];
+	applyImagePolicy(service, imageMode, baseUrl, references);
+	service.addRule("anchorAbsolutize", {
+		filter: "a",
+		replacement: (content, node) => {
+			const rawHref = node.getAttribute("href");
+			if (!rawHref) return content;
+			const href = absolutize(rawHref, baseUrl);
+			const title = node.getAttribute("title");
+			return `[${content}](${href}${title ? ` "${title.replace(/"/g, "\\\"")}"` : ""})`;
+		}
+	});
+	service.addRule("mathMarker", {
+		filter: (node) => node.nodeName === "SPAN" && node.classList.contains("rdrm-math"),
+		replacement: (_content, node) => {
+			const tex = node.textContent.trim();
+			if (!tex) return "";
+			return node.getAttribute("data-display") === "true" ? `$$${tex}$$` : `$${tex}$`;
+		}
+	});
+	const fnResult = processFootnotes(html);
+	const sourceHtml = fnResult?.html ?? html;
+	let body = service.turndown(sourceHtml);
+	if (fnResult) for (let n = 1; n <= fnResult.footnoteDefs.length; n++) body = body.replaceAll(`\\[^${n}\\]`, `[^${n}]`);
+	const trailingBlocks = [];
+	if (imageMode === "reference" && references.length > 0) trailingBlocks.push(references.map((ref, i) => `[img-${i + 1}]: ${ref}`).join("\n"));
+	if (fnResult && fnResult.footnoteDefs.length > 0) trailingBlocks.push(fnResult.footnoteDefs.map((def, i) => `[^${i + 1}]: ${def}`).join("\n"));
+	if (trailingBlocks.length === 0) return body;
+	return `${body.replace(/\n+$/, "")}\n\n${trailingBlocks.join("\n")}`;
+}
+function applyImagePolicy(service, mode, baseUrl, references) {
+	switch (mode) {
+		case "drop":
+			service.addRule("dropImage", {
+				filter: "img",
+				replacement: () => ""
+			});
+			break;
+		case "keep":
+		case void 0:
+			service.addRule("imageKeep", {
+				filter: "img",
+				replacement: (_content, node) => {
+					const src = absolutize(node.getAttribute("src") ?? "", baseUrl);
+					const alt = node.getAttribute("alt") ?? "";
+					return src ? `![${alt}](${src})` : "";
+				}
+			});
+			break;
+		case "reference":
+			service.addRule("imageReference", {
+				filter: "img",
+				replacement: (_content, node) => {
+					const src = absolutize(node.getAttribute("src") ?? "", baseUrl);
+					if (!src) return "";
+					references.push(src);
+					const id = references.length;
+					return `![${node.getAttribute("alt") ?? ""}][img-${id}]`;
+				}
+			});
+			break;
+		case "src-only": service.addRule("imageSrcOnly", {
+			filter: "img",
+			replacement: (_content, node) => {
+				const src = absolutize(node.getAttribute("src") ?? "", baseUrl);
+				return src ? `\n\n${src}\n\n` : "";
+			}
+		});
+	}
+}
+//#endregion
+//#region src/policy/fallback.ts
+var MIN_DENSE_BLOCK_CHARS = 200;
+function convert(element, options) {
+	const rawHtml = element.outerHTML;
+	let sanitizedHtml = rawHtml;
+	let sanitization = {
+		iframes: 0,
+		scripts: 0
+	};
+	if (options.sanitize) {
+		const res = sanitizeHtml(rawHtml, options.window);
+		sanitizedHtml = res.html;
+		sanitization = {
+			iframes: res.iframesRemoved,
+			scripts: res.scriptsRemoved
+		};
+	}
+	const markdown = toMarkdown(sanitizedHtml, {
+		codeBlockStyle: options.codeBlockStyle,
+		gfm: options.gfm,
+		headingStyle: options.headingStyle,
+		images: options.images,
+		tables: options.tables,
+		baseUrl: options.baseUrl
+	});
+	const textContent = element.textContent;
+	if (markdown.trim().length === 0) return;
+	return {
+		markdown,
+		sanitization,
+		sanitizedHtml,
+		textContent
+	};
+}
+function largestTextDenseBlock(document) {
+	let best;
+	let bestLen = 0;
+	document.querySelectorAll("div, section").forEach((el) => {
+		const len = el.textContent.trim().length;
+		if (len > bestLen && len >= MIN_DENSE_BLOCK_CHARS) {
+			best = el;
+			bestLen = len;
+		}
+	});
+	return best;
+}
+function extractViaFallback(document, options) {
+	for (const selector of [
+		"article",
+		"main",
+		"[role=main]"
+	]) {
+		const root = document.querySelector(selector);
+		if (root) {
+			const converted = convert(root, options);
+			if (converted) return {
+				...converted,
+				rootSelector: selector
+			};
+		}
+	}
+	const dense = largestTextDenseBlock(document);
+	if (dense) {
+		const converted = convert(dense, options);
+		if (converted) return {
+			...converted,
+			rootSelector: "largest-block"
+		};
+	}
+	const converted = convert(document.body, options);
+	if (converted) return {
+		...converted,
+		rootSelector: "body"
+	};
+	return null;
+}
+//#endregion
+//#region src/policy/images.ts
+function positiveInt(value) {
+	if (value === null) return;
+	const n = Number.parseInt(value, 10);
+	return Number.isInteger(n) && n > 0 ? n : void 0;
+}
+function collectImageInventory(html, window, baseUrl) {
+	if (!html) return [];
+	const probe = window.document.createElement("div");
+	probe.innerHTML = html;
+	const entries = [];
+	for (const img of probe.querySelectorAll("img")) {
+		const rawSrc = img.getAttribute("src") ?? "";
+		if (isPlaceholderSrc(rawSrc)) continue;
+		const src = absolutize(rawSrc, baseUrl);
+		if (!src) continue;
+		const alt = img.getAttribute("alt") ?? "";
+		const width = positiveInt(img.getAttribute("width"));
+		const height = positiveInt(img.getAttribute("height"));
+		const figcaption = img.closest("figure")?.querySelector("figcaption");
+		const caption = figcaption ? figcaption.textContent.replace(/\s+/g, " ").trim() : alt;
+		entries.push({
+			src,
+			alt,
+			...width !== void 0 ? { width } : {},
+			...height !== void 0 ? { height } : {},
+			caption
+		});
+	}
+	return entries;
+}
+//#endregion
+//#region src/policy/truncate.ts
+var TRUNCATION_MARKER = "\n\n…[truncated]";
+function truncateMarkdown(markdown, maxChars) {
+	if (markdown.length <= maxChars) return {
+		text: markdown,
+		truncated: false
+	};
+	const blocks = parseBlocks(markdown);
+	let start = -1;
+	let end = -1;
+	let truncated = false;
+	for (const block of blocks) {
+		const from = start === -1 ? block.start : start;
+		if (block.end - from > maxChars) {
+			if (start === -1 && block.kind !== "code") return {
+				text: (hardSplitLines(markdown.slice(block.start, block.end), maxChars)[0] ?? "").replace(/\s+$/, "") + TRUNCATION_MARKER,
+				truncated: true
+			};
+			truncated = true;
+			break;
+		}
+		if (start === -1) start = block.start;
+		end = block.end;
+	}
+	if (!truncated) return {
+		text: markdown,
+		truncated: false
+	};
+	return {
+		text: (start === -1 ? "" : markdown.slice(start, end)).replace(/\s+$/, "") + TRUNCATION_MARKER,
+		truncated: true
+	};
+}
+//#endregion
+//#region src/tools/extract.ts
+var EXTRACTED_NODE = "readability";
+function extractArticle(rawArgs) {
+	const { localPath, ...rest } = extractInputSchema.parse(rawArgs);
+	return extractArticleFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+var DEFAULTS = extractInputSchema.parse({ localPath: "" });
+function extractArticleFromHtml(input) {
+	const merged = {
+		...DEFAULTS,
+		...input
+	};
+	const { html, baseUrl, cache: useCache, selectors, extraction, minArticleLength, maxNodes, keepClasses, readabilityOverrides, format, metadataMode, gfm, headingStyle, codeBlockStyle, images, sanitize: shouldSanitize, maxChars, wordsPerMinute, cleanChrome, tables, chunk, imageInventory, debug } = merged;
+	if (useCache) {
+		const hit = lookup(html, merged);
+		if (hit) {
+			const cloned = JSON.parse(JSON.stringify(hit.entry.structuredContent));
+			const structuredContent = {
+				...cloned,
+				diagnostics: {
+					...cloned.diagnostics,
+					cache: {
+						hit: true,
+						normalizedHash: hit.normalizedHash,
+						originalHash: hit.originalHash
+					}
+				}
+			};
+			return {
+				content: [{
+					text: hit.entry.contentText,
+					type: "text"
+				}],
+				structuredContent
+			};
+		}
+	}
+	const trace = new TraceCollector(debug);
+	const { document, window } = buildDocument(html, baseUrl);
+	const { gating, documentElementCount, normalizeCounts, imagesResolved, pagination } = trace.run("normalize", () => {
+		const gating = detectGating(document);
+		const documentElementCount = document.querySelectorAll("*").length;
+		const normalizeCounts = normalizeDocument(document, { cleanChrome });
+		const imagesResolved = resolveLazyImages(document);
+		const pagination = detectPagination(document, baseUrl);
+		applySelectors(document, selectors);
+		const codeBlocksCanonicalized = canonicalizeCodeBlocks(document);
+		if (codeBlocksCanonicalized > 0) logger.debug(`canonicalized ${codeBlocksCanonicalized} code-block language tag(s)`);
+		return {
+			documentElementCount,
+			gating,
+			imagesResolved,
+			normalizeCounts,
+			pagination
+		};
+	});
+	const { readerable, article } = trace.run("readability", () => {
+		const readerable = isReaderable(document);
+		const readabilityOptions = resolveReadabilityOptions({
+			extraction,
+			keepClasses,
+			maxNodes,
+			minArticleLength,
+			readabilityOverrides
+		});
+		return {
+			article: parseArticle(document, readabilityOptions),
+			readerable
+		};
+	});
+	let markdown;
+	let sanitizedHtml;
+	let textContent;
+	let extractedNode;
+	let fallbackUsed;
+	let sanitizeCounts;
+	if (article?.content) {
+		extractedNode = EXTRACTED_NODE;
+		fallbackUsed = false;
+		textContent = article.textContent ?? "";
+		const articleHtml = article.content;
+		const sanitized = trace.run("sanitize", () => {
+			if (!shouldSanitize) return {
+				counts: {
+					iframes: 0,
+					scripts: 0
+				},
+				html: articleHtml
+			};
+			const res = sanitizeHtml(articleHtml, window);
+			return {
+				counts: {
+					iframes: res.iframesRemoved,
+					scripts: res.scriptsRemoved
+				},
+				html: res.html
+			};
+		});
+		sanitizedHtml = sanitized.html;
+		sanitizeCounts = sanitized.counts;
+		markdown = trace.run("turndown", () => toMarkdown(sanitizedHtml, {
+			codeBlockStyle,
+			gfm,
+			headingStyle,
+			images,
+			tables,
+			baseUrl
+		}));
+	} else {
+		const fallback = trace.run("fallback", () => extractViaFallback(document, {
+			codeBlockStyle,
+			gfm,
+			headingStyle,
+			images,
+			sanitize: shouldSanitize,
+			tables,
+			baseUrl,
+			window
+		}));
+		if (!fallback) throw new ExtractionError("Readability returned no article and the selector cascade yielded no usable content.");
+		extractedNode = fallback.rootSelector;
+		fallbackUsed = true;
+		markdown = fallback.markdown;
+		sanitizedHtml = fallback.sanitizedHtml;
+		textContent = fallback.textContent;
+		sanitizeCounts = fallback.sanitization;
+	}
+	const { metadata } = trace.run("metadata", () => {
+		const { wordCount, readingTimeMin } = computeTextMetrics(textContent, wordsPerMinute);
+		return { metadata: resolveMetadata({
+			document,
+			readability: article,
+			readingTimeMin,
+			textContent,
+			baseUrl,
+			wordCount
+		}) };
+	});
+	const sanitization = {
+		iframes: normalizeCounts.iframes + sanitizeCounts.iframes,
+		scripts: normalizeCounts.scripts + sanitizeCounts.scripts
+	};
+	const baseDiagnostics = assembleDiagnostics({
+		articleHtml: sanitizedHtml,
+		boilerplateRemoved: normalizeCounts.boilerplateRemoved,
+		chromeRemoved: normalizeCounts.chromeRemoved,
+		documentElementCount,
+		extractedNode,
+		fallbackUsed,
+		gated: gating,
+		imagesResolved,
+		pagination,
+		readerable,
+		sanitization,
+		trace: trace.collect(),
+		truncated: false,
+		window
+	});
+	let payload = formatPayload({
+		diagnostics: baseDiagnostics,
+		format,
+		markdown,
+		metadata,
+		metadataMode,
+		sanitizedHtml,
+		textContent
+	});
+	let truncated = false;
+	if (maxChars !== void 0 && (format === "markdown" || format === "text")) {
+		const res = truncateMarkdown(payload, maxChars);
+		payload = res.text;
+		truncated = res.truncated;
+	}
+	const diagnostics = truncated ? {
+		...baseDiagnostics,
+		truncated
+	} : baseDiagnostics;
+	const chunks = chunk && (format === "markdown" || format === "text") ? chunkMarkdown(payload, chunk) : void 0;
+	const imageInventoryEntries = imageInventory ? collectImageInventory(sanitizedHtml, window, baseUrl) : void 0;
+	const baseStructuredContent = {
+		schemaVersion: 1,
+		content: payload,
+		metadata,
+		diagnostics,
+		...chunks ? { chunks } : {},
+		...imageInventoryEntries ? { images: imageInventoryEntries } : {}
+	};
+	let structuredContent = baseStructuredContent;
+	if (useCache) {
+		const stored = storeResult(html, merged, {
+			contentText: payload,
+			structuredContent: baseStructuredContent
+		});
+		structuredContent = {
+			...baseStructuredContent,
+			diagnostics: {
+				...diagnostics,
+				cache: {
+					hit: false,
+					normalizedHash: stored.normalizedHash,
+					originalHash: stored.originalHash
+				}
+			}
+		};
+	}
+	return {
+		content: [{
+			text: payload,
+			type: "text"
+		}],
+		structuredContent
+	};
+}
+var EXTRACT_TOOL_DESCRIPTION = `Extract the main article from already-rendered (post-JavaScript) HTML and return clean Markdown plus metadata and diagnostics. The server fetches nothing: \`localPath\` (a file holding the rendered HTML, e.g. \`document.documentElement.outerHTML\` written to disk by a browser/devtools capture) is the only source, and \`baseUrl\` (optional) is used solely to absolutize relative links.`;
+function extractHandler(args) {
+	try {
+		return extractArticle(args);
+	} catch (err) {
+		logger.error(`extract failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExtractTool(server) {
+	return server.registerTool("extract", {
+		title: "Extract article to Markdown",
+		description: EXTRACT_TOOL_DESCRIPTION,
+		inputSchema: extractInputShape,
+		outputSchema: outputSchemaShape
+	}, extractHandler);
+}
+//#endregion
+export { outlineInputShape as $, extractListOutputShape as A, extractLinksInputShape as B, resolveLazyImages as C, chunkTextOutputShape as D, isElement as E, chunkTextInputSchema as F, extractSectionInputSchema as G, extractListInputShape as H, chunkTextInputShape as I, extractTablesInputShape as J, extractSectionInputShape as K, extractGridInputSchema as L, extractTablesOutputShape as M, outlineOutputShape as N, extractGridOutputShape as O, outputSchemaShape as P, outlineInputSchema as Q, extractGridInputShape as R, normalizeDocument as S, buildDocument as T, extractMetadataInputSchema as U, extractListInputSchema as V, extractMetadataInputShape as W, htmlToMarkdownInputShape as X, htmlToMarkdownInputSchema as Y, localPathField as Z, detectGating as _, sanitizeHtml as a, registerResources as at, isReaderable as b, computeTextMetrics as c, renderTable as d, selectorsSchema as et, resolveHeaderKeys as f, absolutize as g, detectPagination as h, toMarkdown as i, toErrorResult as it, extractMetadataOutputShape as j, extractLinksOutputShape as k, nonEmpty as l, readHtmlFile as m, registerExtractTool as n, logger as nt, formatPayload as o, loadConfig as ot, resolveCellText as p, extractTablesInputSchema as q, truncateMarkdown as r, ExtractionError as rt, resolveMetadata as s, extractArticleFromHtml as t, chunkMarkdown as tt, parseTableMatrix as u, TraceCollector as v, resolveReadabilityOptions as w, applySelectors as x, assembleDiagnostics as y, extractLinksInputSchema as z };
+
+//# sourceMappingURL=extract-BKl4PzEI.js.map