@v1nvn/readability 0.43.0 → 0.45.0

package/dist/index.js

@@ -1,2267 +0,0 @@
-#!/usr/bin/env node
-import { $ as resolveLazyImages, A as selectorsSchema, B as absolutize, C as extractTablesInputSchema, D as localPathField, E as htmlToMarkdownInputShape, F as detectGating, G as sanitizeHtml, H as renderTable, I as TraceCollector, J as computeTextMetrics, K as isReaderable, L as assembleDiagnostics, M as truncateMarkdown, N as detectPagination, O as outlineInputSchema, P as resolveMetadata, Q as normalizeDocument, R as chunkMarkdown, S as extractSectionInputShape, T as htmlToMarkdownInputSchema, U as resolveHeaderKeys, V as parseTableMatrix, W as resolveCellText, X as nonEmpty, Y as countWords, Z as applySelectors, _ as extractListInputSchema, a as extractLinksOutputShape, at as normalizeSiteKey, b as extractMetadataInputShape, c as extractTablesOutputShape, ct as selectorMisses, d as chunkTextInputSchema, dt as ExtractionError, et as resolveReadabilityOptions, f as chunkTextInputShape, ft as describeError, g as extractLinksInputShape, gt as shutdownOnSignals, h as extractLinksInputSchema, i as extractGridOutputShape, it as addPreset, j as readHtmlFile, k as outlineInputShape, l as outlineOutputShape, lt as logger, m as extractGridInputShape, n as registerExtractTool, nt as isElement, o as extractListOutputShape, ot as presetForSite, p as extractGridInputSchema, pt as toErrorResult, q as formatPayload, r as chunkTextOutputShape, rt as registerResources, s as extractMetadataOutputShape, st as removePreset, t as extractArticleFromHtml, tt as buildDocument, u as outputSchemaShape, ut as loadConfig, v as extractListInputShape, w as extractTablesInputShape, x as extractSectionInputSchema, y as extractMetadataInputSchema, z as toMarkdown } from "./assets/extract-Cyv5qfGN.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { Readability } from "@mozilla/readability";
-//#region src/preset-cache.ts
-var PRESETS_DIR_ENV = "READABILITY_PRESETS_DIR";
-var presetFileSchema = z.object({
-	site: z.string().min(1),
-	detectors: z.array(z.string().min(1)).min(1),
-	scope: z.object({
-		include: z.string().min(1).optional(),
-		exclude: z.array(z.string().min(1)).min(1).optional()
-	}).refine((scope) => scope.include !== void 0 || scope.exclude !== void 0, { message: "scope must carry include or exclude" })
-});
-function resolvePresetsDir(env = process.env) {
-	const override = env[PRESETS_DIR_ENV];
-	if (override !== void 0) return override.trim() === "" ? void 0 : override;
-	const root = env.XDG_CACHE_HOME || join(homedir(), process.platform === "darwin" ? "Library/Caches" : ".cache");
-	return join(root, "readability", "presets");
-}
-function loadPresetDir(dir) {
-	let names;
-	try {
-		names = readdirSync(dir).filter((name) => name.endsWith(".json")).sort();
-	} catch (err) {
-		if (err.code === "ENOENT") logger.debug(`no preset directory at ${dir}`);
-		else logger.warn(`preset directory unreadable: ${dir}`);
-		return {
-			loaded: 0,
-			pruned: 0,
-			skipped: 0
-		};
-	}
-	const ranked = rankPresetFiles(dir, names);
-	const pruned = pruneRanked(dir, ranked.slice(64));
-	let loaded = 0;
-	let skipped = 0;
-	for (const { name } of ranked.slice(0, 64)) if (loadPresetFile(join(dir, name))) loaded++;
-	else skipped++;
-	if (loaded > 0) logger.info(`loaded ${loaded} site preset(s) from ${dir}`);
-	if (pruned > 0) logger.info(`pruned ${pruned} preset file(s) beyond the 64-file bound`);
-	return {
-		loaded,
-		pruned,
-		skipped
-	};
-}
-function loadPresets(env = process.env) {
-	const dir = resolvePresetsDir(env);
-	return dir ? loadPresetDir(dir) : void 0;
-}
-function rankPresetFiles(dir, names) {
-	const ranked = [];
-	for (const name of names) try {
-		ranked.push({
-			name,
-			mtimeMs: statSync(join(dir, name)).mtimeMs
-		});
-	} catch {}
-	ranked.sort((a, b) => b.mtimeMs - a.mtimeMs);
-	return ranked;
-}
-function pruneRanked(dir, ranked) {
-	let pruned = 0;
-	for (const { name } of ranked) try {
-		unlinkSync(join(dir, name));
-		pruned++;
-	} catch (err) {
-		logger.warn(`could not prune preset file ${name}: ${describeError(err)}`);
-	}
-	return pruned;
-}
-function savePreset(preset, env = process.env) {
-	const dir = resolvePresetsDir(env);
-	if (!dir) return {
-		persisted: false,
-		reason: "preset-directory-disabled"
-	};
-	const shape = presetFileSchema.safeParse(preset);
-	if (!shape.success) return {
-		persisted: false,
-		reason: shape.error.issues[0]?.message ?? "invalid preset shape"
-	};
-	const key = normalizeSiteKey(preset.site);
-	if (!key) return {
-		persisted: false,
-		reason: "site-is-not-a-hostname"
-	};
-	const path = join(dir, `${key}.json`);
-	try {
-		mkdirSync(dir, { recursive: true });
-		writeFileSync(path, `${JSON.stringify(shape.data, null, 2)}\n`);
-	} catch (err) {
-		return {
-			persisted: false,
-			reason: describeError(err)
-		};
-	}
-	pruneRanked(dir, rankPresetFiles(dir, readdirSync(dir).filter((name) => name.endsWith(".json"))).slice(64));
-	return {
-		path,
-		persisted: true
-	};
-}
-function loadPresetFile(path) {
-	let parsed;
-	try {
-		parsed = JSON.parse(readFileSync(path, "utf8"));
-	} catch (err) {
-		logger.warn(`${path}: not readable JSON (${describeError(err)}), preset skipped`);
-		return false;
-	}
-	const result = presetFileSchema.safeParse(parsed);
-	if (!result.success) {
-		logger.warn(`${path}: ${result.error.issues[0]?.message}, preset skipped`);
-		return false;
-	}
-	if (!normalizeSiteKey(result.data.site)) {
-		logger.warn(`${path}: site is not a hostname, preset skipped`);
-		return false;
-	}
-	addPreset(result.data);
-	return true;
-}
-//#endregion
-//#region src/host-sampling.ts
-var SAMPLING_TIMEOUT_MS = 3e5;
-async function sampleText$1(server, args) {
-	const result = await server.server.createMessage({
-		messages: [{
-			role: "user",
-			content: {
-				type: "text",
-				text: args.userText
-			}
-		}],
-		systemPrompt: args.systemPrompt,
-		maxTokens: args.maxTokens
-	}, { timeout: SAMPLING_TIMEOUT_MS });
-	if (result.content.type !== "text") throw new Error(`host sampling returned non-text content (${result.content.type})`);
-	return result.content.text;
-}
-var SuggestParseError = class extends Error {
-	rawText;
-	constructor(message, rawText) {
-		super(message);
-		this.rawText = rawText;
-	}
-};
-function extractJsonReply(text) {
-	const trimmed = text.replace(/^[\s\S]*?```(?:json)?\s*\n?([\s\S]*?)\n?```[\s\S]*$/, "$1").trim();
-	try {
-		return JSON.parse(trimmed);
-	} catch {
-		const start = trimmed.indexOf("{");
-		const end = trimmed.lastIndexOf("}");
-		if (start !== -1 && end > start) try {
-			return JSON.parse(trimmed.slice(start, end + 1));
-		} catch {}
-		throw new SuggestParseError(`host sampling returned text that does not parse as JSON (${trimmed.slice(0, 80)}…)`, trimmed);
-	}
-}
-async function sampleJson(server, args) {
-	return extractJsonReply(await sampleText$1(server, args));
-}
-var DEBRIS_PROBES = [
-	{
-		label: "player-controls",
-		pattern: /Loaded:\s*\d+%/
-	},
-	{
-		label: "player-controls",
-		pattern: /Duration Time \d+:\d\d/
-	},
-	{
-		label: "metered-barrier",
-		pattern: /read your last free article|subscribe to continue reading/i
-	}
-];
-function assessLostSignal(input) {
-	const wordCount = countWords(input.contentText);
-	const nearEmpty = wordCount < 120;
-	const debrisProbes = [...new Set(DEBRIS_PROBES.filter((probe) => probe.pattern.test(input.contentText)).map((probe) => probe.label))];
-	const reasons = [
-		...input.fallbackUsed ? ["fallback-used"] : [],
-		...nearEmpty ? ["near-empty"] : [],
-		...debrisProbes.map((label) => `debris:${label}`)
-	];
-	return {
-		debrisProbes,
-		fallbackUsed: input.fallbackUsed,
-		gatedReason: input.gated?.likely ? input.gated.reason : void 0,
-		nearEmpty,
-		reasons,
-		wordCount
-	};
-}
-var PRICE_TABLE = {
-	"Upper:Lower": .2,
-	"Lower:Upper": .5,
-	"Symbol:Upper": .4,
-	"Symbol:Lower": .3,
-	"Symbol:Digit": .9,
-	"Upper:Digit": 1.4,
-	"Lower:Digit": 1.3,
-	"Digit:Upper": 1.4,
-	"Digit:Lower": 1.5,
-	"Digit:Symbol": 1.2,
-	"Upper:Symbol": .2,
-	"Lower:Symbol": .2,
-	"Digit:Digit": 1.2,
-	"Symbol:Symbol": .3,
-	"Upper:Upper": .1,
-	"Lower:Lower": .1,
-	"Other:Other": 0
-};
-function classifyChar(ch) {
-	if (/[A-Z]/.test(ch)) return "Upper";
-	if (/[a-z]/.test(ch)) return "Lower";
-	if (/[0-9]/.test(ch)) return "Digit";
-	if (/[-_]/.test(ch)) return "Symbol";
-	return "Other";
-}
-function transitionPrice(from, to) {
-	return PRICE_TABLE[`${from}:${to}`] ?? 1;
-}
-function gibberishScore(value) {
-	if (value.length < 2) return 0;
-	let absolute = 0;
-	let previous = null;
-	for (const ch of value) {
-		const current = classifyChar(ch);
-		if (previous !== null) absolute += transitionPrice(previous, current);
-		previous = current;
-	}
-	return absolute / Math.max(1, value.length - 1);
-}
-function exceedsThreshold(value) {
-	return value.length >= 4 && gibberishScore(value) >= .3;
-}
-function isGeneratedIdentifier(value) {
-	if (exceedsThreshold(value)) return true;
-	return value.split(/[-_]/).some((segment) => exceedsThreshold(segment));
-}
-var SAMPLE_MAX_CHARS = 80;
-var NON_CONTENT_SELECTOR = "script, style, noscript, template";
-var HOP_ATTRIBUTE_WHITELIST = [
-	"itemprop",
-	"role",
-	"data-testid"
-];
-function buildChainOutline(input) {
-	const { document } = buildDocument(input.html, input.baseUrl);
-	normalizeDocument(document, { cleanChrome: input.cleanChrome });
-	resolveLazyImages(document);
-	const scope = input.mode === "page" ? void 0 : input.mode.scope;
-	if (scope) applySelectors(document, scope);
-	const scopeRoot = scope?.include ? document.body.querySelector(scope.include) ?? void 0 : void 0;
-	const min = scope ? 40 : 200;
-	const candidates = [];
-	for (const element of (scopeRoot ?? document.body).querySelectorAll("*")) {
-		if (element.closest(NON_CONTENT_SELECTOR)) continue;
-		const own = ownTextLength(element);
-		if (own >= min) candidates.push({
-			element,
-			own
-		});
-	}
-	return scope ? groupedOutline(candidates, scopeRoot) : flatOutline(candidates);
-}
-function flatOutline(candidates) {
-	const lines = [];
-	let truncated = false;
-	for (const candidate of [...candidates].sort((a, b) => b.own - a.own)) {
-		if (lines.length >= 60) {
-			truncated = true;
-			break;
-		}
-		const line = ancestorsUpTo(candidate.element, void 0).map((element) => hopWithSizes(element)).join(" > ");
-		if (lines.join("\n---\n").length + line.length > 6e3) {
-			truncated = true;
-			break;
-		}
-		lines.push(line);
-	}
-	return {
-		chainCount: lines.length,
-		text: lines.join("\n---\n"),
-		truncated
-	};
-}
-function groupedOutline(candidates, scopeRoot) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const candidate of candidates) {
-		const chain = ancestorsUpTo(candidate.element, scopeRoot).map((element) => renderHop(element));
-		if (scopeRoot) chain.push(renderHop(scopeRoot));
-		const key = chain.join(" > ");
-		const existing = groups.get(key);
-		if (existing) {
-			existing.count += 1;
-			existing.min = Math.min(existing.min, candidate.own);
-			existing.max = Math.max(existing.max, candidate.own);
-		} else groups.set(key, {
-			chain: key,
-			count: 1,
-			min: candidate.own,
-			max: candidate.own,
-			sample: sampleText(candidate.element)
-		});
-	}
-	const lines = [];
-	let truncated = false;
-	const sorted = [...groups.values()].sort((a, b) => a.min - b.min);
-	for (const group of sorted) {
-		if (lines.length >= 60) {
-			truncated = true;
-			break;
-		}
-		const line = `${group.chain} (own:${group.min}..${group.max}, ×${group.count}) sample: "${group.sample}"`;
-		if (lines.join("\n").length + line.length > 6e3) {
-			truncated = true;
-			break;
-		}
-		lines.push(line);
-	}
-	return {
-		chainCount: lines.length,
-		text: lines.join("\n"),
-		truncated
-	};
-}
-function ancestorsUpTo(element, stop) {
-	const hops = [];
-	let node = element;
-	const body = element.ownerDocument.body;
-	while (node && node !== stop && node !== body) {
-		hops.push(node);
-		node = node.parentElement;
-	}
-	return hops;
-}
-function hopWithSizes(element) {
-	const own = ownTextLength(element);
-	const all = element.textContent.length;
-	return `${renderHop(element)} (own:${own}, all:${all})`;
-}
-function ownTextLength(element) {
-	let own = 0;
-	for (const node of element.childNodes) if (node.nodeType === node.TEXT_NODE) own += (node.textContent ?? "").length;
-	return own;
-}
-function renderHop(element) {
-	let hop = element.tagName.toLowerCase();
-	const id = element.id;
-	if (id && !isGeneratedIdentifier(id)) hop += `#${id}`;
-	const classes = (element.getAttribute("class") ?? "").split(/\s+/).filter(Boolean).filter((className) => !isGeneratedIdentifier(className));
-	if (classes.length > 0) hop += `.${classes.join(".")}`;
-	for (const attribute of HOP_ATTRIBUTE_WHITELIST) {
-		const value = element.getAttribute(attribute);
-		if (value) hop += `[${attribute}="${value}"]`;
-	}
-	return hop;
-}
-function sampleText(element) {
-	const text = element.textContent.trim().replace(/\s+/g, " ");
-	return text.length > SAMPLE_MAX_CHARS ? `${text.slice(0, SAMPLE_MAX_CHARS)}…` : text;
-}
-//#endregion
-//#region src/policy/selector-lint.ts
-var POSITIONAL_PSEUDO_RE = /:(?:nth(?:-last)?(?:-child|-of-type)|first(?:-child|-of-type)|last(?:-child|-of-type)|only(?:-child|-of-type))\b/i;
-var CONTAINS_PSEUDO_RE = /:contains\s*\(/i;
-function quotedSegmentsOut(selector) {
-	return selector.replace(/(["'])(?:\\.|(?!\1)[\s\S])*\1/g, "\"\"");
-}
-function identifierTokens(selector) {
-	return [...quotedSegmentsOut(selector).matchAll(/[.#]([A-Za-z0-9_-]+)/g)].map((match) => match[1]);
-}
-function lintSelectorText(selector) {
-	if (CONTAINS_PSEUDO_RE.test(selector)) return {
-		kind: "contains-pseudo",
-		selector,
-		detail: ":contains is not standard CSS and changes the result silently"
-	};
-	const positional = POSITIONAL_PSEUDO_RE.exec(selector);
-	if (positional) return {
-		kind: "positional-pseudo",
-		selector,
-		detail: `${positional[0]} depends on this page's child order, not the site's layout`
-	};
-	for (const token of identifierTokens(selector)) if (isGeneratedIdentifier(token)) return {
-		kind: "generated-identifier",
-		selector,
-		detail: `"${token}" reads as a generated hash that changes on deploy`
-	};
-}
-function lintProposal({ document, detectors, scope }) {
-	const violations = [];
-	const selectors = [
-		...detectors,
-		...scope.include ? [scope.include] : [],
-		...scope.exclude ?? []
-	];
-	for (const selector of selectors) {
-		const violation = lintSelectorText(selector);
-		if (violation) violations.push(violation);
-	}
-	let includeRoot;
-	if (scope.include && !violations.some((violation) => violation.selector === scope.include)) try {
-		includeRoot = document.body.querySelector(scope.include) ?? void 0;
-	} catch {
-		violations.push({
-			kind: "unparseable",
-			selector: scope.include,
-			detail: "the selector engine rejects this selector"
-		});
-	}
-	for (const detector of detectors) {
-		if (violations.some((violation) => violation.selector === detector)) continue;
-		if (selectorMisses(document, detector)) violations.push({
-			kind: "no-match",
-			selector: detector,
-			detail: "detector matches nothing on this page"
-		});
-	}
-	if (scope.include && !includeRoot && !violations.some((violation) => violation.selector === scope.include)) violations.push({
-		kind: "no-match",
-		selector: scope.include,
-		detail: "include matches nothing inside <body>, where applySelectors searches"
-	});
-	for (const selector of scope.exclude ?? []) {
-		if (violations.some((violation) => violation.selector === selector)) continue;
-		try {
-			if (document.querySelectorAll(selector).length === 0) violations.push({
-				kind: "no-match",
-				selector,
-				detail: "exclude matches nothing on this page"
-			});
-		} catch {
-			violations.push({
-				kind: "unparseable",
-				selector,
-				detail: "the selector engine rejects this selector"
-			});
-		}
-	}
-	if (includeRoot) for (const selector of scope.exclude ?? []) {
-		if (violations.some((violation) => violation.selector === selector)) continue;
-		try {
-			for (const match of document.querySelectorAll(selector)) if (match.contains(includeRoot)) {
-				violations.push({
-					kind: "exclude-shadows-include",
-					selector,
-					detail: "this exclude removes the include root itself"
-				});
-				break;
-			}
-		} catch {}
-	}
-	return violations;
-}
-//#endregion
-//#region src/tools/suggest-preset.ts
-var SUGGEST_SYSTEM_PROMPT = `You propose site-level CSS presets for a web-article extractor. The extractor removes every "exclude" match document-wide, then keeps the FIRST match of "include" in document order as the entire page body (the search runs inside <body>). An exclude matching an ancestor of the include root destroys it.
-
-Rules:
-- "include": exactly ONE selector that matches an element inside <body> on THIS page. A non-matching selector silently does nothing.
-- "exclude": selectors naming debris containers (video players, carousels, caption figures, comment blocks, promo modules).
-- "detectors": 1-3 selectors naming stable site-template containers that also match on other pages of the same site. Their loss is what retires the preset, so they must be structural, not per-page.
-- Forbidden — statically rejected and fed back to you: :nth-child and every positional pseudo (:first-child, :last-of-type, :only-child, ...), :contains, and generated hash class names (css-1a2b3c, content_1tsiE, BoxStyles_x__Wo6Z4).
-- Prefer itemprop, role, data-testid, ids, and stable class-name stems; quote attribute values exactly as rendered in the material.
-- The material shows every text-bearing node as a CSS chain with text sizes. It deliberately carries no article prose.
-Return strict JSON only — no prose, no code fences.`;
-var suggestPresetInputShape = {
-	localPath: localPathField,
-	baseUrl: z.url().describe("A URL of the site the page belongs to — its host names the preset. Required: without a host there is no site key to store a preset under, and presets only resolve for pages whose site matches."),
-	secondPath: localPathField.optional().describe("A second capture of the SAME site. The converged preset must verify on it too — detectors match, extraction clean — before anything is persisted; without it the preset is verified on the proposal page alone."),
-	maxSamplingCalls: z.number().int().min(1).max(8).describe("Upper bound on host-model sampling calls for this run. Round one (include + detectors) and round two (excludes) each consume a call, rejected proposals consume retries. A budget of 1 skips round two.").default(4)
-};
-var suggestPresetInputSchema = z.object(suggestPresetInputShape);
-var proposalSchema = z.object({
-	detectors: z.array(z.string().min(1)).min(1).max(6),
-	scope: z.object({
-		include: z.string().min(1),
-		exclude: z.array(z.string().min(1)).max(12).optional()
-	})
-});
-var excludeProposalSchema = z.object({ exclude: z.array(z.string().min(1)).max(12) });
-var MAX_SAMPLING_TOKENS = 8192;
-var SUGGEST_PRESET_TOOL_DESCRIPTION = `Ask the HOST's model to propose a site preset (detectors + selectors) for a page whose extraction was lost, then verify it: proposals are validated deterministically, applied through the real pipeline, and a converged preset is stored in memory and persisted to the local preset cache so later extractions of the same site apply it automatically. Runs a bounded two-round loop over MCP \`sampling/createMessage\` — the server embeds no model. The tool is only listed when the connected client advertises the sampling capability, and it refuses to run when the baseline extraction looks healthy: call it after \`extract\` reports gated content, a fallback extraction, a near-empty result, or visible debris such as video-player controls.`;
-var triggerShape = {
-	fired: z.boolean().describe("Whether the suggest loop ran at all."),
-	reasons: z.array(z.string()).describe("Why the loop ran (the lost signals observed on the baseline extraction), or why it refused."),
-	wordCount: z.number().describe("Word count of the baseline extraction; 0 when the loop never ran."),
-	debrisProbes: z.array(z.string()).describe("Debris signatures matched in the baseline extraction text."),
-	gatedReason: z.string().optional().describe("The gating signal reported by the baseline extraction, if any.")
-};
-var suggestPresetOutputShape = {
-	schemaVersion: z.literal(1).describe("Structured-content schema version."),
-	content: z.string().describe("Human-readable report of the run."),
-	trigger: z.object(triggerShape).describe("Baseline lost-signal verdict."),
-	preset: z.object({
-		site: z.string().describe("The host the preset is keyed by."),
-		detectors: z.array(z.string()).describe("Template fingerprints that must keep matching."),
-		scope: z.object({
-			include: z.string().optional(),
-			exclude: z.array(z.string()).optional()
-		}).describe("The accepted selector scope.")
-	}).optional().describe("The preset that converged, present only when one was accepted and verified."),
-	verification: z.object({
-		applied: z.boolean().describe("Whether the stored preset resolved and applied during the verification extraction."),
-		converged: z.boolean().describe("Whether the verification extraction came back clean."),
-		verifiedPages: z.number().int().min(1).max(2).describe("Pages the preset verified on: 2 only when secondPath was given and the preset verified on that capture too."),
-		wordCountBefore: z.number().describe("Baseline extraction word count."),
-		wordCountAfter: z.number().describe("Verification extraction word count.")
-	}).optional().describe("Result of extracting with the preset actually stored."),
-	secondVerification: z.object({
-		applied: z.boolean().describe("Whether the preset resolved and applied on the second capture."),
-		converged: z.boolean().describe("Whether the second-capture extraction came back clean."),
-		wordCountAfter: z.number().describe("Second-capture extraction word count.")
-	}).optional().describe("Verification on the secondPath capture; absent when secondPath was not given or the capture belongs to another site."),
-	persistence: z.object({
-		persisted: z.boolean().describe("Whether the preset file was written to the local preset cache directory."),
-		path: z.string().optional().describe("The file written, when persisted."),
-		reason: z.string().optional().describe("Why nothing was persisted, when it was not.")
-	}).optional().describe("Outcome of the disk write; absent when the run never accepted a preset."),
-	sampling: z.object({
-		calls: z.number().int().describe("Sampling calls actually made."),
-		budget: z.number().int().describe("The budget this run was given."),
-		budgetExhausted: z.boolean().describe("Whether the budget ran out before the loop could converge.")
-	}).describe("Sampling accounting for this run.")
-};
-function registerSuggestPresetTool(server) {
-	return server.registerTool("suggest_preset", {
-		title: "Suggest a site preset using the host model",
-		description: SUGGEST_PRESET_TOOL_DESCRIPTION,
-		inputSchema: suggestPresetInputShape,
-		outputSchema: suggestPresetOutputShape
-	}, async (rawArgs) => {
-		const args = suggestPresetInputSchema.parse(rawArgs);
-		try {
-			return await runSuggestLoop(args, server);
-		} catch (err) {
-			logger.error(`suggest_preset failed: ${describeError(err)}`);
-			return toErrorResult(err);
-		}
-	});
-}
-async function runSuggestLoop(args, server) {
-	const site = normalizeSiteKey(args.baseUrl);
-	if (!site) throw new Error(`baseUrl does not name a site: ${args.baseUrl}`);
-	const html = readHtmlFile(args.localPath);
-	const secondHtml = args.secondPath ? readHtmlFile(args.secondPath) : void 0;
-	const state = {
-		budget: args.maxSamplingCalls,
-		calls: 0,
-		exhausted: false
-	};
-	if (presetForSite(site)) return report(state, { trigger: {
-		debrisProbes: [],
-		fired: false,
-		reasons: ["preset-exists"],
-		wordCount: 0
-	} });
-	const baseline = extractText(html, args.baseUrl);
-	const canonicalSite = normalizeSiteKey(baseline.metadata.canonical);
-	if (canonicalSite && canonicalSite !== site) throw new Error(`baseUrl names ${site} but the page's canonical URL names ${canonicalSite} — the capture does not belong to the site the preset would be keyed by.`);
-	const baselineEvidence = assessLostSignal({
-		contentText: baseline.content,
-		fallbackUsed: baseline.diagnostics.fallbackUsed ?? false,
-		gated: baseline.diagnostics.gated
-	});
-	const trigger = {
-		debrisProbes: baselineEvidence.debrisProbes,
-		fired: baselineEvidence.reasons.length > 0,
-		gatedReason: baselineEvidence.gatedReason,
-		reasons: baselineEvidence.reasons,
-		wordCount: baselineEvidence.wordCount
-	};
-	if (!trigger.fired) return report(state, { trigger });
-	const core = await proposeCore(html, args.baseUrl, site, baseline, trigger, state, server);
-	if (!core) return report(state, { trigger });
-	const excludes = await proposeExcludes(html, args.baseUrl, core, state, server);
-	const preset = {
-		detectors: core.detectors,
-		site,
-		scope: {
-			exclude: excludes.length > 0 ? excludes : void 0,
-			include: core.scope.include
-		}
-	};
-	addPreset({
-		detectors: preset.detectors,
-		scope: preset.scope,
-		site: preset.site
-	});
-	const verification = extractText(html, args.baseUrl);
-	const verificationEvidence = assessLostSignal({
-		contentText: verification.content,
-		fallbackUsed: verification.diagnostics.fallbackUsed ?? false,
-		gated: verification.diagnostics.gated
-	});
-	const applied = verification.presetSignal?.applied === true;
-	const converged = applied && verificationEvidence.reasons.length === 0;
-	const verdict = {
-		applied,
-		converged,
-		verifiedPages: 1,
-		wordCountAfter: verificationEvidence.wordCount,
-		wordCountBefore: trigger.wordCount
-	};
-	if (!converged) {
-		removePreset(preset.site);
-		state.persistence = {
-			persisted: false,
-			reason: "not-converged"
-		};
-		return report(state, {
-			preset,
-			trigger,
-			verification: verdict
-		});
-	}
-	let secondVerification;
-	if (secondHtml) {
-		const second = extractText(secondHtml, args.baseUrl);
-		const secondCanonicalSite = normalizeSiteKey(second.metadata.canonical);
-		if (secondCanonicalSite && secondCanonicalSite !== site) {
-			removePreset(preset.site);
-			state.persistence = {
-				persisted: false,
-				reason: "second-page-canonical-mismatch"
-			};
-			return report(state, {
-				preset,
-				trigger,
-				verification: verdict
-			});
-		}
-		const secondEvidence = assessLostSignal({
-			contentText: second.content,
-			fallbackUsed: second.diagnostics.fallbackUsed ?? false,
-			gated: second.diagnostics.gated
-		});
-		const secondApplied = second.presetSignal?.applied === true;
-		const secondConverged = secondApplied && secondEvidence.reasons.length === 0;
-		secondVerification = {
-			applied: secondApplied,
-			converged: secondConverged,
-			wordCountAfter: secondEvidence.wordCount
-		};
-		if (!secondConverged) {
-			removePreset(preset.site);
-			state.persistence = {
-				persisted: false,
-				reason: "second-page-not-converged"
-			};
-			return report(state, {
-				preset,
-				secondVerification,
-				trigger,
-				verification: verdict
-			});
-		}
-		verdict.verifiedPages = 2;
-	}
-	state.persistence = savePreset(preset);
-	return report(state, {
-		preset,
-		secondVerification,
-		trigger,
-		verification: verdict
-	});
-}
-function report(state, parts) {
-	const lines = [];
-	if (!parts.trigger.fired) lines.push(parts.trigger.reasons.length > 0 ? `No suggest loop run: ${parts.trigger.reasons.join(", ")}.` : `No suggest loop run: the baseline extraction looks healthy (${parts.trigger.wordCount} words, no lost signal).`);
-	else lines.push(`Lost signals on the baseline extraction (${parts.trigger.wordCount} words): ${parts.trigger.reasons.join(", ")}.`);
-	if (state.calls > 0) lines.push(`Sampling: ${state.calls}/${state.budget} call(s)${state.exhausted ? " — budget exhausted" : ""}.`);
-	if (parts.verification) lines.push(`Verification with the preset stored: applied=${parts.verification.applied}, converged=${parts.verification.converged}, ${parts.verification.wordCountAfter} words, pages verified: ${parts.verification.verifiedPages}.`);
-	if (parts.secondVerification) lines.push(`Second-page verification: applied=${parts.secondVerification.applied}, converged=${parts.secondVerification.converged}, ${parts.secondVerification.wordCountAfter} words.`);
-	if (parts.preset) lines.push(`Accepted preset for ${parts.preset.site}: include=${parts.preset.scope.include ?? "(none)"}, exclude=${(parts.preset.scope.exclude ?? []).join(", ") || "(none)"}, detectors=${parts.preset.detectors.join(", ")}.`);
-	if (state.persistence) lines.push(state.persistence.persisted ? `Persisted to ${state.persistence.path}.` : `Not persisted: ${state.persistence.reason}.`);
-	return {
-		content: [{
-			text: lines.join("\n"),
-			type: "text"
-		}],
-		structuredContent: {
-			content: lines.join("\n"),
-			persistence: state.persistence,
-			preset: parts.preset,
-			sampling: {
-				budget: state.budget,
-				budgetExhausted: state.exhausted,
-				calls: state.calls
-			},
-			schemaVersion: 1,
-			secondVerification: parts.secondVerification,
-			trigger: parts.trigger,
-			verification: parts.verification
-		}
-	};
-}
-function coreProposalUserText(site, title, evidence, outline, rejection) {
-	return [
-		`SITE: ${site}`,
-		`PAGE: ${title || "(untitled)"}`,
-		`BASELINE: ${evidence.wordCount} words; debris probes: ${evidence.debrisProbes.join(", ") || "none"}; gating: ${evidence.gatedReason ?? "none"}. The extraction lost to page junk — propose a preset.`,
-		"",
-		"MATERIAL — ancestor chains of every node holding at least 200 chars of its own text, hop format tag#id.classes[attr=\"value\"] (own:X, all:Y):",
-		outline.text,
-		...outline.truncated ? ["(material truncated at the budget — the largest own-text chains come first)"] : [],
-		...rejection ? [
-			"",
-			"YOUR PREVIOUS PROPOSAL WAS REJECTED:",
-			rejection,
-			"Return corrected strict JSON."
-		] : [""],
-		"Return JSON: {\"detectors\": [\"...\"], \"scope\": {\"include\": \"...\", \"exclude\": [\"...\"]}}"
-	].join("\n");
-}
-async function proposeCore(html, baseUrl, site, baseline, evidence, state, server) {
-	const outline = buildChainOutline({
-		baseUrl,
-		cleanChrome: true,
-		html,
-		mode: "page"
-	});
-	let rejection;
-	while (state.calls < state.budget) {
-		state.calls += 1;
-		let reply;
-		try {
-			reply = await sampleJson(server, {
-				maxTokens: MAX_SAMPLING_TOKENS,
-				systemPrompt: SUGGEST_SYSTEM_PROMPT,
-				userText: coreProposalUserText(site, baseline.metadata.title ?? "", evidence, outline, rejection)
-			});
-		} catch (err) {
-			if (err instanceof SuggestParseError) {
-				rejection = err.message;
-				continue;
-			}
-			throw err;
-		}
-		const parsed = proposalSchema.safeParse(reply);
-		if (!parsed.success) {
-			rejection = `the reply must parse as {"detectors": [...], "scope": {"include": "...", "exclude": [...]}} — ${parsed.error.issues[0]?.message}`;
-			continue;
-		}
-		const violations = lintProposal({
-			detectors: parsed.data.detectors,
-			document: normalizedDocument(html, baseUrl),
-			scope: parsed.data.scope
-		});
-		if (violations.length > 0) {
-			rejection = renderViolations(violations);
-			continue;
-		}
-		return {
-			detectors: parsed.data.detectors,
-			scope: {
-				exclude: parsed.data.scope.exclude,
-				include: parsed.data.scope.include
-			}
-		};
-	}
-	state.exhausted = true;
-}
-async function proposeExcludes(html, baseUrl, core, state, server) {
-	if (state.calls >= state.budget) return core.scope.exclude ?? [];
-	const outline = buildChainOutline({
-		baseUrl,
-		cleanChrome: true,
-		html,
-		mode: { scope: { include: core.scope.include } }
-	});
-	let rejection;
-	while (state.calls < state.budget) {
-		state.calls += 1;
-		let reply;
-		try {
-			reply = await sampleJson(server, {
-				maxTokens: MAX_SAMPLING_TOKENS,
-				systemPrompt: SUGGEST_SYSTEM_PROMPT,
-				userText: [
-					`ACCEPTED SO FAR: {"detectors": ${JSON.stringify(core.detectors)}, "scope": {"include": ${JSON.stringify(core.scope.include)}}}`,
-					"",
-					"MATERIAL — text blocks remaining inside the included subtree after the include was applied, grouped by chain, smallest own text first, each with a text sample:",
-					outline.text,
-					...rejection ? [
-						"",
-						"YOUR PREVIOUS PROPOSAL WAS REJECTED:",
-						rejection,
-						"Return corrected strict JSON."
-					] : [""],
-					"Propose excludes for the debris groups (video players, carousels, caption figures, comment blocks, promos) — never for prose paragraphs. Return [] if none. Return JSON: {\"exclude\": [\"...\"]}"
-				].join("\n")
-			});
-		} catch (err) {
-			if (err instanceof SuggestParseError) {
-				rejection = err.message;
-				continue;
-			}
-			throw err;
-		}
-		const parsed = excludeProposalSchema.safeParse(reply);
-		if (!parsed.success) {
-			rejection = `the reply must parse as {"exclude": ["..."]} — ${parsed.error.issues[0]?.message}`;
-			continue;
-		}
-		const violations = lintProposal({
-			detectors: core.detectors,
-			document: normalizedDocument(html, baseUrl),
-			scope: {
-				exclude: parsed.data.exclude,
-				include: core.scope.include
-			}
-		});
-		if (violations.length > 0) {
-			rejection = renderViolations(violations);
-			continue;
-		}
-		const merged = [...core.scope.exclude ?? []];
-		for (const selector of parsed.data.exclude) if (!merged.includes(selector)) merged.push(selector);
-		return merged;
-	}
-	state.exhausted = true;
-	return core.scope.exclude ?? [];
-}
-function renderViolations(violations) {
-	return violations.map((violation) => `- ${violation.kind}: ${violation.selector} — ${violation.detail}`).join("\n");
-}
-function normalizedDocument(html, baseUrl) {
-	const { document } = buildDocument(html, baseUrl);
-	normalizeDocument(document, { cleanChrome: true });
-	resolveLazyImages(document);
-	return document;
-}
-function extractText(html, baseUrl) {
-	const result = extractArticleFromHtml({
-		baseUrl,
-		cache: false,
-		format: "text",
-		html
-	});
-	if (result.isError || !result.structuredContent) throw new Error("extraction failed inside the suggest loop");
-	const structured = result.structuredContent;
-	return {
-		content: structured.content,
-		diagnostics: {
-			fallbackUsed: structured.diagnostics.fallbackUsed,
-			gated: structured.diagnostics.gated
-		},
-		metadata: structured.metadata,
-		presetSignal: structured.diagnostics.preset
-	};
-}
-//#endregion
-//#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("Ceiling on tokens the host model may generate, forwarded as `sampling/createMessage` maxTokens. Thinking counts toward it on thinking models, so a low value truncates the summary; the system prompt already asks for a concise one.").default(4096)
-};
-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) {
-	return sampleText$1(server, {
-		maxTokens: args.maxTokens,
-		systemPrompt: SUMMARIZE_SYSTEM_PROMPT,
-		userText: args.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: ${describeError(err)}`);
-			return toErrorResult(err);
-		}
-	});
-}
-function registerSamplingTools(server) {
-	return [registerSummarizeTool(server), registerSuggestPresetTool(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: ${describeError(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/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 groupChildrenByShape(container) {
-	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]);
-	}
-	return groups;
-}
-function describeSelector(el, maxClasses) {
-	const parts = [el.tagName.toLowerCase()];
-	const id = el.getAttribute("id");
-	if (id) parts.push(`#${id}`);
-	const cls = el.getAttribute("class");
-	if (cls) {
-		let used = 0;
-		for (const token of cls.trim().split(/\s+/)) {
-			if (token) {
-				parts.push(`.${token}`);
-				used += 1;
-			}
-			if (maxClasses !== void 0 && used >= maxClasses) break;
-		}
-	}
-	return parts.join("");
-}
-//#endregion
-//#region src/policy/explain.ts
-var DEFAULT_SNAPSHOT_MAX = 4e3;
-var DEFAULT_TOP_N = 5;
-function readScored(el) {
-	const score = el.readability?.contentScore;
-	if (typeof score !== "number") return null;
-	return {
-		className: typeof el.className === "string" ? el.className : "",
-		id: el.id,
-		score,
-		tag: el.tagName,
-		textLength: el.textContent.trim().length,
-		selector: describeSelector(el, 2)
-	};
-}
-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: ${describeError(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/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 = groupChildrenByShape(container);
-		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: ${describeError(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: ${describeError(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 = groupChildrenByShape(container);
-		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: ${describeError(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: ${describeError(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 },
-		resolvePreset: false
-	});
-	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 },
-		resolvePreset: false
-	});
-}
-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: ${describeError(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: ${describeError(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: ${describeError(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: ${describeError(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();
-	loadPresets();
-	registerTools(server);
-	registerResources(server);
-	server.server.oninitialized = () => {
-		registerCapabilityGatedTools(server);
-	};
-	return server;
-}
-//#endregion
-//#region src/index.ts
-if (process.argv[2] === "extract") import("./assets/cli-BE_Ml3rh.js").then((m) => m.runCli(process.argv.slice(2))).then((code) => {
-	process.exit(code);
-}).catch((err) => {
-	process.stderr.write(`${describeError(err)}\n`);
-	process.exit(1);
-});
-else {
-	const server = createServer();
-	const transport = new StdioServerTransport();
-	await server.connect(transport);
-	shutdownOnSignals([server]);
-}
-//#endregion
-export {};
-
-//# sourceMappingURL=index.js.map