@v1nvn/readability-mcp 0.14.0

package/dist/index.js

@@ -0,0 +1,1425 @@
+#!/usr/bin/env node
+import { $ as outlineInputShape, A as extractListOutputShape, B as extractLinksInputShape, C as resolveLazyImages, D as chunkTextOutputShape, E as isElement, F as chunkTextInputSchema, G as extractSectionInputSchema, H as extractListInputShape, I as chunkTextInputShape, J as extractTablesInputShape, K as extractSectionInputShape, L as extractGridInputSchema, M as extractTablesOutputShape, N as outlineOutputShape, O as extractGridOutputShape, P as outputSchemaShape, Q as outlineInputSchema, R as extractGridInputShape, S as normalizeDocument, T as buildDocument, U as extractMetadataInputSchema, V as extractListInputSchema, W as extractMetadataInputShape, X as htmlToMarkdownInputShape, Y as htmlToMarkdownInputSchema, Z as localPathField, _ as detectGating, a as sanitizeHtml, at as registerResources, b as isReaderable, c as computeTextMetrics, d as renderTable, et as selectorsSchema, f as resolveHeaderKeys, g as absolutize, h as detectPagination, i as toMarkdown, it as toErrorResult, j as extractMetadataOutputShape, k as extractLinksOutputShape, l as nonEmpty, m as readHtmlFile, n as registerExtractTool, nt as logger, o as formatPayload, ot as loadConfig, p as resolveCellText, q as extractTablesInputSchema, r as truncateMarkdown, rt as ExtractionError, s as resolveMetadata, t as extractArticleFromHtml, tt as chunkMarkdown, u as parseTableMatrix, v as TraceCollector, w as resolveReadabilityOptions, x as applySelectors, y as assembleDiagnostics, z as extractLinksInputSchema } from "./assets/extract-BKl4PzEI.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { Readability } from "@mozilla/readability";
+//#region src/sampling.ts
+var SUMMARIZE_SYSTEM_PROMPT = "Summarize the user-supplied text concisely while preserving its key points, entities, and any decisive conclusions. Output only the summary prose — no preamble, no headings unless the source had them.";
+var summarizeInputShape = {
+	text: z.string().describe("The markdown or text to summarize — typically the output of `extract`, `extract_section`, `html_to_markdown`, or `chunk_text`. Passed through to the host model verbatim; the server does not parse or modify it."),
+	maxTokens: z.number().int().min(1).describe("Upper bound on the summary length in tokens, forwarded to the host as `sampling/createMessage` maxTokens. The host chooses the actual length.").default(512)
+};
+var summarizeInputSchema = z.object(summarizeInputShape);
+var SUMMARIZE_TOOL_DESCRIPTION = `Summarize text using the HOST's model via MCP \`sampling/createMessage\` — the server embeds no model and calls no provider directly. Hand it the output of \`extract\`, \`extract_section\`, \`html_to_markdown\`, or any markdown/text string; the host picks the model and may ask the user to approve the sampling request (human-in-the-loop per MCP). The tool is only listed when the connected client advertises the sampling capability.`;
+async function summarizeWithHost(server, args) {
+	const result = await server.server.createMessage({
+		messages: [{
+			role: "user",
+			content: {
+				type: "text",
+				text: args.text
+			}
+		}],
+		systemPrompt: SUMMARIZE_SYSTEM_PROMPT,
+		maxTokens: args.maxTokens
+	});
+	if (result.content.type !== "text") throw new Error(`host sampling returned non-text content (${result.content.type}); summarize expects a text response`);
+	return result.content.text;
+}
+function registerSummarizeTool(server) {
+	return server.registerTool("summarize", {
+		title: "Summarize text using the host model",
+		description: SUMMARIZE_TOOL_DESCRIPTION,
+		inputSchema: summarizeInputShape
+	}, async (rawArgs) => {
+		const args = summarizeInputSchema.parse(rawArgs);
+		try {
+			return { content: [{
+				type: "text",
+				text: await summarizeWithHost(server, args)
+			}] };
+		} catch (err) {
+			logger.error(`summarize failed: ${err instanceof Error ? err.message : String(err)}`);
+			return toErrorResult(err);
+		}
+	});
+}
+function registerSamplingTools(server) {
+	return [registerSummarizeTool(server)];
+}
+//#endregion
+//#region src/tools/chunk_text.ts
+function renderChunkIndex(chunks) {
+	if (chunks.length === 0) return "(no chunks emitted — input had no non-whitespace content)";
+	return chunks.map((chunk) => {
+		const head = chunk.headingContext ? ` [${chunk.headingContext}]` : "";
+		return `## Chunk ${chunk.index}${head}\n\n${chunk.text}`;
+	}).join("\n\n");
+}
+function chunkTextDocument(rawArgs) {
+	const { text, maxTokens, overlap, strategy } = chunkTextInputSchema.parse(rawArgs);
+	const chunks = chunkMarkdown(text, {
+		maxTokens,
+		overlap,
+		strategy
+	});
+	const content = renderChunkIndex(chunks);
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			chunks
+		}
+	};
+}
+var CHUNK_TEXT_TOOL_DESCRIPTION = `Split already-extracted text into token-bounded chunks for embedding/RAG. Each chunk carries its index, tokenCount (chars/4), and the nearest preceding markdown heading as headingContext. Operates on any text — pair with the \`chunk\` option on \`extract\` when you want chunks inline with the extraction. The server fetches nothing: \`text\` is the only input.`;
+function chunkTextHandler(args) {
+	try {
+		return chunkTextDocument(args);
+	} catch (err) {
+		logger.error(`chunk_text failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerChunkTextTool(server) {
+	return server.registerTool("chunk_text", {
+		title: "Chunk text for RAG/embedding",
+		description: CHUNK_TEXT_TOOL_DESCRIPTION,
+		inputSchema: chunkTextInputShape,
+		outputSchema: chunkTextOutputShape
+	}, chunkTextHandler);
+}
+//#endregion
+//#region src/policy/explain.ts
+var DEFAULT_SNAPSHOT_MAX = 4e3;
+var DEFAULT_TOP_N = 5;
+function describeSelector$1(parts) {
+	const idPart = parts.id ? `#${parts.id}` : "";
+	const cls = parts.className.trim().split(/\s+/).filter(Boolean).slice(0, 2).join(".");
+	const classPart = cls ? `.${cls}` : "";
+	return `${parts.tag.toLowerCase()}${idPart}${classPart}`;
+}
+function readScored(el) {
+	const score = el.readability?.contentScore;
+	if (typeof score !== "number") return null;
+	const candidate = {
+		className: typeof el.className === "string" ? el.className : "",
+		id: el.id,
+		score,
+		tag: el.tagName,
+		textLength: el.textContent.trim().length
+	};
+	return {
+		...candidate,
+		selector: describeSelector$1(candidate)
+	};
+}
+function truncateSnapshot(html, max) {
+	if (html.length <= max) return {
+		html,
+		truncated: false
+	};
+	return {
+		html: html.slice(0, max),
+		truncated: true
+	};
+}
+function buildExplainReport(options) {
+	const { html, selectors, snapshotMaxChars = DEFAULT_SNAPSHOT_MAX, topN = DEFAULT_TOP_N, baseUrl } = options;
+	const { document, window } = buildDocument(html, baseUrl);
+	const gating = detectGating(document);
+	const documentElementCount = document.querySelectorAll("*").length;
+	const normalizeCounts = normalizeDocument(document);
+	resolveLazyImages(document);
+	const pagination = detectPagination(document, baseUrl);
+	applySelectors(document, selectors);
+	const snapshot = truncateSnapshot(document.body.innerHTML, snapshotMaxChars);
+	const readerable = isReaderable(document);
+	const readabilityOptions = resolveReadabilityOptions({});
+	const clone = document.cloneNode(true);
+	const heldNodes = Array.from(clone.querySelectorAll("*"));
+	const article = new Readability(clone, readabilityOptions).parse();
+	const parseSucceeded = !!article?.content;
+	const scored = [];
+	for (const el of heldNodes) {
+		const entry = readScored(el);
+		if (entry) scored.push(entry);
+	}
+	scored.sort((a, b) => b.score - a.score);
+	const candidates = scored.slice(0, Math.max(0, topN));
+	const chosenRoot = scored[0] ?? null;
+	const diagnostics = assembleDiagnostics({
+		articleHtml: article?.content ?? "",
+		boilerplateRemoved: normalizeCounts.boilerplateRemoved,
+		chromeRemoved: normalizeCounts.chromeRemoved,
+		documentElementCount,
+		extractedNode: "readability",
+		fallbackUsed: false,
+		gated: gating,
+		pagination,
+		readerable,
+		window
+	});
+	return {
+		candidates,
+		chosenRoot,
+		fallbackUsed: diagnostics.fallbackUsed,
+		gating: diagnostics.gated,
+		pagination: diagnostics.pagination,
+		parseSucceeded,
+		readerable: diagnostics.readerable ?? false,
+		removedNodes: {
+			boilerplate: diagnostics.boilerplateRemoved ?? 0,
+			chrome: diagnostics.chromeRemoved ?? 0,
+			total: diagnostics.removedNodes ?? 0
+		},
+		snapshot
+	};
+}
+//#endregion
+//#region src/tools/explain.ts
+var explainInputShape = {
+	localPath: localPathField,
+	baseUrl: z.url().describe("Base URL for absolutizing relative links during pagination/gating detection. NEVER fetched — origin context only.").optional(),
+	selectors: selectorsSchema,
+	topN: z.number().int().min(1).max(20).describe("Maximum number of scored candidate nodes to return (highest first). Default 5.").default(5)
+};
+var explainInputSchema = z.object(explainInputShape);
+var DEFAULTS$4 = explainInputSchema.parse({ localPath: "" });
+var candidateSchema = z.object({
+	className: z.string().describe("The candidate's class attribute (raw, unsplit). Empty string when absent."),
+	id: z.string().describe("The candidate's id attribute, or empty string."),
+	score: z.number().describe("Readability's actual contentScore for this node (link-density-scaled). Higher is better; the top entry is Readability's raw top candidate before its parent-walking/only-child adjustments."),
+	selector: z.string().describe("A CSS-ish hint (tag#id.class1.class2) for locating the node in the host DOM. NOT a unique locator — Readability's score lives on a JS expando invisible to CSS."),
+	tag: z.string().describe("Uppercase DOM tag name (e.g. \"ARTICLE\", \"MAIN\", \"DIV\")."),
+	textLength: z.number().int().min(0).describe("Trimmed textContent length of the candidate node, for eyeballing content density.")
+}).describe("One scored candidate node Readability considered, with its real contentScore.");
+var explainOutputShape = {
+	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 report (chosen root, ranked candidates, removal counts, gating/pagination, snapshot head) so content[0].text is always scannable."),
+	chosenRoot: candidateSchema.nullable().describe("The highest-scoring candidate Readability computed — its raw top pick before parent-walking/only-child post-processing. Null when Readability scored nothing (e.g. empty input)."),
+	candidates: z.array(candidateSchema).describe("Scored candidate nodes (highest first), capped at topN. These are Readability's real contentScore values, not a self-computed heuristic."),
+	readerable: z.boolean().describe("Readability isProbablyReaderable verdict on the normalized document."),
+	parseSucceeded: z.boolean().describe("True when reader.parse() returned article content. False signals that `extract` would fall back to its selector cascade."),
+	fallbackUsed: z.boolean().describe("Always false for explain — this tool runs only the Readability path it is diagnosing, never the fallback cascade."),
+	gating: 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\").")
+	}).nullable().describe("Likely paywall / gating signal detected before normalization. Null when none."),
+	pagination: z.object({
+		type: z.enum(["infinite", "paginated"]).describe("Kind of pagination signal detected."),
+		nextUrl: z.string().optional().describe("Absolute URL of the detected next page (paginated only). Never fetched."),
+		selector: z.string().optional().describe("CSS selector of the load-more / infinite-scroll sentinel (infinite only).")
+	}).nullable().describe("Detected pagination / infinite-scroll signal. Null when none."),
+	removedNodes: z.object({
+		boilerplate: z.number().int().min(0).describe("Boilerplate blocks (related-posts, newsletter signup) stripped before Readability."),
+		chrome: z.number().int().min(0).describe("Browser-chrome nodes stripped (scrollbars, consent banners, overlays)."),
+		total: z.number().int().min(0).describe("Net element count removed across the whole pipeline (delta vs. the parsed document).")
+	}).describe("Breakdown of nodes removed before Readability saw the document, reused from the extract diagnostics path."),
+	snapshot: z.object({
+		html: z.string().describe("The sanitized-by-normalization (post chrome/boilerplate/script strip) HTML fed to Readability — \"what Readability saw\". Not DOMPurify-sanitized (that runs on Readability's output in `extract`), so it may still carry inline event handlers (`onerror`/`onclick`/…); it is diagnostic data — do not render verbatim."),
+		truncated: z.boolean().describe("True when the snapshot was cut at snapshotMaxChars (default 4000).")
+	}).describe("Pre-Readability HTML snapshot of the normalized document body.")
+};
+var explainOutput = z.object(explainOutputShape);
+function formatGating(report) {
+	const g = report.gating;
+	if (!g) return "none";
+	return `${g.reason}${g.likely ? "" : " (weak)"}`;
+}
+function formatPagination(report) {
+	const p = report.pagination;
+	if (!p) return "none";
+	if (p.type === "paginated") return `paginated -> ${p.nextUrl ?? "(no href)"}`;
+	return `infinite (${p.selector ?? "sentinel"})`;
+}
+function renderText(report) {
+	const lines = [];
+	const root = report.chosenRoot;
+	lines.push(`readerable: ${report.readerable ? "yes" : "no"}  parse: ${report.parseSucceeded ? "ok" : "fail"}  fallback: ${report.fallbackUsed ? "yes" : "no"}`);
+	lines.push(`chosen root: ${root ? `${root.selector}  (score ${root.score.toFixed(2)}, ${root.textLength} chars)` : "(no candidate scored)"}`);
+	lines.push(`top candidates (${report.candidates.length}):`);
+	if (report.candidates.length === 0) lines.push("  (none)");
+	report.candidates.forEach((c, i) => {
+		lines.push(`  ${i + 1}. ${c.selector}  score ${c.score.toFixed(2)}  (${c.textLength} chars)`);
+	});
+	const r = report.removedNodes;
+	lines.push(`removed: total=${r.total} (chrome=${r.chrome}, boilerplate=${r.boilerplate})`);
+	lines.push(`gating: ${formatGating(report)}`);
+	lines.push(`pagination: ${formatPagination(report)}`);
+	lines.push(`snapshot (${report.snapshot.html.length} chars${report.snapshot.truncated ? ", truncated" : ""}):`);
+	lines.push(report.snapshot.html);
+	return lines.join("\n");
+}
+function explain(rawArgs) {
+	const { localPath, ...rest } = explainInputSchema.parse(rawArgs);
+	return explainFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+function explainFromHtml(input) {
+	const { html, baseUrl, selectors, topN } = {
+		...DEFAULTS$4,
+		...input
+	};
+	const report = buildExplainReport({
+		html,
+		selectors,
+		topN,
+		baseUrl
+	});
+	const content = renderText(report);
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			chosenRoot: report.chosenRoot,
+			candidates: report.candidates,
+			readerable: report.readerable,
+			parseSucceeded: report.parseSucceeded,
+			fallbackUsed: report.fallbackUsed,
+			gating: report.gating ?? null,
+			pagination: report.pagination ?? null,
+			removedNodes: report.removedNodes,
+			snapshot: report.snapshot
+		}
+	};
+}
+var EXPLAIN_TOOL_DESCRIPTION = `Post-mortem diagnostics for extraction: shows WHY Readability picked what it picked. Returns the chosen root, the ranked candidate nodes with their REAL Readability contentScore values (read off the DOM expando Readability stamps during scoring), a categorized removed-nodes breakdown, gating/pagination signals, and a snapshot of the normalized HTML fed to Readability. Runs the same normalize + Readability pipeline as \`extract\` (no fallback cascade, no Turndown). The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` (optional) is origin context only.`;
+function explainHandler(args) {
+	try {
+		return explain(args);
+	} catch (err) {
+		logger.error(`explain failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExplainTool(server) {
+	return server.registerTool("explain", {
+		title: "Explain why Readability picked what it picked",
+		description: EXPLAIN_TOOL_DESCRIPTION,
+		inputSchema: explainInputShape,
+		outputSchema: explainOutput
+	}, explainHandler);
+}
+//#endregion
+//#region src/policy/sibling-scan.ts
+var CONTAINER_TAGS = /* @__PURE__ */ new Set([
+	"ARTICLE",
+	"DIV",
+	"MAIN",
+	"OL",
+	"SECTION",
+	"TABLE",
+	"TBODY",
+	"UL"
+]);
+var LANDMARK_CHROME_SELECTOR = "nav, header, footer, aside, [role=\"navigation\"], [role=\"banner\"], [role=\"contentinfo\"], [role=\"complementary\"], [role=\"search\"], [role=\"menu\"], [role=\"menubar\"]";
+function stripLandmarkChrome(document) {
+	for (const el of document.querySelectorAll(LANDMARK_CHROME_SELECTOR)) el.remove();
+	for (const el of document.querySelectorAll("script, style, template")) el.remove();
+}
+function shapeKey(el) {
+	const raw = el.getAttribute("class");
+	if (!raw) return el.tagName;
+	const normalized = raw.trim().split(/\s+/).sort().join(" ");
+	return normalized ? `${el.tagName}|${normalized}` : el.tagName;
+}
+function describeSelector(el) {
+	const parts = [el.tagName.toLowerCase()];
+	const id = el.getAttribute("id");
+	if (id) parts.push(`#${id}`);
+	const cls = el.getAttribute("class");
+	if (cls) {
+		for (const token of cls.trim().split(/\s+/)) if (token) parts.push(`.${token}`);
+	}
+	return parts.join("");
+}
+//#endregion
+//#region src/policy/grid-detector.ts
+var MIN_ROWS = 3;
+var HIGH_CONF_ROWS = 6;
+var MIN_CELLS_PER_ROW = 2;
+function rowCells(row) {
+	return Array.from(row.children).map(resolveCellText);
+}
+function notDetected$1(note) {
+	return {
+		confidence: "low",
+		containerSelector: "",
+		detected: false,
+		rowCount: 0,
+		colCount: 0,
+		rows: [],
+		rowTag: "",
+		note
+	};
+}
+function confidenceFor$1(dataRowCount) {
+	return dataRowCount >= HIGH_CONF_ROWS ? "high" : "medium";
+}
+function buildResult(raggedRows, rowTag, containerSelector, selectorHint, evidence) {
+	let maxCols = 0;
+	for (const row of raggedRows) if (row.length > maxCols) maxCols = row.length;
+	if (maxCols === 0) return notDetected$1(selectorHint ? `not a grid: rows matched ${selectorHint} but no cells were found` : "not a grid: rows matched but no cells were found");
+	const rowCount = raggedRows.length;
+	const dataRowCount = evidence?.dataRowCount ?? rowCount;
+	const headerCount = evidence?.headerCount ?? 0;
+	const rows = raggedRows.map((row) => ({ cells: Array.from({ length: maxCols }, (_, i) => row[i] ?? "") }));
+	const where = containerSelector || selectorHint || "document";
+	const descriptor = headerCount > 0 ? `detected ${dataRowCount} ${rowTag} data rows plus ${headerCount} header row${headerCount > 1 ? "s" : ""} (${maxCols} cols) in ${where}` : `detected ${dataRowCount} ${rowTag} rows (${maxCols} cols) in ${where}`;
+	return {
+		confidence: confidenceFor$1(dataRowCount),
+		containerSelector,
+		detected: true,
+		rowCount,
+		colCount: maxCols,
+		rows,
+		rowTag,
+		note: descriptor
+	};
+}
+function detectSelectorMode(document, rowSelector, cellSelector, minRows) {
+	const rowEls = Array.from(document.querySelectorAll(rowSelector));
+	if (rowEls.length < minRows) return notDetected$1(`not a grid: rowSelector "${rowSelector}" matched ${rowEls.length} row(s) (min ${minRows})`);
+	return buildResult(rowEls.map((row) => Array.from(row.querySelectorAll(cellSelector)).map(resolveCellText)), rowEls[0].tagName, "", rowSelector);
+}
+function modalWidth(members) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const member of members) {
+		const width = member.children.length;
+		counts.set(width, (counts.get(width) ?? 0) + 1);
+	}
+	let best = members[0].children.length;
+	let bestCount = 0;
+	for (const [width, count] of counts) if (count > bestCount) {
+		best = width;
+		bestCount = count;
+	}
+	return best;
+}
+function classTokens(el) {
+	const cls = el.getAttribute("class");
+	return cls ? new Set(cls.trim().split(/\s+/)) : /* @__PURE__ */ new Set();
+}
+function looksLikeHeader(child, rowTag, dataClass, dataWidth) {
+	if (child.tagName !== rowTag || child.children.length !== dataWidth) return false;
+	if (child.getAttribute("role") === "row" && Array.from(child.children).some((c) => c.getAttribute("role") === "columnheader")) return true;
+	const childClass = classTokens(child);
+	return dataClass.size > 0 && [...dataClass].every((token) => childClass.has(token));
+}
+function collectHeaderRows(container, members) {
+	const memberSet = new Set(members);
+	const rowTag = members[0].tagName;
+	const dataWidth = modalWidth(members);
+	const dataClass = classTokens(members[0]);
+	const headers = [];
+	for (const child of Array.from(container.children)) {
+		if (memberSet.has(child)) break;
+		if (looksLikeHeader(child, rowTag, dataClass, dataWidth)) headers.push(rowCells(child));
+	}
+	return headers;
+}
+function detectAuto(document, minRows) {
+	stripLandmarkChrome(document);
+	const candidates = [];
+	for (const container of document.querySelectorAll("*")) {
+		if (!CONTAINER_TAGS.has(container.tagName)) continue;
+		const groups = /* @__PURE__ */ new Map();
+		for (const child of Array.from(container.childNodes)) {
+			if (!isElement(child)) continue;
+			const key = shapeKey(child);
+			const bucket = groups.get(key);
+			if (bucket) bucket.push(child);
+			else groups.set(key, [child]);
+		}
+		for (const members of groups.values()) {
+			if (members.length < minRows) continue;
+			if (!members.every((m) => m.children.length >= MIN_CELLS_PER_ROW)) continue;
+			const rows = members.map(rowCells);
+			const totalCellText = rows.reduce((sum, row) => sum + row.reduce((s, c) => s + c.length, 0), 0);
+			candidates.push({
+				container,
+				containerSelector: describeSelector(container),
+				members,
+				rows,
+				rowTag: members[0].tagName,
+				memberCount: members.length,
+				totalCellText
+			});
+		}
+	}
+	if (candidates.length === 0) return notDetected$1("not a grid: no repeating row structure (≥3 same-shape siblings each with ≥2 direct element-children, outside nav/header/footer/aside)");
+	let winner = candidates[0];
+	for (let i = 1; i < candidates.length; i++) {
+		const candidate = candidates[i];
+		if (candidate.memberCount > winner.memberCount || candidate.memberCount === winner.memberCount && candidate.totalCellText > winner.totalCellText) winner = candidate;
+	}
+	const headerRows = collectHeaderRows(winner.container, winner.members);
+	return buildResult([...headerRows, ...winner.rows], winner.rowTag, winner.containerSelector, void 0, {
+		dataRowCount: winner.memberCount,
+		headerCount: headerRows.length
+	});
+}
+function detectGrid(document, opts) {
+	const minRows = opts?.minRows ?? MIN_ROWS;
+	if (opts?.rowSelector && opts.cellSelector) return detectSelectorMode(document, opts.rowSelector, opts.cellSelector, minRows);
+	return detectAuto(document, minRows);
+}
+//#endregion
+//#region src/tools/extract_grid.ts
+var NO_GRID = "(no repeating grid found)";
+function extractGrid(rawArgs) {
+	const { localPath, ...rest } = extractGridInputSchema.parse(rawArgs);
+	return extractGridFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+var DEFAULTS$3 = extractGridInputSchema.parse({ localPath: "" });
+function extractGridFromHtml(input) {
+	const { html, baseUrl, format, selectors, rowSelector, cellSelector } = {
+		...DEFAULTS$3,
+		...input
+	};
+	const { document } = buildDocument(html, baseUrl);
+	applySelectors(document, selectors);
+	const result = detectGrid(document, {
+		rowSelector,
+		cellSelector
+	});
+	let content = NO_GRID;
+	let grid = {
+		rows: 0,
+		cols: 0,
+		markdown: ""
+	};
+	if (result.detected && result.rows.length > 0) {
+		const matrix = result.rows.map((row) => [...row.cells]);
+		const markdown = renderTable(matrix, format);
+		content = markdown;
+		grid = {
+			rows: result.rowCount,
+			cols: result.colCount,
+			markdown
+		};
+	}
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			grid,
+			diagnostics: {
+				confidence: result.confidence,
+				containerSelector: result.containerSelector,
+				detected: result.detected,
+				rowCount: result.rowCount,
+				colCount: result.colCount,
+				rowTag: result.rowTag,
+				note: result.note
+			},
+			metadata: {
+				baseUrl,
+				format,
+				detected: result.detected
+			}
+		}
+	};
+}
+var EXTRACT_GRID_TOOL_DESCRIPTION = `Detect and extract a CSS-grid / div "table" from already-rendered (post-JavaScript) HTML — the div equivalent of \`extract_tables\` for SPAs that render data into repeating \`<div>\` rows instead of \`<table>\`. Supports auto-detect (find the container whose direct children form the largest same-shape sibling group of ≥3 rows, each row a set of ≥2 direct element-children) and explicit \`rowSelector\` + \`cellSelector\` selector mode (cells scoped to each row subtree). Renders the matrix through the SAME gfm/csv/json renderer as \`extract_tables\`. Runs no Readability, no Turndown, no sanitization — the server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` (optional) is origin context only.`;
+function extractGridHandler(args) {
+	try {
+		return extractGrid(args);
+	} catch (err) {
+		logger.error(`extract_grid failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExtractGridTool(server) {
+	return server.registerTool("extract_grid", {
+		title: "Extract a CSS-grid / div table (the div equivalent of extract_tables)",
+		description: EXTRACT_GRID_TOOL_DESCRIPTION,
+		inputSchema: extractGridInputShape,
+		outputSchema: extractGridOutputShape
+	}, extractGridHandler);
+}
+//#endregion
+//#region src/tools/extract_links.ts
+var MAX_TEXT_LENGTH = 300;
+function clipText(raw) {
+	const collapsed = raw.replace(/\s+/g, " ").trim();
+	return collapsed.length > MAX_TEXT_LENGTH ? `${collapsed.slice(0, MAX_TEXT_LENGTH)}…` : collapsed;
+}
+function isWebOrigin(parsed) {
+	return parsed.protocol === "http:" || parsed.protocol === "https:";
+}
+function resolveExternal(absolutizedHref, baseUrl) {
+	let parsedHref;
+	try {
+		parsedHref = new URL(absolutizedHref);
+	} catch {
+		return false;
+	}
+	if (!isWebOrigin(parsedHref)) return false;
+	try {
+		return new URL(baseUrl).origin !== parsedHref.origin;
+	} catch {
+		return false;
+	}
+}
+function pruneUnsafeRoots(document) {
+	for (const el of document.querySelectorAll("script, template")) el.remove();
+}
+function extractLinks(rawArgs) {
+	const { localPath, ...rest } = extractLinksInputSchema.parse(rawArgs);
+	return extractLinksFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+var DEFAULTS$2 = extractLinksInputSchema.parse({ localPath: "" });
+function extractLinksFromHtml(input) {
+	const { html, baseUrl, sameOriginOnly, selectors } = {
+		...DEFAULTS$2,
+		...input
+	};
+	const { document } = buildDocument(html, baseUrl);
+	applySelectors(document, selectors);
+	pruneUnsafeRoots(document);
+	const links = [];
+	for (const anchor of document.querySelectorAll("a")) {
+		const rawHref = anchor.getAttribute("href");
+		if (!rawHref) continue;
+		const href = absolutize(rawHref, baseUrl);
+		const isExternal = baseUrl ? resolveExternal(href, baseUrl) : false;
+		if (sameOriginOnly && isExternal) continue;
+		links.push({
+			text: clipText(anchor.textContent),
+			href,
+			rel: anchor.getAttribute("rel") ?? "",
+			isExternal
+		});
+	}
+	const content = renderLinksIndex(links);
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			links,
+			metadata: { baseUrl }
+		}
+	};
+}
+function renderLinksIndex(links) {
+	if (links.length === 0) return "(no links found)";
+	return links.map((link) => `- [${link.text || "(no text)"}](${link.href})`).join("\n");
+}
+var EXTRACT_LINKS_TOOL_DESCRIPTION = `Return a structured list of anchor links from already-rendered (post-JavaScript) HTML — \`[{text, href, rel, isExternal}]\` in document order, hrefs absolutized against \`baseUrl\`. No Readability scoring, Turndown, or sanitization — links are gathered from the raw parsed DOM so nav/footer/main links survive. Pairs with chrome-devtools for crawl/navigation decisions. The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` is origin context only (never fetched).`;
+function extractLinksHandler(args) {
+	try {
+		return extractLinks(args);
+	} catch (err) {
+		logger.error(`extract_links failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExtractLinksTool(server) {
+	return server.registerTool("extract_links", {
+		title: "Extract anchor links",
+		description: EXTRACT_LINKS_TOOL_DESCRIPTION,
+		inputSchema: extractLinksInputShape,
+		outputSchema: extractLinksOutputShape
+	}, extractLinksHandler);
+}
+//#endregion
+//#region src/policy/list-detector.ts
+var MIN_ITEMS = 3;
+var HIGH_CONF_ITEMS = 6;
+var HIGH_CONF_AVG_SCORE = 30;
+var MAX_SNIPPET_CHARS = 200;
+function isNavigationHref(href) {
+	if (!href || href === "#") return false;
+	const lower = href.toLowerCase();
+	return !lower.startsWith("javascript:") && !lower.startsWith("mailto:") && !lower.startsWith("tel:");
+}
+function anchorText(anchor) {
+	return anchor.textContent.replace(/\s+/g, " ").trim();
+}
+function navigationAnchors(child) {
+	const anchors = [];
+	for (const el of child.querySelectorAll("a[href]")) {
+		const anchor = el;
+		if (!isNavigationHref(anchor.getAttribute("href") ?? "")) continue;
+		if (anchorText(anchor).length === 0) continue;
+		anchors.push(anchor);
+	}
+	return anchors;
+}
+function pickPrimaryAnchor(anchors) {
+	let primary = anchors[0];
+	let best = anchorText(primary).length;
+	for (let i = 1; i < anchors.length; i++) {
+		const len = anchorText(anchors[i]).length;
+		if (len > best) {
+			primary = anchors[i];
+			best = len;
+		}
+	}
+	return primary;
+}
+function clipSnippet(raw) {
+	const collapsed = raw.replace(/\s+/g, " ").trim();
+	if (collapsed.length <= MAX_SNIPPET_CHARS) return collapsed;
+	return `${collapsed.slice(0, MAX_SNIPPET_CHARS)}…`;
+}
+function scoreItem(textLength, linkTextLength, primaryAnchorTextLength) {
+	if (textLength === 0) return 0;
+	return primaryAnchorTextLength + Math.max(0, textLength - linkTextLength);
+}
+function extractItem(child, baseUrl) {
+	const anchors = navigationAnchors(child);
+	if (anchors.length === 0) return null;
+	const primary = pickPrimaryAnchor(anchors);
+	const title = anchorText(primary);
+	if (!title) return null;
+	const href = primary.getAttribute("href") ?? "";
+	const url = absolutize(href, baseUrl);
+	if (!url) return null;
+	const fullText = child.textContent.replace(/\s+/g, " ").trim();
+	const snippet = fullText === title ? "" : fullText.startsWith(title) ? clipSnippet(fullText.slice(title.length + 1)) : clipSnippet(fullText);
+	const linkTextLength = anchors.reduce((sum, anchor) => sum + anchorText(anchor).length, 0);
+	return {
+		score: scoreItem(fullText.length, linkTextLength, title.length),
+		snippet,
+		title,
+		url
+	};
+}
+function distinctPathnames(items) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const item of items) try {
+		paths.add(new URL(item.url).pathname);
+	} catch {
+		paths.add(item.url);
+	}
+	return paths.size;
+}
+function collectCandidates(document, baseUrl) {
+	const candidates = [];
+	for (const container of document.querySelectorAll("*")) {
+		if (!CONTAINER_TAGS.has(container.tagName)) continue;
+		const groups = /* @__PURE__ */ new Map();
+		for (const child of Array.from(container.childNodes)) {
+			if (!isElement(child)) continue;
+			const key = shapeKey(child);
+			const bucket = groups.get(key);
+			if (bucket) bucket.push(child);
+			else groups.set(key, [child]);
+		}
+		for (const children of groups.values()) {
+			if (children.length < MIN_ITEMS) continue;
+			if (!children.every((child) => navigationAnchors(child).length > 0)) continue;
+			const items = [];
+			for (const child of children) {
+				const item = extractItem(child, baseUrl);
+				if (item) items.push(item);
+			}
+			if (items.length < MIN_ITEMS) continue;
+			candidates.push({
+				containerSelector: describeSelector(container),
+				distinctPathnames: distinctPathnames(items),
+				itemTag: children[0].tagName,
+				items,
+				totalScore: items.reduce((sum, item) => sum + item.score, 0)
+			});
+		}
+	}
+	return candidates;
+}
+function confidenceFor(items) {
+	if (items.length < MIN_ITEMS) return "low";
+	if (items.length >= HIGH_CONF_ITEMS) return items.reduce((sum, item) => sum + item.score, 0) / items.length >= HIGH_CONF_AVG_SCORE ? "high" : "medium";
+	return "medium";
+}
+function notDetected(note) {
+	return {
+		confidence: "low",
+		containerSelector: "",
+		detected: false,
+		itemCount: 0,
+		itemTag: "",
+		items: [],
+		note
+	};
+}
+function detectList(document, baseUrl) {
+	stripLandmarkChrome(document);
+	const candidates = collectCandidates(document, baseUrl);
+	if (candidates.length === 0) return notDetected("not a list: no repeated item structure with links (≥3 same-shape siblings each carrying an anchor, outside nav/header/footer/aside)");
+	let winner = candidates[0];
+	for (let i = 1; i < candidates.length; i++) {
+		const candidate = candidates[i];
+		if (candidate.distinctPathnames > winner.distinctPathnames || candidate.distinctPathnames === winner.distinctPathnames && candidate.items.length > winner.items.length || candidate.distinctPathnames === winner.distinctPathnames && candidate.items.length === winner.items.length && candidate.totalScore > winner.totalScore) winner = candidate;
+	}
+	if (winner.items.length < MIN_ITEMS) return notDetected("not a list: best candidate had fewer than 3 extracted items");
+	const items = winner.items;
+	return {
+		confidence: confidenceFor(items),
+		containerSelector: winner.containerSelector,
+		detected: true,
+		itemCount: items.length,
+		itemTag: winner.itemTag,
+		items,
+		note: `detected ${items.length} ${winner.itemTag} items in ${winner.containerSelector}`
+	};
+}
+//#endregion
+//#region src/tools/extract_list.ts
+var NOT_A_LIST = "not a list: no repeated item structure with links";
+function renderItems(result) {
+	if (!result.detected || result.items.length === 0) return result.note || NOT_A_LIST;
+	return result.items.map((item, index) => {
+		const head = `${index + 1}. ${item.title} — ${item.url}`;
+		return item.snippet ? `${head}\n   ${item.snippet}` : head;
+	}).join("\n");
+}
+function toStructuredItem(item) {
+	return {
+		score: item.score,
+		snippet: item.snippet,
+		title: item.title,
+		url: item.url
+	};
+}
+function extractList(rawArgs) {
+	const { localPath, ...rest } = extractListInputSchema.parse(rawArgs);
+	return extractListFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+function extractListFromHtml(input) {
+	const { html, baseUrl, selectors } = input;
+	const { document } = buildDocument(html, baseUrl);
+	applySelectors(document, selectors);
+	const result = detectList(document, baseUrl);
+	const content = renderItems(result);
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			items: result.items.map(toStructuredItem),
+			diagnostics: {
+				confidence: result.confidence,
+				containerSelector: result.containerSelector,
+				detected: result.detected,
+				itemCount: result.itemCount,
+				itemTag: result.itemTag,
+				note: result.note
+			},
+			metadata: { baseUrl }
+		}
+	};
+}
+var EXTRACT_LIST_TOOL_DESCRIPTION = `Detect and extract a list/feed/index structure from already-rendered (post-JavaScript) HTML — for HN-style, search-result, and blog-index pages that Readability cannot turn into one article. Returns \`{items: [{title, url, snippet, score}], diagnostics}\` instead of one article. Strips nav/header/footer/aside + ARIA chrome roles first (the false-positive guard so an article's nav menu doesn't look like a 4-item feed), then finds the container whose direct children form a same-shape sibling cluster of ≥3 elements each carrying a navigation anchor, and the cluster with the most items wins. No Readability, no Turndown, no sanitization. The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` (optional) is origin context for absolutizing item hrefs.`;
+function extractListHandler(args) {
+	try {
+		return extractList(args);
+	} catch (err) {
+		logger.error(`extract_list failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExtractListTool(server) {
+	return server.registerTool("extract_list", {
+		title: "Extract a list/feed (HN/search/blog-index pages)",
+		description: EXTRACT_LIST_TOOL_DESCRIPTION,
+		inputSchema: extractListInputShape,
+		outputSchema: extractListOutputShape
+	}, extractListHandler);
+}
+//#endregion
+//#region src/tools/extract_metadata.ts
+var BIBLIOGRAPHIC_KEYS = [
+	"title",
+	"byline",
+	"siteName",
+	"lang",
+	"publishedTime",
+	"excerpt",
+	"canonical",
+	"baseUrl"
+];
+function pickBibliographic(metadata) {
+	const out = {};
+	for (const key of BIBLIOGRAPHIC_KEYS) {
+		const value = metadata[key];
+		if (value !== void 0) out[key] = value;
+	}
+	return out;
+}
+function renderMetadataLines(metadata) {
+	const lines = Object.entries(metadata).map(([key, value]) => `${key}: ${value}`);
+	return lines.length > 0 ? lines.join("\n") : "(no metadata found)";
+}
+function extractMetadataDocument(rawArgs) {
+	const { localPath, ...rest } = extractMetadataInputSchema.parse(rawArgs);
+	return extractMetadataDocumentFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+function extractMetadataDocumentFromHtml(input) {
+	const { html, baseUrl } = input;
+	const { document } = buildDocument(html, baseUrl);
+	normalizeDocument(document);
+	const metadata = pickBibliographic(resolveMetadata({
+		document,
+		textContent: "",
+		wordCount: 0,
+		readingTimeMin: 0,
+		baseUrl
+	}));
+	const content = renderMetadataLines(metadata);
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			metadata
+		}
+	};
+}
+var EXTRACT_METADATA_TOOL_DESCRIPTION = `Return only the bibliographic metadata (title, byline, siteName, lang, publishedTime, excerpt, canonical, baseUrl) of already-rendered (post-JavaScript) HTML without running Readability/Turndown — a fast pre-check for crawlers and citation. Resolves the same metadata cascade as \`extract\` (JSON-LD → OpenGraph → Twitter → <meta> → <time> → <title>), plus <link rel="canonical"> → og:url. The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` is origin context only (never fetched).`;
+function extractMetadataHandler(args) {
+	try {
+		return extractMetadataDocument(args);
+	} catch (err) {
+		logger.error(`extract_metadata failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExtractMetadataTool(server) {
+	return server.registerTool("extract_metadata", {
+		title: "Extract metadata only (no Readability)",
+		description: EXTRACT_METADATA_TOOL_DESCRIPTION,
+		inputSchema: extractMetadataInputShape,
+		outputSchema: extractMetadataOutputShape
+	}, extractMetadataHandler);
+}
+//#endregion
+//#region src/policy/outline.ts
+function normalizeHeadingText(raw) {
+	return raw.replace(/\s+/g, " ").trim().replace(/^#+|#+$/g, "").trim();
+}
+function slugify(text) {
+	return text.toLowerCase().replace(/[^\p{L}\p{M}\p{N}\p{Pc} -]/gu, "").replace(/ /g, "-") || "section";
+}
+function linkAnchor(heading) {
+	for (const link of heading.querySelectorAll("a[href^=\"#\"]")) {
+		const href = link.getAttribute("href");
+		if (!href) continue;
+		const fragment = href.slice(1);
+		if (fragment) return fragment;
+	}
+}
+function resolveCandidate(heading, text) {
+	const id = heading.getAttribute("id");
+	if (id) return {
+		anchor: id,
+		explicit: true
+	};
+	const link = linkAnchor(heading);
+	if (link) return {
+		anchor: link,
+		explicit: true
+	};
+	return {
+		anchor: slugify(text),
+		explicit: false
+	};
+}
+function dedupe(candidate, explicit, used) {
+	if (explicit || !used.has(candidate)) return candidate;
+	let suffix = 1;
+	while (used.has(`${candidate}-${suffix}`)) suffix++;
+	return `${candidate}-${suffix}`;
+}
+function resolveOutline(document) {
+	const entries = [];
+	const used = /* @__PURE__ */ new Set();
+	document.querySelectorAll("h1, h2, h3, h4, h5, h6").forEach((heading) => {
+		const rawText = heading.textContent;
+		if (!rawText.trim()) return;
+		const text = normalizeHeadingText(rawText);
+		const level = Number.parseInt(heading.tagName.slice(1), 10);
+		const { anchor: candidate, explicit } = resolveCandidate(heading, text);
+		const anchor = dedupe(candidate, explicit, used);
+		used.add(anchor);
+		entries.push({
+			anchor,
+			level,
+			text
+		});
+	});
+	return entries;
+}
+//#endregion
+//#region src/policy/section.ts
+function findHeading(document, query) {
+	const needle = normalizeHeadingText(query).toLowerCase();
+	if (!needle) return;
+	const headings = document.querySelectorAll("h1, h2, h3, h4, h5, h6");
+	let substring;
+	for (const heading of headings) {
+		const text = normalizeHeadingText(heading.textContent).toLowerCase();
+		if (!text) continue;
+		const level = Number.parseInt(heading.tagName.slice(1), 10);
+		if (text === needle) return {
+			heading,
+			level
+		};
+		if (!substring && text.includes(needle)) substring = {
+			heading,
+			level
+		};
+	}
+	return substring;
+}
+var FLOW_CONTAINERS = /* @__PURE__ */ new Set([
+	"ARTICLE",
+	"ASIDE",
+	"BLOCKQUOTE",
+	"BODY",
+	"DD",
+	"DETAILS",
+	"DT",
+	"FOOTER",
+	"HEADER",
+	"LI",
+	"MAIN",
+	"NAV",
+	"SECTION",
+	"TD"
+]);
+function findFlowContainer(heading) {
+	let ancestor = heading.parentElement;
+	while (ancestor) {
+		if (FLOW_CONTAINERS.has(ancestor.tagName)) return ancestor;
+		ancestor = ancestor.parentElement;
+	}
+	return heading.ownerDocument.body;
+}
+function firstHeadingLevel(el) {
+	const direct = /^H([1-6])$/.exec(el.tagName);
+	if (direct) return Number.parseInt(direct[1], 10);
+	const inner = el.querySelector("h1, h2, h3, h4, h5, h6");
+	if (inner) return Number.parseInt(inner.tagName.slice(1), 10);
+}
+function scopeToHeading(document, headingText) {
+	const match = findHeading(document, headingText);
+	if (!match) return false;
+	const { heading, level } = match;
+	const container = findFlowContainer(heading);
+	let startChild = heading;
+	while (startChild.parentElement && startChild.parentElement !== container) startChild = startChild.parentElement;
+	const wrap = document.createElement("section");
+	wrap.setAttribute("data-rdrm-section-scope", "");
+	container.insertBefore(wrap, startChild);
+	let node = startChild;
+	while (node) {
+		const next = node.nextSibling;
+		wrap.appendChild(node);
+		if (next !== null && isElement(next)) {
+			const nextLevel = firstHeadingLevel(next);
+			if (nextLevel !== void 0 && nextLevel <= level) break;
+		}
+		node = next;
+	}
+	return true;
+}
+//#endregion
+//#region src/tools/extract_section.ts
+var SECTION_SCOPE_SELECTOR = "[data-rdrm-section-scope]";
+function extractSection(rawArgs) {
+	const { localPath, ...rest } = extractSectionInputSchema.parse(rawArgs);
+	return extractSectionFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+function extractSectionFromHtml(input) {
+	const { html, baseUrl, selector, heading } = input;
+	if (selector !== void 0) return extractArticleFromHtml({
+		html,
+		baseUrl,
+		selectors: { include: selector }
+	});
+	if (heading === void 0) throw new ExtractionError("Provide exactly one of `selector` or `heading`.");
+	const { document } = buildDocument(html, baseUrl);
+	normalizeDocument(document);
+	if (!scopeToHeading(document, heading)) throw new ExtractionError(`no heading matched: ${heading}`);
+	const scoped = `<!DOCTYPE html><html><head></head><body>${document.body.innerHTML}</body></html>`;
+	return extractArticleFromHtml({
+		html: scoped,
+		baseUrl,
+		selectors: { include: SECTION_SCOPE_SELECTOR }
+	});
+}
+var EXTRACT_SECTION_TOOL_DESCRIPTION = `Extract one section of an already-rendered (post-JavaScript) HTML document and return its Markdown + metadata + diagnostics — a thin resolver over extract’s \`selectors.include\` path, not a new extractor. Pick the section by CSS \`selector\` (passed straight through) OR by \`heading\` text (case-insensitive, first match wins; the section spans from the matched heading to the next same-or-higher-level heading). Exactly one of \`selector\`/\`heading\` is required. The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` (optional) is origin context only (never fetched).`;
+function extractSectionHandler(args) {
+	try {
+		return extractSection(args);
+	} catch (err) {
+		logger.error(`extract_section failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExtractSectionTool(server) {
+	return server.registerTool("extract_section", {
+		title: "Extract one section by selector or heading",
+		description: EXTRACT_SECTION_TOOL_DESCRIPTION,
+		inputSchema: extractSectionInputShape,
+		outputSchema: outputSchemaShape
+	}, extractSectionHandler);
+}
+//#endregion
+//#region src/tools/extract_tables.ts
+var NO_TABLES = "(no tables found)";
+function extractTables(rawArgs) {
+	const { localPath, ...rest } = extractTablesInputSchema.parse(rawArgs);
+	return extractTablesFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+var DEFAULTS$1 = extractTablesInputSchema.parse({ localPath: "" });
+function extractTablesFromHtml(input) {
+	const { html, baseUrl, format, selectors } = {
+		...DEFAULTS$1,
+		...input
+	};
+	const { document } = buildDocument(html, baseUrl);
+	applySelectors(document, selectors);
+	const tables = [];
+	let index = 0;
+	for (const table of document.querySelectorAll("table")) {
+		const matrix = parseTableMatrix(table);
+		if (matrix.length === 0) continue;
+		const keys = format === "json" ? resolveHeaderKeys(table, matrix) : void 0;
+		const markdown = renderTable(matrix, format, keys);
+		tables.push({
+			index,
+			rows: matrix.length,
+			cols: matrix[0]?.length ?? 0,
+			markdown
+		});
+		index++;
+	}
+	const content = tables.length > 0 ? tables.map((entry) => entry.markdown).join("\n\n") : NO_TABLES;
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			tables,
+			metadata: {
+				baseUrl,
+				format,
+				tableCount: tables.length
+			}
+		}
+	};
+}
+var EXTRACT_TABLES_TOOL_DESCRIPTION = `Extract every <table> on the page from already-rendered (post-JavaScript) HTML and return each as GFM / CSV / JSON (caller picks). Runs no Readability, Turndown, or sanitization — a page-wide \`querySelectorAll('table')\` walk in front of the same rowspan/colspan-aware matrix serializer used by the \`tables\` option on \`extract\`. Captures tables outside the article body (nav, aside, boilerplate) that the \`tables\` option never sees. The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` (optional) is origin context only (never fetched).`;
+function extractTablesHandler(args) {
+	try {
+		return extractTables(args);
+	} catch (err) {
+		logger.error(`extract_tables failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerExtractTablesTool(server) {
+	return server.registerTool("extract_tables", {
+		title: "Extract every table on the page",
+		description: EXTRACT_TABLES_TOOL_DESCRIPTION,
+		inputSchema: extractTablesInputShape,
+		outputSchema: extractTablesOutputShape
+	}, extractTablesHandler);
+}
+//#endregion
+//#region src/tools/html_to_markdown.ts
+var EXTRACTED_NODE = "fragment";
+function htmlToMarkdown(rawArgs) {
+	const { localPath, ...rest } = htmlToMarkdownInputSchema.parse(rawArgs);
+	return htmlToMarkdownFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+var DEFAULTS = htmlToMarkdownInputSchema.parse({ localPath: "" });
+function htmlToMarkdownFromHtml(input) {
+	const { html, baseUrl, selectors, format, metadataMode, gfm, headingStyle, codeBlockStyle, images, sanitize: shouldSanitize, maxChars, wordsPerMinute, cleanChrome, tables, debug } = {
+		...DEFAULTS,
+		...input
+	};
+	const trace = new TraceCollector(debug);
+	const { document, window } = buildDocument(html, baseUrl);
+	const { documentElementCount, normalizeCounts, imagesResolved, textContent, rawHtml } = trace.run("normalize", () => {
+		const documentElementCount = document.querySelectorAll("*").length;
+		const normalizeCounts = normalizeDocument(document, { cleanChrome });
+		const imagesResolved = resolveLazyImages(document);
+		applySelectors(document, selectors);
+		const body = document.body;
+		return {
+			documentElementCount,
+			imagesResolved,
+			normalizeCounts,
+			rawHtml: body.innerHTML,
+			textContent: body.textContent
+		};
+	});
+	const { html: sanitizedHtml, counts: sanitizeCounts } = trace.run("sanitize", () => {
+		if (!shouldSanitize) return {
+			counts: {
+				iframes: 0,
+				scripts: 0
+			},
+			html: rawHtml
+		};
+		const res = sanitizeHtml(rawHtml, window);
+		return {
+			counts: {
+				iframes: res.iframesRemoved,
+				scripts: res.scriptsRemoved
+			},
+			html: res.html
+		};
+	});
+	const markdown = trace.run("turndown", () => toMarkdown(sanitizedHtml, {
+		codeBlockStyle,
+		gfm,
+		headingStyle,
+		images,
+		tables,
+		baseUrl
+	}));
+	const { metadata } = trace.run("metadata", () => {
+		return { metadata: {
+			title: nonEmpty(document.body.querySelector("h1, h2, h3, h4, h5, h6")?.textContent),
+			baseUrl,
+			...computeTextMetrics(textContent, wordsPerMinute)
+		} };
+	});
+	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: EXTRACTED_NODE,
+		fallbackUsed: true,
+		imagesResolved,
+		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;
+	return {
+		content: [{
+			text: payload,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content: payload,
+			metadata,
+			diagnostics
+		}
+	};
+}
+var HTML_TO_MARKDOWN_TOOL_DESCRIPTION = `Convert an arbitrary HTML fragment to Markdown WITHOUT Readability article extraction (e.g. a snippet already isolated via chrome-devtools). Same Turndown + DOMPurify path as \`extract\`. The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` (optional) absolutizes relative links.`;
+function htmlToMarkdownHandler(args) {
+	try {
+		return htmlToMarkdown(args);
+	} catch (err) {
+		logger.error(`html_to_markdown failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerHtmlToMarkdownTool(server) {
+	return server.registerTool("html_to_markdown", {
+		title: "Convert HTML fragment to Markdown",
+		description: HTML_TO_MARKDOWN_TOOL_DESCRIPTION,
+		inputSchema: htmlToMarkdownInputShape,
+		outputSchema: outputSchemaShape
+	}, htmlToMarkdownHandler);
+}
+//#endregion
+//#region src/tools/outline.ts
+function renderOutlineToc(outline) {
+	if (outline.length === 0) return "(no headings found)";
+	return outline.map((entry) => `${"  ".repeat(entry.level - 1)}- ${entry.text}`).join("\n");
+}
+function outlineDocument(rawArgs) {
+	const { localPath, ...rest } = outlineInputSchema.parse(rawArgs);
+	return outlineDocumentFromHtml({
+		html: readHtmlFile(localPath),
+		...rest
+	});
+}
+function outlineDocumentFromHtml(input) {
+	const { html, baseUrl, selectors } = input;
+	const { document } = buildDocument(html, baseUrl);
+	normalizeDocument(document);
+	applySelectors(document, selectors);
+	const outline = resolveOutline(document);
+	const metadata = {
+		title: document.title.trim() || document.querySelector("h1")?.textContent.replace(/\s+/g, " ").trim() || void 0,
+		baseUrl
+	};
+	const content = renderOutlineToc(outline);
+	return {
+		content: [{
+			text: content,
+			type: "text"
+		}],
+		structuredContent: {
+			schemaVersion: 1,
+			content,
+			outline,
+			metadata
+		}
+	};
+}
+var OUTLINE_TOOL_DESCRIPTION = `Return the document outline (h1-h6 headings with stable anchor ids) of already-rendered (post-JavaScript) HTML as a cheap pre-check before full extraction. No Readability scoring, no Turndown, no sanitization — a pure heading walk. The server fetches nothing: \`localPath\` is the only source, and \`baseUrl\` is origin context only (never fetched).`;
+function outlineHandler(args) {
+	try {
+		return outlineDocument(args);
+	} catch (err) {
+		logger.error(`outline failed: ${err instanceof Error ? err.message : String(err)}`);
+		return toErrorResult(err);
+	}
+}
+function registerOutlineTool(server) {
+	return server.registerTool("outline", {
+		title: "Get document outline (heading TOC)",
+		description: OUTLINE_TOOL_DESCRIPTION,
+		inputSchema: outlineInputShape,
+		outputSchema: outlineOutputShape
+	}, outlineHandler);
+}
+//#endregion
+//#region src/server.ts
+function createMcpServer() {
+	const { name, version, title, description, instructions } = loadConfig();
+	return new McpServer({
+		name,
+		version,
+		title,
+		description
+	}, { instructions });
+}
+function registerTools(server) {
+	return [
+		registerChunkTextTool(server),
+		registerExplainTool(server),
+		registerExtractGridTool(server),
+		registerExtractLinksTool(server),
+		registerExtractListTool(server),
+		registerExtractTool(server),
+		registerExtractMetadataTool(server),
+		registerExtractSectionTool(server),
+		registerExtractTablesTool(server),
+		registerHtmlToMarkdownTool(server),
+		registerOutlineTool(server)
+	];
+}
+function registerCapabilityGatedTools(server) {
+	if (!server.server.getClientCapabilities()?.sampling) return [];
+	return registerSamplingTools(server);
+}
+function createServer() {
+	const server = createMcpServer();
+	registerTools(server);
+	registerResources(server);
+	server.server.oninitialized = () => {
+		registerCapabilityGatedTools(server);
+	};
+	return server;
+}
+//#endregion
+//#region src/index.ts
+if (process.argv[2] === "extract") import("./assets/cli-BwKCixh6.js").then((m) => m.runCli(process.argv.slice(2))).then((code) => {
+	process.exit(code);
+}).catch((err) => {
+	process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+	process.exit(1);
+});
+else {
+	const server = createServer();
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	function shutdown() {
+		server.close().catch(() => {}).finally(() => {
+			process.exit(0);
+		});
+	}
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+}
+//#endregion
+export {};
+
+//# sourceMappingURL=index.js.map