dsh-ab-wechat-scrape 0.4.0

package/lib/index.js

@@ -0,0 +1,2523 @@
+import { isAbsolute, join, resolve } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region lib/html.js
+/**
+* Pure page parsing for mp.weixin.qq.com articles: HTML entity and inline-script
+* string decoding, metadata lookup, balanced body extraction, interstitial
+* redirect resolution, and the detection of block, verification, and withdrawn
+* pages. No I/O and no DOM library, so tests drive every rule directly.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/html
+*/
+const NAMED_ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " ",
+	ensp: " ",
+	emsp: " ",
+	ldquo: "“",
+	rdquo: "”",
+	lsquo: "‘",
+	rsquo: "’",
+	hellip: "…",
+	mdash: "—",
+	ndash: "–",
+	middot: "·",
+	copy: "©"
+};
+/** Block-page markers WeChat serves instead of an article. */
+const BLOCK_MARKERS = [
+	"环境异常",
+	"去验证",
+	"请在微信客户端打开链接",
+	"访问过于频繁",
+	"操作频繁",
+	"参数错误",
+	"完成验证",
+	"wappoc_appmsg",
+	"poc_token"
+];
+/** Response-URL shapes WeChat redirects a throttled or unverified request to. */
+const BLOCK_URL_PATTERNS = [
+	/\/mp\/wappoc_appmsg/i,
+	/\/mp\/verify/i,
+	/\/mp\/captcha/i,
+	/poc_token=/i
+];
+/**
+* Page markers WeChat serves when an article is gone rather than withheld:
+* the publisher withdrew it, a reviewer removed it, or the account itself was
+* closed. Rendering cannot recover any of these, and none of them is an
+* article, so a page carrying one is never saved.
+*/
+const UNAVAILABLE_MARKERS = [
+	"该内容已被发布者删除",
+	"该内容因违规无法查看",
+	"该内容已被删除",
+	"此内容因违规无法查看",
+	"此内容已被发布者删除",
+	"此内容发送失败无法查看",
+	"该账号已被屏蔽",
+	"该公众号已注销",
+	"文章已被删除",
+	"内容不存在",
+	"链接已失效"
+];
+/** One attribute of an opening tag, double- or single-quoted. */
+const ATTRIBUTE = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** One opening tag, closing tag, comment, or run of text. */
+const TAG = /<([a-zA-Z][a-zA-Z0-9-]*)((?:"[^"]*"|'[^']*'|[^>"'])*?)(\/?)>/g;
+/** The inline-script shapes that hand the browser the real article link. */
+const REDIRECT_PATTERNS = [
+	/(?:var\s+)?msg_link\s*[:=]\s*"((?:\\[\s\S]|[^"\\])*)"/,
+	/(?:var\s+)?msg_link\s*[:=]\s*'((?:\\[\s\S]|[^'\\])*)'/,
+	/window\.location\.replace\(\s*"([^"]+)"\s*\)/,
+	/window\.location\.replace\(\s*'([^']+)'\s*\)/,
+	/location\.href\s*[:=]\s*"([^"]+)"/,
+	/location\.href\s*[:=]\s*'([^']+)'/
+];
+/** One code point as a character, or the original text when it is out of range. */
+function codePoint(code, fallback) {
+	return Number.isInteger(code) && code >= 0 && code <= 1114111 ? String.fromCodePoint(code) : fallback;
+}
+/**
+* Decode named and numeric HTML entities.
+* @param text - text carrying entity references.
+* @returns the same text with every known reference replaced.
+*/
+function decodeEntities(text) {
+	return text.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (match, body) => {
+		if (/^#x/i.test(body)) return codePoint(Number.parseInt(body.slice(2), 16), match);
+		if (body.startsWith("#")) return codePoint(Number.parseInt(body.slice(1), 10), match);
+		const named = NAMED_ENTITIES[body.toLowerCase()];
+		return named === void 0 ? match : named;
+	});
+}
+/**
+* Decode the string-literal escapes WeChat embeds in its inline scripts.
+* @param raw - the literal body, without its surrounding quotes.
+* @returns the decoded text.
+*/
+function decodeJsString(raw) {
+	return decodeEntities(raw.replace(/\\(u[0-9a-f]{4}|x[0-9a-f]{2}|[\s\S])/gi, (match, escape) => {
+		const kind = escape.charAt(0);
+		if (kind === "u" || kind === "x") return codePoint(Number.parseInt(escape.slice(1), 16), match);
+		if (escape === "n") return "\n";
+		if (escape === "r") return "\r";
+		if (escape === "t") return "	";
+		return escape;
+	}));
+}
+/**
+* Read one opening tag's attributes into a lookup keyed by lower-case name.
+* @param tag - the opening tag text.
+* @returns decoded attribute values; the last occurrence of a name wins.
+*/
+function parseAttributes(tag) {
+	const attributes = /* @__PURE__ */ new Map();
+	ATTRIBUTE.lastIndex = 0;
+	let match;
+	while ((match = ATTRIBUTE.exec(tag)) !== null) {
+		const name = match[1];
+		const value = match[2] ?? match[3];
+		if (name === void 0 || value === void 0) continue;
+		attributes.set(name.toLowerCase(), decodeEntities(value).trim());
+	}
+	return attributes;
+}
+/**
+* Read one meta tag's content by its property or name.
+* @param html - complete page HTML.
+* @param key - the property or name to match, case-insensitive.
+* @returns the decoded content, or an empty string when no such tag exists.
+*/
+function metaContent(html, key) {
+	const wanted = key.toLowerCase();
+	const tags = /<meta\b[^>]*>/gi;
+	let match;
+	while ((match = tags.exec(html)) !== null) {
+		const attributes = parseAttributes(match[0]);
+		if ((attributes.get("property") ?? attributes.get("name") ?? "").toLowerCase() === wanted) return attributes.get("content") ?? "";
+	}
+	return "";
+}
+/** Escape one literal so it can be embedded in a regular expression. */
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^(){}|[\]\\]/g, "\\$&");
+}
+/** The first quoted literal inside one script expression, decoded. */
+function firstQuoted(expression) {
+	const match = /"((?:\\[\s\S]|[^"\\])*)"|'((?:\\[\s\S]|[^'\\])*)'/.exec(expression);
+	const value = match?.[1] ?? match?.[2];
+	return value === void 0 ? "" : decodeJsString(value).trim();
+}
+/**
+* Read one inline-script variable by name. The page assigns both bare literals
+* and wrapped ones (htmlDecode("..."), "....html(false)"), so the whole
+* right-hand expression is read and its first quoted literal decoded.
+* @param html - complete page HTML.
+* @param variable - the variable to read, case-sensitive.
+* @returns the decoded value, or an empty string when the page carries none.
+*/
+function jsString(html, variable) {
+	const pattern = new RegExp("\\bvar\\s+" + escapeRegExp(variable) + "\\s*=\\s*([^\\n;]*)", "g");
+	let match;
+	while ((match = pattern.exec(html)) !== null) {
+		const value = firstQuoted(match[1] ?? "");
+		if (value !== "") return value;
+	}
+	return "";
+}
+/**
+* Extract the inner HTML of the first element carrying one id. Tag depth is
+* counted, so nested elements of the same name cannot end the slice early.
+* @param html - complete page HTML.
+* @param id - the id attribute value the opening tag must carry.
+* @returns the inner HTML, or an empty string when no such element exists.
+*/
+function elementById(html, id) {
+	TAG.lastIndex = 0;
+	let match;
+	while ((match = TAG.exec(html)) !== null) {
+		const name = match[1];
+		if (name === void 0) continue;
+		if (parseAttributes(match[0]).get("id") !== id) continue;
+		const element = name.toLowerCase();
+		const contentStart = match.index + match[0].length;
+		const walk = new RegExp("<" + element + "\\b|</" + element + "\\s*>", "gi");
+		walk.lastIndex = contentStart;
+		let depth = 1;
+		let step;
+		while ((step = walk.exec(html)) !== null) if (step[0].startsWith("</")) {
+			depth -= 1;
+			if (depth === 0) return html.slice(contentStart, step.index);
+		} else depth += 1;
+		return html.slice(contentStart);
+	}
+	return "";
+}
+/**
+* Decode entities, drop tags, and collapse whitespace into readable text.
+* @param html - markup to flatten.
+* @returns the element text with every run of whitespace collapsed to one space.
+*/
+function textOf(html) {
+	return decodeEntities(html.replace(/<[^>]*>/g, " ")).replace(/\s+/g, " ").trim();
+}
+/**
+* Resolve the real article URL an interstitial or short link hands the browser.
+* @param html - the page that came back for the requested link.
+* @returns an mp.weixin.qq.com article URL, or an empty string when none is named.
+*/
+function findRedirectUrl(html) {
+	for (const pattern of REDIRECT_PATTERNS) {
+		const raw = pattern.exec(html)?.[1];
+		if (raw === void 0 || raw.length === 0) continue;
+		const url = decodeJsString(raw).trim();
+		if (isMpArticleUrl(url)) return url;
+	}
+	return "";
+}
+/**
+* Whether a link names an official-account article host.
+* @param url - the candidate link.
+* @returns true for an http(s) mp.weixin.qq.com link.
+*/
+function isMpArticleUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return false;
+	}
+	return (parsed.protocol === "https:" || parsed.protocol === "http:") && (parsed.hostname === "mp.weixin.qq.com" || parsed.hostname.endsWith(".mp.weixin.qq.com"));
+}
+/**
+* Whether a link names one official-account article rather than another page on
+* the same host. A collection page lives under /mp/appmsgalbum and an article
+* under /s, so the path decides.
+* @param url - the candidate link.
+* @returns true for an http(s) mp.weixin.qq.com /s link.
+*/
+function isMpArticleLink(url) {
+	if (!isMpArticleUrl(url)) return false;
+	const path = new URL(url).pathname;
+	return path === "/s" || path.startsWith("/s/");
+}
+/**
+* The block-page marker a page carries.
+* @param html - complete page HTML.
+* @returns the marker found in the page head, or an empty string for a normal page.
+*/
+function detectBlock(html) {
+	const head = html.slice(0, 4e4);
+	for (const marker of BLOCK_MARKERS) if (head.includes(marker)) return marker;
+	return "";
+}
+/**
+* The verification redirect a response URL names, which the body may not mention.
+* @param url - the final response URL.
+* @returns the matched URL fragment, or an empty string for a normal article URL.
+*/
+function detectBlockUrl(url) {
+	for (const pattern of BLOCK_URL_PATTERNS) {
+		const match = pattern.exec(url);
+		if (match !== null) return match[0];
+	}
+	return "";
+}
+/**
+* The withdrawal marker a page carries.
+* @param html - complete page HTML.
+* @returns the marker found in the page head, or an empty string for a page that
+* is not reporting a withdrawn or removed article.
+*/
+function detectUnavailable(html) {
+	const head = html.slice(0, 4e4);
+	for (const marker of UNAVAILABLE_MARKERS) if (head.includes(marker)) return marker;
+	return "";
+}
+/**
+* Collect the content image URLs in document order, preferring lazy data-src.
+* @param bodyHtml - the article body HTML.
+* @returns absolute http(s) image URLs, de-duplicated.
+*/
+function extractImages(bodyHtml) {
+	const images = [];
+	const seen = /* @__PURE__ */ new Set();
+	const tags = /<img\b[^>]*>/gi;
+	let match;
+	while ((match = tags.exec(bodyHtml)) !== null) {
+		const attributes = parseAttributes(match[0]);
+		const src = attributes.get("data-src") ?? attributes.get("src") ?? "";
+		if (src === "" || src.startsWith("data:") || !/^https?:/i.test(src) || seen.has(src)) continue;
+		seen.add(src);
+		images.push(src);
+	}
+	return images;
+}
+/**
+* Normalize a page timestamp to ISO 8601.
+* @param raw - the page's own timestamp text.
+* @returns an ISO timestamp, the unchanged text when it is not a time, or an empty string.
+*/
+function toIsoTime(raw) {
+	const trimmed = raw.trim();
+	if (trimmed === "") return "";
+	if (/^\d{9,11}$/.test(trimmed)) return (/* @__PURE__ */ new Date(Number.parseInt(trimmed, 10) * 1e3)).toISOString();
+	const parsed = new Date(trimmed);
+	return Number.isNaN(parsed.getTime()) ? trimmed : parsed.toISOString();
+}
+/** The first non-empty value, trimmed. */
+function firstNonEmpty(values) {
+	for (const value of values) {
+		const trimmed = value.trim();
+		if (trimmed !== "") return trimmed;
+	}
+	return "";
+}
+/**
+* Parse one page into article facts, a block report, or an empty result.
+* @param html - complete page HTML.
+* @returns the extraction outcome the caller turns into the canonical value.
+*/
+function extractArticle(html) {
+	const marker = detectBlock(html);
+	if (marker !== "") return {
+		kind: "blocked",
+		marker
+	};
+	const bodyHtml = elementById(html, "js_content");
+	if (bodyHtml.trim() === "") {
+		const reason = detectUnavailable(html);
+		if (reason !== "") return {
+			kind: "unavailable",
+			reason
+		};
+	}
+	const title = firstNonEmpty([
+		metaContent(html, "og:title"),
+		jsString(html, "msg_title"),
+		textOf(elementById(html, "activity-name"))
+	]);
+	const account = firstNonEmpty([
+		jsString(html, "nickname"),
+		textOf(elementById(html, "js_name")),
+		metaContent(html, "og:site_name")
+	]);
+	const author = firstNonEmpty([jsString(html, "author"), metaContent(html, "author")]);
+	const publishTime = firstNonEmpty([toIsoTime(jsString(html, "ct")), textOf(elementById(html, "publish_time"))]);
+	const digest = firstNonEmpty([jsString(html, "msg_desc"), metaContent(html, "description")]);
+	const cover = firstNonEmpty([jsString(html, "msg_cdn_url"), metaContent(html, "og:image")]);
+	if (bodyHtml.trim() === "" && title === "") return { kind: "empty" };
+	return {
+		kind: "article",
+		article: {
+			title,
+			account,
+			author,
+			publishTime,
+			digest,
+			cover,
+			bodyHtml,
+			images: extractImages(bodyHtml)
+		}
+	};
+}
+//#endregion
+//#region lib/clean.js
+/**
+* Promotional-block removal for WeChat article bodies. WeChat mixes ad
+* components, follow prompts, QR codes, and trailing "read more" lists into the
+* same body element as the article, so the body is filtered before it is
+* converted. Two rules run over the body HTML: a structural rule drops the
+* elements WeChat marks as advertising, and a text rule drops a short block
+* whose whole text is a follow or promotion prompt. The text rule never drops a
+* long block, so a section that carries the article cannot match it. Both rules
+* are the built-in ones; a deployment widens the text rule through
+* {@link CleanPolicy.patterns} and moves its length ceiling through
+* {@link CleanPolicy.maxPromoChars}.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/clean
+*/
+/** One opening tag, closing tag, comment, or run of text. */
+const TOKEN$1 = /<([a-zA-Z][a-zA-Z0-9-]*)((?:"[^"]*"|'[^']*'|[^>"'])*?)(\/?)>|<\/([a-zA-Z][a-zA-Z0-9-]*)>|<!--[\s\S]*?-->|[^<]+/g;
+/** Elements that never have children, so they never open a subtree. */
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+/** Elements that start a block of prose, the unit the text rule drops. */
+const BLOCK_ELEMENTS$1 = /* @__PURE__ */ new Set([
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"dd",
+	"div",
+	"dl",
+	"dt",
+	"figcaption",
+	"figure",
+	"footer",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"section",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"tr",
+	"ul"
+]);
+/** Custom elements and frames WeChat fills with advertising. */
+const AD_TAGS = /* @__PURE__ */ new Set([
+	"iframe",
+	"mp-common-mpa",
+	"mp-common-profile",
+	"mpcpc",
+	"mpa-ad",
+	"mp-ad",
+	"mp-common-mpa-ad"
+]);
+/** Element ids WeChat gives its follow prompts, QR codes, reward widgets, and ad slots. */
+const AD_IDS = /* @__PURE__ */ new Set([
+	"js_pc_qr_code",
+	"js_profile_qrcode",
+	"js_qr_code",
+	"js_reward_area",
+	"js_praise_area",
+	"js_star_area",
+	"js_follow_area",
+	"js_mp_ad_area",
+	"js_bottom_ad_area",
+	"js_ad_area",
+	"js_author_reward",
+	"js_reward_author",
+	"js_related_articles",
+	"js_article_bottom_ad",
+	"js_immersive_ad",
+	"js_ad_link",
+	"js_tags_area",
+	"js_like_area"
+]);
+/** A class or id token that names an advertising element. */
+const AD_ATTRIBUTE = /(?:^|[-_])ads?(?:[-_]|$)/i;
+/**
+* A class or id token that names a QR-code, reward, or subscription widget.
+* Anchored to the end of the token: an unanchored form would drop ordinary
+* content markup, because `like`, `zan`, and `follow` start English words too.
+*/
+const PROMO_ATTRIBUTE = /(?:^|[-_])(?:qrcode|qr_code|reward|praise|subscribe)(?:[-_](?:area|box|wrap|panel|btn|bar))?$/i;
+/** Element names whose whole content is a widget rather than article prose. */
+const WIDGET_ELEMENTS = /* @__PURE__ */ new Set([
+	"mp-common-qrcode",
+	"mp-common-reward",
+	"mp-common-follow",
+	"mp-common-vote"
+]);
+/** Text that makes a short block a follow or promotion prompt. */
+const PROMO_TEXT = [
+	/关注(?:我们|公众号|一下|本号|后)/,
+	/扫码关注/,
+	/长按(?:识别|二维码|关注)/,
+	/(?:点击|戳)上方(?:蓝字|关注)/,
+	/星标/,
+	/(?:点|戳)(?:个|一下)?(?:在看|赞)/,
+	/点亮(?:在看|赞)/,
+	/(?:分享|转发|收藏)到?(?:朋友圈|好友|群)/,
+	/往期(?:回顾|推荐|精选|文章)/,
+	/推荐阅读/,
+	/精彩(?:回顾|推荐)/,
+	/更多(?:精彩|内容)/,
+	/商务合作/,
+	/投稿/,
+	/^广告$/,
+	/广告位/,
+	/本条广告/,
+	/免责声明/,
+	/版权(?:归|所有)/,
+	/微信号[:：]/,
+	/阅读原文/,
+	/(?:长按|扫描|识别)(?:下方|上面)?二维码/,
+	/点击(?:下方|底部)?(?:阅读原文|了解更多)/,
+	/本文(?:为|系)(?:广告|推广|软文)/,
+	/(?:合作|推广|投稿)邮箱/,
+	/转载(?:请)?(?:注明|联系)/,
+	/(?:喜欢|觉得)不错[，,]?(?:请)?(?:点|分享)/
+];
+/** The policy a caller that states none gets: the built-in rules alone. */
+const DEFAULT_CLEAN_POLICY = {
+	maxPromoChars: 200,
+	patterns: []
+};
+/**
+* Remove the promotional elements WeChat embeds in an article body.
+* @param bodyHtml - the inner HTML of the article body element.
+* @param policy - the promotion rules the deployment filters with.
+* @returns the same HTML without the advertising subtrees and promotion blocks.
+*/
+function filterAds(bodyHtml, policy = DEFAULT_CLEAN_POLICY) {
+	let output = "";
+	const stack = [];
+	let skipDepth = -1;
+	TOKEN$1.lastIndex = 0;
+	let match;
+	while ((match = TOKEN$1.exec(bodyHtml)) !== null) {
+		const whole = match[0];
+		const openName = match[1];
+		const closeName = match[4];
+		if (closeName !== void 0) {
+			const entry = closeElement(stack, closeName.toLowerCase());
+			if (skipDepth >= 0) {
+				if (stack.length < skipDepth) skipDepth = -1;
+				continue;
+			}
+			if (entry !== void 0 && entry.droppable && isPromo(output.slice(entry.mark), policy)) {
+				output = output.slice(0, entry.mark);
+				continue;
+			}
+			output += whole;
+			continue;
+		}
+		if (openName !== void 0) {
+			const name = openName.toLowerCase();
+			const childless = match[3] === "/" || VOID_ELEMENTS.has(name);
+			if (skipDepth >= 0) {
+				if (!childless) stack.push({
+					name,
+					mark: 0,
+					droppable: false
+				});
+				continue;
+			}
+			if (isAdElement(name, match[2] ?? "")) {
+				if (!childless) {
+					stack.push({
+						name,
+						mark: 0,
+						droppable: false
+					});
+					skipDepth = stack.length;
+				}
+				continue;
+			}
+			if (childless) {
+				output += whole;
+				continue;
+			}
+			stack.push({
+				name,
+				mark: output.length,
+				droppable: BLOCK_ELEMENTS$1.has(name)
+			});
+			output += whole;
+			continue;
+		}
+		if (skipDepth >= 0 || whole.startsWith("<!--")) continue;
+		output += whole;
+	}
+	return output;
+}
+/**
+* Whether one opening tag names an advertising element.
+* @param name - the lower-case element name.
+* @param rawAttributes - the tag's raw attribute text.
+* @returns true when the tag is one of WeChat's advertising elements.
+*/
+function isAdElement(name, rawAttributes) {
+	if (AD_TAGS.has(name) || WIDGET_ELEMENTS.has(name)) return true;
+	const attributes = parseAttributes(rawAttributes);
+	const id = (attributes.get("id") ?? "").toLowerCase();
+	if (AD_IDS.has(id) || id !== "" && (AD_ATTRIBUTE.test(id) || PROMO_ATTRIBUTE.test(id))) return true;
+	return (attributes.get("class") ?? "").split(/\s+/).some((token) => token !== "" && (AD_ATTRIBUTE.test(token) || PROMO_ATTRIBUTE.test(token)));
+}
+/**
+* Whether one block's whole text is a follow or promotion prompt.
+* @param blockHtml - the block element's emitted HTML.
+* @param policy - the promotion rules the deployment filters with.
+* @returns true when the block's text is short and matches a promotion rule.
+*/
+function isPromo(blockHtml, policy) {
+	const text = textOf(blockHtml);
+	if (text === "" || text.length > policy.maxPromoChars) return false;
+	if (policy.patterns.some((pattern) => pattern.test(text))) return true;
+	return PROMO_TEXT.some((pattern) => pattern.test(text));
+}
+/**
+* Pop the open-element stack back to and including one element name.
+* @param stack - the open elements, innermost last.
+* @param name - the lower-case element name the closing tag carried.
+* @returns the popped entry when the tag closed the innermost element, otherwise undefined.
+*/
+function closeElement(stack, name) {
+	if (stack[stack.length - 1]?.name === name) return stack.pop();
+	while (stack.length > 0) if (stack.pop()?.name === name) break;
+}
+//#endregion
+//#region lib/document.js
+/**
+* The Markdown record one article becomes: the file that is written and the text
+* the model reads.
+*
+* They are **not** the same text. The file holds the whole body; the model reads a
+* bounded head of it plus the path, because a call that carried whole articles
+* would pay their full length in context and the session log would carry it too.
+* Both render the same facts, so a saved article and the call that produced it
+* never disagree about what was retrieved.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/document
+*/
+/** Quote one value as a YAML double-quoted scalar, which is a JSON string. */
+function yamlString(value) {
+	return JSON.stringify(value);
+}
+/**
+* The facts shared by the saved file and the model-facing text.
+* @param article - the article's canonical value.
+* @param body - the text to place in the body position.
+* @returns the heading, the metadata line, and the body.
+*/
+function articleLines(article, body) {
+	const meta = [];
+	if (article.account !== "") meta.push("公众号：" + article.account);
+	if (article.author !== "") meta.push("作者：" + article.author);
+	if (article.publishTime !== "") meta.push("发布：" + article.publishTime);
+	meta.push("链接：" + article.resolvedUrl);
+	const lines = [
+		"# " + (article.title === "" ? "(无标题)" : article.title),
+		"",
+		meta.join(" | "),
+		"",
+		body
+	];
+	if (article.images.length > 0) lines.push("", "## 图片", ...article.images.map((src, index) => String(index + 1) + ". " + src));
+	return lines;
+}
+/**
+* Render the Markdown file one article is saved as. This is the complete record:
+* the whole body, never a window of it.
+* @param article - the article as it was built, body included.
+* @returns YAML front matter, the full body, and the image list.
+*/
+function articleDocument(article) {
+	return [
+		"---",
+		"title: " + yamlString(article.title),
+		"account: " + yamlString(article.account),
+		"author: " + yamlString(article.author),
+		"publishTime: " + yamlString(article.publishTime),
+		"source: " + yamlString(article.resolvedUrl),
+		"cover: " + yamlString(article.cover),
+		"chars: " + String(article.chars),
+		"rendered: " + String(article.rendered),
+		"---",
+		...articleLines(article, article.body)
+	].join("\n");
+}
+/**
+* Render the model-facing text of one saved article: the facts, a head of the
+* body, how long the body is, and where the whole of it lives.
+* @param article - the article's canonical value, saved path included.
+* @returns the article facts, the excerpt, the body's length, and the saved path.
+*/
+function renderArticle(article) {
+	const lines = articleLines(article, article.excerpt);
+	lines.push("");
+	lines.push(article.excerptClipped ? `（以上为节选，正文共 ${String(article.chars)} 字；完整内容见文件）` : `（正文共 ${String(article.chars)} 字）`);
+	lines.push("文件：" + article.file);
+	return lines.join("\n");
+}
+//#endregion
+//#region lib/fetch.js
+/**
+* The plugin's HTTP layer: browser-like request headers, a session cookie jar,
+* a minimum interval between requests, a cool-down a refused request imposes on
+* the rest of the instance, bounded retries that honour the server's own retry
+* hint, and the deployment's timeout. Kept separate from page parsing, and
+* driven through injected transport and clock ports so tests never sleep or
+* reach the network.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/fetch
+*/
+/** Statuses worth another attempt: rate limits and server-side failures. */
+const RETRYABLE_STATUS = /* @__PURE__ */ new Set([
+	408,
+	425,
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+/**
+* Headers a browser sends when navigating to a page. The client hints are
+* deliberately absent: they must agree with the configured user agent, and a
+* mismatch is a stronger signal than their absence. `sec-fetch-site` is absent
+* too, because it describes the navigation the request belongs to and is set
+* per request.
+*/
+const NAVIGATION_HEADERS = {
+	accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+	"accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+	"cache-control": "max-age=0",
+	"sec-fetch-dest": "document",
+	"sec-fetch-mode": "navigate",
+	"sec-fetch-user": "?1",
+	"upgrade-insecure-requests": "1"
+};
+/** `sec-fetch-site` for the instance's first navigation, which no page referred. */
+const FIRST_NAVIGATION_SITE = "none";
+/** `sec-fetch-site` for every navigation after the first, which a fetched page referred. */
+const REFERRED_NAVIGATION_SITE = "same-origin";
+const DEFAULT_DEPS = {
+	fetchImpl: fetch,
+	sleep: (ms) => new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	}),
+	now: () => Date.now(),
+	random: () => Math.random()
+};
+/** Whether the caller already cancelled; a function call keeps TS from narrowing the flag. */
+function cancelled(signal) {
+	return signal !== void 0 && signal.aborted;
+}
+/** A cancellation error the caller can distinguish from a failed request. */
+function abortError() {
+	const error = /* @__PURE__ */ new Error("wechat: the call was cancelled");
+	error.name = "AbortError";
+	return error;
+}
+/** Milliseconds to wait before one retry, jittered so parallel callers do not sync. */
+function backoffDelay(base, attempt, random) {
+	return Math.round(base * 2 ** attempt * (.5 + random()));
+}
+/**
+* Milliseconds to wait before the next attempt. A usable server hint wins,
+* capped by the deployment, because it is the rate the server is willing to
+* serve; otherwise the jittered backoff applies.
+*/
+function retryDelay(policy, attempt, retryAfterMs, random) {
+	if (retryAfterMs > 0) return Math.min(retryAfterMs, policy.maxRetryAfterMs);
+	return backoffDelay(policy.backoffBaseMs, attempt, random);
+}
+/**
+* Read a Retry-After header, in either of its two legal forms.
+* @param value - the header value, or null when the response carried none.
+* @param now - current time in milliseconds, for the HTTP-date form.
+* @returns milliseconds to wait, or 0 when the header is absent or unusable.
+*/
+function parseRetryAfter(value, now) {
+	if (value === null || value.trim() === "") return 0;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds) && seconds >= 0) return Math.round(seconds * 1e3);
+	const date = Date.parse(value);
+	return Number.isNaN(date) ? 0 : Math.max(0, date - now);
+}
+/**
+* Every `Set-Cookie` value one response carried. `Headers.getSetCookie` is the
+* only accessor that returns more than one; a runtime without it yields the
+* single folded header, which is still better than dropping the cookies.
+* @param headers - the response headers.
+* @returns the header values, in the order the server sent them.
+*/
+function setCookieValues(headers) {
+	const multi = headers.getSetCookie;
+	if (typeof multi === "function") return multi.call(headers);
+	const single = headers.get("set-cookie");
+	return single === null ? [] : [single];
+}
+/**
+* Read the name and value out of one `Set-Cookie` value, ignoring its
+* attributes. A deletion (`Max-Age=0`) is read like any other; the server's own
+* later value replaces it, so a stale entry cannot outlive the response that
+* removed it on any page the walk reaches afterwards.
+* @param value - one `Set-Cookie` header value.
+* @returns the cookie pair, or undefined when the value carries no `name=value`.
+*/
+function cookiePair(value) {
+	const pair = value.split(";", 1)[0]?.trim() ?? "";
+	const equals = pair.indexOf("=");
+	if (equals <= 0) return void 0;
+	return [pair.slice(0, equals).trim(), pair.slice(equals + 1).trim()];
+}
+/**
+* The cookie header one request sends: the deployment's own cookies first, in
+* the order it wrote them, then every cookie this instance has been given that
+* the deployment's header does not already name.
+* @param configured - the cookies parsed from the deployment's header.
+* @param jar - cookies harvested from earlier responses, keyed by name.
+* @returns the header value, or an empty string when no cookie is held.
+*/
+function cookieHeader(configured, jar) {
+	const named = new Set(configured.map((pair) => pair[0]));
+	const parts = configured.map((pair) => pair[0] + "=" + pair[1]);
+	for (const [name, value] of jar) if (!named.has(name)) parts.push(name + "=" + value);
+	return parts.join("; ");
+}
+/**
+* Parse a Cookie header into ordered pairs.
+* @param header - the deployment's Cookie header.
+* @returns one pair per non-empty entry it carries.
+*/
+function configuredCookies(header) {
+	if (header.trim() === "") return [];
+	const pairs = [];
+	for (const part of header.split(";")) {
+		const pair = cookiePair(part);
+		if (pair !== void 0) pairs.push(pair);
+	}
+	return pairs;
+}
+/** Sleep that settles early when the caller cancels. */
+function sleepWithSignal(ms, sleep, signal) {
+	if (signal === void 0) return sleep(ms);
+	if (signal.aborted) return Promise.reject(abortError());
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			reject(abortError());
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		sleep(ms).then(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+	});
+}
+/**
+* Build the plugin instance's fetcher.
+* @param policy - the deployment's header, pacing, retry, and timeout values.
+* @param overrides - test ports replacing the default transport, clock, or jitter.
+* @returns the fetcher whose pace() the browser renderer shares.
+*/
+function createFetcher(policy, overrides = {}) {
+	const deps = {
+		...DEFAULT_DEPS,
+		...overrides
+	};
+	const configured = configuredCookies(policy.cookie);
+	const jar = /* @__PURE__ */ new Map();
+	let lastRequestAt = Number.NEGATIVE_INFINITY;
+	let resumeAt = Number.NEGATIVE_INFINITY;
+	let navigations = 0;
+	const pace = async (signal) => {
+		const jitter = policy.minIntervalJitterMs > 0 ? Math.round(deps.random() * policy.minIntervalJitterMs) : 0;
+		const wait = Math.max(lastRequestAt + policy.minIntervalMs + jitter, resumeAt) - deps.now();
+		if (wait > 0) await sleepWithSignal(wait, deps.sleep, signal);
+		lastRequestAt = deps.now();
+	};
+	const coolDown = (ms) => {
+		if (ms > 0) resumeAt = Math.max(resumeAt, deps.now() + ms);
+	};
+	const once = async (url, signal) => {
+		const timeout = AbortSignal.timeout(policy.timeoutMs);
+		const combined = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+		const headers = {
+			...NAVIGATION_HEADERS,
+			"user-agent": policy.userAgent,
+			"sec-fetch-site": navigations === 0 ? FIRST_NAVIGATION_SITE : REFERRED_NAVIGATION_SITE
+		};
+		navigations += 1;
+		if (policy.referer !== "") headers.referer = policy.referer;
+		const cookie = policy.cookieJar ? cookieHeader(configured, jar) : policy.cookie;
+		if (cookie !== "") headers.cookie = cookie;
+		const response = await deps.fetchImpl(url, {
+			headers,
+			redirect: "follow",
+			signal: combined
+		});
+		const setCookie = setCookieValues(response.headers);
+		if (policy.cookieJar) for (const value of setCookie) {
+			const pair = cookiePair(value);
+			if (pair !== void 0) jar.set(pair[0], pair[1]);
+		}
+		const body = await response.text();
+		return {
+			response: {
+				url: response.url === "" ? url : response.url,
+				status: response.status,
+				body,
+				setCookie
+			},
+			retryAfterMs: parseRetryAfter(response.headers.get("retry-after"), deps.now())
+		};
+	};
+	const get = async (url, signal) => {
+		if (cancelled(signal)) throw abortError();
+		let lastError;
+		let delayMs = 0;
+		for (let attempt = 0; attempt <= policy.maxRetries; attempt += 1) {
+			if (attempt > 0) await sleepWithSignal(delayMs, deps.sleep, signal);
+			await pace(signal);
+			try {
+				const { response, retryAfterMs } = await once(url, signal);
+				if (RETRYABLE_STATUS.has(response.status) && attempt < policy.maxRetries) {
+					lastError = /* @__PURE__ */ new Error("wechat: HTTP " + response.status + " from " + url);
+					delayMs = retryDelay(policy, attempt, retryAfterMs, deps.random);
+					continue;
+				}
+				return response;
+			} catch (error) {
+				if (cancelled(signal)) throw error;
+				lastError = error;
+				delayMs = backoffDelay(policy.backoffBaseMs, attempt, deps.random);
+			}
+		}
+		throw lastError instanceof Error ? lastError : /* @__PURE__ */ new Error("wechat: the request to " + url + " failed");
+	};
+	return {
+		get,
+		pace,
+		coolDown
+	};
+}
+//#endregion
+//#region lib/list.js
+/**
+* List and collection page parsing. A WeChat collection page
+* (mp/appmsgalbum?action=getalbum) carries its article list in static HTML: one
+* element per article with a data-link, plus the msgid and itemidx cursors that
+* address the next page, and a continue_flag that says whether more follow. A
+* generic list page links its articles with ordinary anchors instead, and
+* addresses its continuation with an ordinary next-page anchor when it has one.
+* This module turns either into an ordered, de-duplicated list of article links
+* plus the cursor that continues the walk.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/list
+*/
+/** One opening tag, with its attribute text. */
+const OPEN_TAG = /<([a-zA-Z][a-zA-Z0-9-]*)((?:"[^"]*"|'[^']*'|[^>"'])*?)(\/?)>/g;
+/** One anchor tag, whatever attributes it carries. */
+const ANCHOR = /<a\b[^>]*>/gi;
+/** The href of one anchor tag, double- or single-quoted. */
+const HREF = /href\s*=\s*(?:"([^"]*)"|'([^']*)')/i;
+/** The inline flag a collection page sets while further pages exist. */
+const CONTINUE_FLAG = /continue_flag\s*:\s*['"]?1['"]?/;
+/**
+* The whole text of an anchor that addresses the next page of a generic list.
+* Anchored at both ends so a link merely mentioning "更多" elsewhere in a
+* sentence is not mistaken for the continuation.
+*/
+const NEXT_TEXT = /^(?:下一页|下页|下一頁|下一篇|更多|查看更多|next(?:\s*page)?|older|›|»|>>)$/i;
+/**
+* Entries one collection page carries. The server ignores a larger count, so
+* this is the page size the walk must assume rather than a deployment choice.
+*/
+const ALBUM_PAGE_SIZE = "20";
+/**
+* Parse one list or collection page.
+* @param html - the page's HTML.
+* @param requestedUrl - the link the page was fetched from, used to resolve relative hrefs and to drop a self-link.
+* @returns the page's title, entries, and its continuation cursor when it carries one.
+*/
+function parseListPage(html, requestedUrl) {
+	const items = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (raw, cursors) => {
+		const url = normalizeLink(raw, requestedUrl);
+		if (url === "" || url === requestedUrl || seen.has(url)) return;
+		seen.add(url);
+		items.push({
+			url,
+			msgid: cursors?.get("data-msgid") ?? "",
+			itemidx: cursors?.get("data-itemidx") ?? ""
+		});
+	};
+	OPEN_TAG.lastIndex = 0;
+	let match;
+	while ((match = OPEN_TAG.exec(html)) !== null) {
+		if (!match[0].includes("data-link")) continue;
+		const attributes = parseAttributes(match[0]);
+		const link = attributes.get("data-link");
+		if (link !== void 0) add(link, attributes);
+	}
+	while ((match = ANCHOR.exec(html)) !== null) {
+		const href = HREF.exec(match[0]);
+		const raw = href?.[1] ?? href?.[2];
+		if (raw !== void 0) add(raw, parseAttributes(match[0]));
+	}
+	const more = CONTINUE_FLAG.test(html);
+	const cursor = [...items].reverse().find((item) => item.msgid !== "" && item.itemidx !== "");
+	const next = more && cursor !== void 0 ? {
+		msgid: cursor.msgid,
+		itemidx: cursor.itemidx
+	} : void 0;
+	return {
+		title: listTitle(html),
+		items,
+		more,
+		next,
+		nextUrl: nextPageUrl(html, requestedUrl)
+	};
+}
+/**
+* The link a generic list page gives for its own next page.
+* @param html - the page's HTML.
+* @param base - the link the page was fetched from.
+* @returns the absolute same-host next-page link, or an empty string when the page carries none.
+*/
+function nextPageUrl(html, base) {
+	const anchors = /<a\b[^>]*>[\s\S]*?<\/a\s*>/gi;
+	let match;
+	while ((match = anchors.exec(html)) !== null) {
+		if (!NEXT_TEXT.test(textOf(match[0]))) continue;
+		const href = HREF.exec(match[0]);
+		const raw = href?.[1] ?? href?.[2];
+		if (raw === void 0) continue;
+		const resolved = absoluteSameHostLink(raw, base);
+		if (resolved !== "" && resolved !== base) return resolved;
+	}
+	return "";
+}
+/**
+* Address the collection page after one that ended on a cursor.
+* @param pageUrl - the collection page the walk is on.
+* @param cursor - the msgid and itemidx the page's last entry carried.
+* @returns the next page's URL, or an empty string when the URL names no collection.
+*/
+function albumPageUrl(pageUrl, cursor) {
+	let parsed;
+	try {
+		parsed = new URL(pageUrl);
+	} catch {
+		return "";
+	}
+	if (parsed.searchParams.get("__biz") === null || parsed.searchParams.get("album_id") === null) return "";
+	parsed.hash = "";
+	parsed.searchParams.set("action", "getalbum");
+	parsed.searchParams.set("count", ALBUM_PAGE_SIZE);
+	parsed.searchParams.set("begin_msgid", cursor.msgid);
+	parsed.searchParams.set("begin_itemidx", cursor.itemidx);
+	return parsed.href;
+}
+/**
+* Normalize one page link to an absolute https article URL.
+* @param raw - the link as the page carried it, possibly relative and entity-encoded.
+* @param base - the link the page was fetched from, resolving a relative href.
+* @returns the normalized article link, or an empty string when it names no article page.
+*/
+function normalizeLink(raw, base) {
+	const parsed = absoluteLink(raw, base);
+	if (parsed === void 0) return "";
+	if (parsed.protocol === "http:" && parsed.hostname === "mp.weixin.qq.com") parsed.protocol = "https:";
+	return isMpArticleLink(parsed.href) ? parsed.href : "";
+}
+/**
+* Resolve one page link against its base.
+* @param raw - the link as the page carried it, possibly relative and entity-encoded.
+* @param base - the link the page was fetched from.
+* @returns the absolute http(s) link without its fragment, or undefined when it names no such link.
+*/
+function absoluteLink(raw, base) {
+	let parsed;
+	try {
+		parsed = new URL(decodeEntities(raw).trim(), base);
+	} catch {
+		return;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return void 0;
+	parsed.hash = "";
+	return parsed;
+}
+/**
+* Resolve one next-page link against its base, requiring the same host: a
+* continuation that leaves the site is not the list's own next page.
+* @param raw - the link as the page carried it.
+* @param base - the link the page was fetched from.
+* @returns the absolute link, or an empty string when it names no same-host page.
+*/
+function absoluteSameHostLink(raw, base) {
+	let origin;
+	try {
+		origin = new URL(base);
+	} catch {
+		return "";
+	}
+	const parsed = absoluteLink(raw, base);
+	return parsed !== void 0 && parsed.hostname === origin.hostname ? parsed.href : "";
+}
+/**
+* The title one list page carries.
+* @param html - the page's HTML.
+* @returns the page's own title, or an empty string when it carries none.
+*/
+function listTitle(html) {
+	const openGraph = metaContent(html, "og:title");
+	if (openGraph !== "") return openGraph;
+	const title = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+	return title?.[1] === void 0 ? "" : textOf(title[1]);
+}
+//#endregion
+//#region lib/markdown.js
+/**
+* HTML-to-Markdown and HTML-to-text conversion for article bodies. A single tag
+* walker covers the elements WeChat article bodies use: sections, paragraphs,
+* headings, emphasis, links, lazy images, lists, quotes, and code. It is a
+* focused converter for that corpus, not a general HTML parser.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/markdown
+*/
+/** Elements that start a new block of prose. */
+const BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"div",
+	"dl",
+	"dd",
+	"dt",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"header",
+	"li",
+	"main",
+	"nav",
+	"ol",
+	"p",
+	"section",
+	"table",
+	"tbody",
+	"td",
+	"tfoot",
+	"th",
+	"thead",
+	"tr",
+	"ul"
+]);
+/** Elements whose content never reaches the article text. */
+const SKIP_ELEMENTS = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"noscript",
+	"svg",
+	"iframe",
+	"video",
+	"audio"
+]);
+/** Heading element names, captured with their level. */
+const HEADING = /^h([1-6])$/;
+/** One opening tag, closing tag, comment, or run of text. */
+const TOKEN = /<([a-zA-Z][a-zA-Z0-9-]*)((?:"[^"]*"|'[^']*'|[^>"'])*?)(\/?)>|<\/([a-zA-Z][a-zA-Z0-9-]*)>|<!--[\s\S]*?-->|[^<]+/g;
+/**
+* Convert one article body to Markdown.
+* @param html - the body element's inner HTML.
+* @returns Markdown text with headings, lists, links, and images preserved.
+*/
+function htmlToMarkdown(html) {
+	return convert(html, true);
+}
+/**
+* Convert one article body to plain text.
+* @param html - the body element's inner HTML.
+* @returns plain text with block boundaries preserved and inline markers dropped.
+*/
+function htmlToText(html) {
+	return convert(html, false);
+}
+/**
+* Walk the body's tags once, emitting block structure and inline markers.
+* @param html - body HTML.
+* @param markdown - whether heading, emphasis, link, and fence markers are emitted.
+* @returns normalized output text.
+*/
+function convert(html, markdown) {
+	let result = "";
+	let skipTag;
+	let skipDepth = 0;
+	let preDepth = 0;
+	let linkHref;
+	let codeOpen = false;
+	let cellsInRow = 0;
+	const lists = [];
+	const ensureNewline = () => {
+		if (result !== "" && !result.endsWith("\n")) result += "\n";
+	};
+	const ensureBlank = () => {
+		if (result === "") return;
+		ensureNewline();
+		if (!result.endsWith("\n\n")) result += "\n";
+	};
+	const marker = (text) => {
+		if (markdown) result += text;
+	};
+	const open = (name, rawAttributes) => {
+		if (preDepth > 0) {
+			if (name === "br") result += "\n";
+			return;
+		}
+		if (name === "br") {
+			result += "\n";
+			return;
+		}
+		if (name === "hr") {
+			ensureBlank();
+			marker("---");
+			ensureBlank();
+			return;
+		}
+		if (name === "img") {
+			const attributes = parseAttributes(rawAttributes);
+			const src = attributes.get("data-src") ?? attributes.get("src") ?? "";
+			if (src === "" || src.startsWith("data:")) return;
+			const alt = attributes.get("alt") ?? "图片";
+			result += markdown ? "![" + alt + "](" + src + ")" : src;
+			return;
+		}
+		if (name === "pre") {
+			ensureBlank();
+			marker("~~~");
+			ensureNewline();
+			preDepth = 1;
+			return;
+		}
+		if (BLOCK_ELEMENTS.has(name)) {
+			ensureBlank();
+			const heading = HEADING.exec(name);
+			if (heading?.[1] !== void 0) marker("#".repeat(Number(heading[1])) + " ");
+			else if (name === "li") {
+				const list = lists[lists.length - 1];
+				if (list?.ordered === true) {
+					list.index += 1;
+					result += list.index + ". ";
+				} else result += "- ";
+			} else if (name === "blockquote") marker("> ");
+			else if (name === "tr") cellsInRow = 0;
+			else if ((name === "td" || name === "th") && cellsInRow > 0) result += " | ";
+			else if (name === "ul" || name === "ol") lists.push({
+				ordered: name === "ol",
+				index: 0
+			});
+			return;
+		}
+		if (name === "a") {
+			linkHref = parseAttributes(rawAttributes).get("href");
+			marker("[");
+			return;
+		}
+		if (name === "strong" || name === "b") {
+			marker("**");
+			return;
+		}
+		if (name === "em" || name === "i") {
+			marker("*");
+			return;
+		}
+		if (name === "del" || name === "s" || name === "strike") {
+			marker("~~");
+			return;
+		}
+		if (name === "code" && !codeOpen) {
+			marker("`");
+			codeOpen = true;
+		}
+	};
+	const close = (name) => {
+		if (name === "pre") {
+			ensureNewline();
+			marker("~~~");
+			ensureBlank();
+			preDepth = 0;
+			return;
+		}
+		if (preDepth > 0) return;
+		if (name === "a") {
+			const href = linkHref;
+			linkHref = void 0;
+			if (markdown && href !== void 0 && href !== "") result += "](" + href + ")";
+			return;
+		}
+		if (name === "strong" || name === "b") {
+			marker("**");
+			return;
+		}
+		if (name === "em" || name === "i") {
+			marker("*");
+			return;
+		}
+		if (name === "del" || name === "s" || name === "strike") {
+			marker("~~");
+			return;
+		}
+		if (name === "code" && codeOpen) {
+			marker("`");
+			codeOpen = false;
+			return;
+		}
+		if (name === "td" || name === "th") {
+			cellsInRow += 1;
+			return;
+		}
+		if (name === "tr") {
+			ensureNewline();
+			return;
+		}
+		if (name === "ul" || name === "ol") {
+			lists.pop();
+			ensureBlank();
+			return;
+		}
+		if (BLOCK_ELEMENTS.has(name)) ensureBlank();
+	};
+	TOKEN.lastIndex = 0;
+	let match;
+	while ((match = TOKEN.exec(html)) !== null) {
+		const whole = match[0];
+		const openName = match[1];
+		const closeName = match[4];
+		if (closeName !== void 0) {
+			const name = closeName.toLowerCase();
+			if (skipTag !== void 0) {
+				if (name === skipTag) {
+					skipDepth -= 1;
+					if (skipDepth === 0) skipTag = void 0;
+				}
+				continue;
+			}
+			close(name);
+			continue;
+		}
+		if (openName !== void 0) {
+			const name = openName.toLowerCase();
+			const selfClosing = match[3] === "/";
+			if (skipTag !== void 0) {
+				if (name === skipTag && !selfClosing) skipDepth += 1;
+				continue;
+			}
+			if (SKIP_ELEMENTS.has(name)) {
+				if (!selfClosing) {
+					skipTag = name;
+					skipDepth = 1;
+				}
+				continue;
+			}
+			open(name, match[2] ?? "");
+			continue;
+		}
+		if (whole.startsWith("<!--")) continue;
+		if (skipTag !== void 0) continue;
+		result += decodeEntities(whole).replace(/[\t\r\n\u00a0]+/g, " ");
+	}
+	return result.replace(/[ \t]+/g, " ").replace(/ *\n */g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+//#endregion
+//#region lib/render.js
+/**
+* Browser rendering for pages whose article body is built by client script, and
+* for pages the plain HTTP path is refused. Playwright is imported lazily
+* through a variable specifier, so the plugin loads, and every statically
+* served article still works, when the optional driver is absent. One browser
+* instance is reused and closed on an idle timer or when the owning fiber
+* disposes. A render waits for the configured body selector to fill, bounded by
+* its own window, instead of trusting a fixed settle time.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/render
+*/
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+	});
+	return path;
+};
+/** Extra milliseconds lazy images need after the page is scrolled to its end. */
+const SCROLL_SETTLE_MS = 400;
+/**
+* The expression the readiness wait polls: the article body element exists and
+* carries text or an image. A body that stayed empty is what a page with no
+* article behind the link looks like, so the caller reads the page as it stands
+* rather than waiting the whole window out for nothing.
+* @param selector - the selector the scripted body fills.
+* @returns a self-contained expression whose value is a boolean.
+*/
+function readinessExpression(selector) {
+	return "(() => { const body = document.querySelector(" + JSON.stringify(selector) + "); if (body === null) return false; return (body.textContent || \"\").trim().length > 0 || body.querySelector(\"img\") !== null; })()";
+}
+/**
+* Load the optional Playwright package through a variable specifier, so the
+* emitted bundle never inlines it and a deployment without it still loads.
+* @returns the chromium launcher.
+*/
+async function loadChromium() {
+	const specifier = "playwright";
+	let loaded;
+	try {
+		loaded = await import(__rewriteRelativeImportExtension(specifier));
+	} catch {
+		throw new Error("wechat: JS rendering needs the optional playwright package installed for this plugin");
+	}
+	const chromium = loaded.chromium;
+	if (chromium === void 0) throw new Error("wechat: the playwright package exposes no chromium launcher");
+	return chromium;
+}
+/**
+* Split one Cookie header into Playwright cookie objects for the target host.
+* @param header - the deployment's Cookie header.
+* @param target - the page being rendered.
+* @returns one cookie object per header entry.
+*/
+function cookiesFor(header, target) {
+	let host = "mp.weixin.qq.com";
+	try {
+		host = new URL(target).hostname;
+	} catch {}
+	return header.split(";").map((part) => part.trim()).filter((part) => part !== "").map((part) => {
+		const equals = part.indexOf("=");
+		return {
+			name: equals === -1 ? part : part.slice(0, equals),
+			value: equals === -1 ? "" : part.slice(equals + 1),
+			domain: host,
+			path: "/"
+		};
+	});
+}
+/**
+* Build the plugin instance's renderer.
+* @param policy - the deployment's driver, browser, and timing values.
+* @param load - launcher factory, replaced by tests with a structural fake.
+* @returns the renderer whose dispose() the plugin fiber owns.
+*/
+function createRenderer(policy, load = loadChromium) {
+	let browser;
+	let launching;
+	let idleTimer;
+	const closeBrowser = async () => {
+		if (idleTimer !== void 0) {
+			clearTimeout(idleTimer);
+			idleTimer = void 0;
+		}
+		const current = browser;
+		browser = void 0;
+		launching = void 0;
+		if (current !== void 0) await current.close().catch(() => void 0);
+	};
+	const scheduleIdleClose = () => {
+		if (idleTimer !== void 0) clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => {
+			closeBrowser();
+		}, policy.idleMs);
+	};
+	const acquire = async () => {
+		if (idleTimer !== void 0) {
+			clearTimeout(idleTimer);
+			idleTimer = void 0;
+		}
+		if (browser?.isConnected() === true) return browser;
+		if (launching === void 0) {
+			launching = (async () => {
+				const chromium = await load();
+				const options = { headless: policy.headless };
+				if (policy.executablePath !== "") options.executablePath = policy.executablePath;
+				else if (policy.channel !== "") options.channel = policy.channel;
+				return chromium.launch(options);
+			})();
+			launching.catch(() => {
+				launching = void 0;
+			});
+		}
+		const started = await launching;
+		browser = started;
+		return started;
+	};
+	const renderWithBrowser = async (url, signal) => {
+		const active = await acquire();
+		const contextOptions = {
+			userAgent: policy.userAgent,
+			locale: "zh-CN",
+			viewport: {
+				width: 1280,
+				height: 900
+			}
+		};
+		if (policy.referer !== "") contextOptions.extraHTTPHeaders = { referer: policy.referer };
+		const context = await active.newContext(contextOptions);
+		try {
+			if (policy.cookie !== "") await context.addCookies(cookiesFor(policy.cookie, url));
+			const page = await context.newPage();
+			const onAbort = () => {
+				page.close().catch(() => void 0);
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			try {
+				await page.goto(url, {
+					waitUntil: "domcontentloaded",
+					timeout: policy.timeoutMs
+				});
+				if (policy.readySelector !== "") try {
+					await page.waitForFunction(readinessExpression(policy.readySelector), void 0, { timeout: policy.waitMs });
+				} catch {}
+				await page.waitForTimeout(policy.settleMs);
+				await page.evaluate("window.scrollTo(0, document.body.scrollHeight)");
+				await page.waitForTimeout(SCROLL_SETTLE_MS);
+				return await page.content();
+			} finally {
+				signal?.removeEventListener("abort", onAbort);
+			}
+		} finally {
+			await context.close().catch(() => void 0);
+			scheduleIdleClose();
+		}
+	};
+	const renderWithHttp = async (url, signal) => {
+		if (policy.url === "") throw new Error("wechat: the http renderer driver needs a rendererUrl");
+		const timeout = AbortSignal.timeout(policy.timeoutMs);
+		const combined = signal === void 0 ? timeout : AbortSignal.any([signal, timeout]);
+		const response = await fetch(policy.url, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				accept: "text/html, application/json"
+			},
+			body: JSON.stringify({ url }),
+			signal: combined
+		});
+		if (!response.ok) throw new Error("wechat: the renderer endpoint returned HTTP " + response.status);
+		const text = await response.text();
+		if (!(response.headers.get("content-type") ?? "").includes("json")) return text;
+		const parsed = JSON.parse(text);
+		const html = typeof parsed === "object" && parsed !== null ? parsed.html : void 0;
+		if (typeof html !== "string" || html === "") throw new Error("wechat: the renderer response carried no html string");
+		return html;
+	};
+	const render = async (url, signal) => {
+		await policy.pace(signal);
+		return policy.driver === "http" ? renderWithHttp(url, signal) : renderWithBrowser(url, signal);
+	};
+	return {
+		render,
+		dispose: closeBrowser
+	};
+}
+/** Base name used when neither the title nor the link yields anything usable. */
+const UNTITLED = "untitled";
+/** Characters no file name may carry: Windows' reserved set, the POSIX separator, and controls. */
+const ILLEGAL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f<>:"/\\|?*]/g;
+/**
+* Characters a file name may carry but a reader cannot see: zero-width spaces,
+* bidirectional overrides, word joiners, and the byte-order mark. WeChat titles
+* are full of them, and a name made only of them looks empty in a directory
+* listing while still being a distinct file.
+*/
+const INVISIBLE_CHARACTERS = /[\u200b-\u200f\u202a-\u202e\u2060-\u2064\u206a-\u206f\ufeff]/g;
+/** Device names Windows reserves in every directory, with or without an extension. */
+const RESERVED_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
+/** Leading and trailing characters a file name may not carry on Windows. */
+const EDGE_NOISE = /^[\s.\-]+|[\s.\-]+$/g;
+/** Message identity a short link carries in its path, e.g. `/s/AbCdEf123`. */
+const SHORT_LINK_PATH = /^\/s\/([^/?#]+)$/;
+/**
+* Fold one article title into a file-name base: Unicode-normalized, with the
+* characters no file system accepts replaced, and whitespace, separators, and
+* edge noise collapsed.
+* @param title - the article title as the page carried it.
+* @returns the normalized base, or an empty string when nothing survives.
+*/
+function normalizeTitle(title) {
+	return title.normalize("NFC").replace(INVISIBLE_CHARACTERS, "").replace(ILLEGAL_CHARACTERS, "-").replace(/\s+/g, " ").replace(/-{2,}/g, "-").replace(EDGE_NOISE, "");
+}
+/**
+* A stable name for an article whose title yielded none, taken from its own
+* link: the message identity is what makes two untitled articles different, and
+* a name derived from it separates them without a collision suffix.
+* @param source - the article's resolved link.
+* @returns the normalized stem, or an empty string when the link names no identity.
+*/
+function linkStem(source) {
+	let parsed;
+	try {
+		parsed = new URL(source);
+	} catch {
+		return "";
+	}
+	const identity = SHORT_LINK_PATH.exec(parsed.pathname)?.[1] ?? parsed.searchParams.get("sn") ?? [parsed.searchParams.get("mid"), parsed.searchParams.get("idx")].filter((part) => part !== null).join("-");
+	return identity === void 0 || identity === "" ? "" : normalizeTitle(identity);
+}
+/**
+* Build the file name one article is saved under.
+* @param title - the article title as the page carried it.
+* @param maxChars - longest base name, in code points, the deployment allows.
+* @param source - the article's resolved link, used when the title yields no name.
+* @returns a base name carrying {@link FILE_EXTENSION}, creatable on Windows and POSIX.
+*/
+function articleFileName(title, maxChars, source = "") {
+	const normalized = normalizeTitle(title);
+	if (normalized !== "") return finish(normalized, maxChars);
+	const stem = linkStem(source);
+	return finish(stem === "" ? UNTITLED : stem, maxChars);
+}
+/** Clip one base name and escape the device names Windows reserves. */
+function finish(base, maxChars) {
+	const clipped = clip$1(base, maxChars);
+	return (RESERVED_DEVICE_NAME.test(clipped) ? "_" + clipped : clipped) + ".md";
+}
+/** Cut a base name to the ceiling without leaving edge noise or an empty name behind. */
+function clip$1(base, maxChars) {
+	const characters = [...base];
+	if (characters.length <= maxChars) return base;
+	const cut = characters.slice(0, maxChars).join("").replace(EDGE_NOISE, "");
+	return cut === "" ? UNTITLED : cut;
+}
+//#endregion
+//#region lib/store.js
+/**
+* File persistence for scraped articles: the article's file name, the
+* same-title collision rule, and the write itself. Every operation goes through
+* the mounted `ctx.fs` capability rather than the host filesystem directly, so
+* a deployment's file policy sees the write and its own backend decides how the
+* bytes are published. The calling session's per-call sandbox policy travels
+* with the write, which is what lets a confining backend fence it against the
+* workspace the session actually runs in.
+* @module @deepseek-ai/dsh-ab-wechat-scrape/store
+*/
+/** Number-suffixed names tried before a colliding name falls back to a timestamp. */
+const MAX_COLLISION_SUFFIX = 50;
+/** Opening line of the YAML front matter every article file starts with. */
+const FRONT_MATTER_FENCE = "---";
+/** The structured code a sandboxing filesystem reports a fenced write with. */
+const SANDBOX_DENIED = "FS_SANDBOX_DENIED";
+/** Front-matter key carrying the article's resolved link. */
+const SOURCE_KEY = "source: ";
+/**
+* Whether one failure is the file sandbox refusing the write, judged by the
+* stable code the capability publishes rather than by its message text.
+* @param error - the error the write threw.
+* @returns true when a confining filesystem denied the write.
+*/
+function isSandboxDenial(error) {
+	return typeof error === "object" && error !== null && error.code === SANDBOX_DENIED;
+}
+/**
+* Drop the body, which now lives in the file, from the value the call records.
+*
+* Written out field by field rather than spread-and-delete: adding a field to the
+* article then stops this compiling, instead of silently leaving the new field —
+* and any body-sized thing it might carry — in the value and the log.
+* @param drafted - the article as it was built, body included.
+* @returns the article as the call records it.
+*/
+function recordedArticle(drafted) {
+	return {
+		url: drafted.url,
+		resolvedUrl: drafted.resolvedUrl,
+		title: drafted.title,
+		account: drafted.account,
+		author: drafted.author,
+		publishTime: drafted.publishTime,
+		digest: drafted.digest,
+		cover: drafted.cover,
+		chars: drafted.chars,
+		excerpt: drafted.excerpt,
+		excerptClipped: drafted.excerptClipped,
+		images: drafted.images,
+		rendered: drafted.rendered
+	};
+}
+/**
+* Write one article's Markdown file, and return the value the call records.
+*
+* The body stops here: it is written to the file, and what the caller gets back is
+* the article without it. That is the whole point of the split — a call that
+* returned the body would pay the article's full length in context and in the log,
+* then have the reader look at a window of it anyway.
+* @param article - the article as it was built, body included.
+* @param policy - the deployment's output directory, name ceiling, and per-call sandbox policy.
+* @param fs - the mounted filesystem capability the write goes through.
+* @param signal - caller cancellation, forwarded to the write.
+* @returns the saved path, in the backend's execution world, and the recorded value.
+*/
+async function saveArticle(article, policy, fs, signal) {
+	const name = articleFileName(article.title, policy.fileNameMaxChars, article.resolvedUrl);
+	const target = await resolveTarget(fs, policy.dir, name, article.resolvedUrl);
+	await write(fs, target, articleDocument(article) + "\n", policy, signal);
+	return {
+		file: fs.processPath(target),
+		article: recordedArticle(article)
+	};
+}
+/**
+* Publish one article file, turning a sandbox refusal into the one instruction
+* that resolves it.
+*
+* A refusal under a stamped policy is a statement about the output directory
+* rather than about the article: the confining backend fences the write by the
+* workspace root the calling session runs in, so an outputDir outside that root
+* has to move. Reporting the bare provider text would leave that unsaid. A
+* call that stamped no policy gets the provider's own message, which already
+* names the mode it was fenced by.
+* @param fs - the mounted filesystem capability.
+* @param target - the resolved file target.
+* @param document - the complete file content.
+* @param policy - the deployment's output directory and per-call sandbox policy.
+* @param signal - caller cancellation.
+* @throws Error the provider raised, or the same failure restated with the remedy.
+*/
+async function write(fs, target, document, policy, signal) {
+	try {
+		await fs.writeText(target, document, void 0, signal, policy.sandboxPolicy);
+	} catch (error) {
+		const stamped = policy.sandboxPolicy;
+		if (stamped === void 0 || !isSandboxDenial(error)) throw error;
+		throw new Error("wechat: the file sandbox refused to write " + fs.processPath(target) + " under mode " + stamped.mode + "; this session's workspace is " + stamped.workspaceRoot + ", so set the plugin row's outputDir inside it", { cause: error });
+	}
+}
+/**
+* Choose the file one article is written to.
+* @param fs - the mounted filesystem capability.
+* @param dir - the absolute output directory.
+* @param name - the normalized file name, extension included.
+* @param source - the article's resolved link, the identity a collision is judged by.
+* @returns a free target, or the target already holding this same article.
+*/
+async function resolveTarget(fs, dir, name, source) {
+	const base = name.slice(0, -3);
+	const first = await fs.resolve(join(dir, name));
+	if (await matchesOrIsFree(fs, first, source)) return first;
+	for (let suffix = 2; suffix <= MAX_COLLISION_SUFFIX; suffix += 1) {
+		const candidate = await fs.resolve(join(dir, base + "-" + suffix + ".md"));
+		if (await matchesOrIsFree(fs, candidate, source)) return candidate;
+	}
+	return fs.resolve(join(dir, base + "-" + Date.now() + ".md"));
+}
+/**
+* Whether one target is free, or already holds the article with this resolved link.
+* @param fs - the mounted filesystem capability.
+* @param target - the candidate file target.
+* @param source - the article's resolved link.
+* @returns true when the caller may write the article to this target.
+*/
+async function matchesOrIsFree(fs, target, source) {
+	if (await fs.stat(target) === void 0) return true;
+	return await recordedSource(fs, target) === source;
+}
+/**
+* The resolved link recorded in one file's front matter.
+* @param fs - the mounted filesystem capability.
+* @param target - the existing file target.
+* @returns the recorded link, or an empty string when the file is unreadable or carries none.
+*/
+async function recordedSource(fs, target) {
+	let text;
+	try {
+		text = await fs.readText(target);
+	} catch {
+		return "";
+	}
+	const lines = text.split("\n");
+	if (lines[0] !== FRONT_MATTER_FENCE) return "";
+	for (const line of lines.slice(1)) {
+		if (line === FRONT_MATTER_FENCE) break;
+		if (!line.startsWith(SOURCE_KEY)) continue;
+		try {
+			const parsed = JSON.parse(line.slice(8));
+			return typeof parsed === "string" ? parsed : "";
+		} catch {
+			return "";
+		}
+	}
+	return "";
+}
+//#endregion
+//#region lib/index.js
+/**
+* Model-facing wechat_scrape tool. One call retrieves articles from WeChat
+* official accounts and saves each as its own Markdown file named after the
+* article title. A link may be an article page, or a list or collection page
+* whose article links are parsed out and then scraped one by one the same way;
+* a page that carries no article body is read as a list page. The HTTP layer
+* paces, retries, carries the session cookies WeChat sets, and reports WeChat's
+* block pages; a page whose body is built by client script, and a page the plain
+* path is refused for, fall back to the optional browser renderer. Only a page
+* that is still an article with a usable body after promotion filtering is ever
+* written to a file: a block page, a withdrawn article, and an article the
+* filtering left empty are reported as failures instead. The tool reads no
+* session state beyond the workspace directory it writes into and returns the
+* canonical value alone, so model-facing text and any replay read the same
+* recorded call.
+* @module @deepseek-ai/dsh-ab-wechat-scrape
+*/
+const name = "wechat-scrape";
+const inject = [
+	"tools",
+	"systemPrompt",
+	"fs"
+];
+/** Wire name this plugin registers. */
+const TOOL_NAME = "wechat_scrape";
+/** Body formats the tool accepts, in the order the model sees them. */
+const BODY_FORMATS = ["markdown", "text"];
+/**
+* Name and order of the routing section this plugin contributes. Repository-owned
+* tool sections allocate their order centrally; an external contribution states
+* its own finite order and sits after the built-in tool band (TOOL_REPORT, 2900).
+*/
+const SECTION_NAME = "tool:wechat_scrape";
+/** Order of {@link SECTION_NAME}, after the built-in tool sections. */
+const SECTION_ORDER = 2970;
+/**
+* Schemastery configuration for the tool. Defaults cover a single-machine
+* deployment that writes into the calling session's workspace; the
+* request-identity, list-depth, and output values are the ones a restricted or
+* authenticated deployment overrides from cordis.yml.
+*/
+const Config = z.object({
+	userAgent: z.string().default("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"),
+	referer: z.string().default("https://mp.weixin.qq.com/"),
+	cookie: z.string().default(""),
+	cookieJar: z.boolean().default(true),
+	minIntervalMs: z.number().step(1).min(0).default(2e3),
+	minIntervalJitterMs: z.number().step(1).min(0).default(1e3),
+	blockCooldownMs: z.number().step(1).min(0).default(6e4),
+	timeoutMs: z.number().step(1).min(1e3).default(2e4),
+	maxRetries: z.number().step(1).min(0).max(5).default(2),
+	backoffBaseMs: z.number().step(1).min(0).default(800),
+	maxRetryAfterMs: z.number().step(1).min(0).default(6e4),
+	maxChars: z.number().step(1).min(200).default(4e4),
+	maxImages: z.number().step(1).min(0).default(50),
+	maxArticles: z.number().step(1).min(1).max(200).default(10),
+	maxListPages: z.number().step(1).min(0).max(200).default(0),
+	filterAds: z.boolean().default(true),
+	promoMaxChars: z.number().step(1).min(0).default(200),
+	promoPatterns: z.array(z.string()).default([]),
+	minBodyChars: z.number().step(1).min(0).default(10),
+	outputDir: z.string().default("wechat-articles"),
+	fileNameMaxChars: z.number().step(1).min(8).max(200).default(80),
+	renderer: z.union([
+		"auto",
+		"never",
+		"always"
+	]).default("auto"),
+	rendererDriver: z.union(["playwright", "http"]).default("playwright"),
+	rendererUrl: z.string().default(""),
+	browserChannel: z.string().default("msedge"),
+	browserExecutablePath: z.string().default(""),
+	headless: z.boolean().default(true),
+	browserIdleMs: z.number().step(1).min(1e3).default(6e4),
+	renderReadySelector: z.string().default("#js_content"),
+	renderWaitMs: z.number().step(1).min(0).default(8e3),
+	renderSettleMs: z.number().step(1).min(0).default(1200)
+});
+const DESCRIPTION = [
+	"Scrape WeChat official-account articles and save each as its own Markdown file named after the article title.",
+	"A link may name one article, or a page that lists articles (a collection or archive page); a listing link is scraped as the articles it points to.",
+	"Returns each article's title, account, author, publish time, body text, image links, and the file it was saved to, plus the article links every listing page produced.",
+	"Accepts a short /s/<id> link, a full mp.weixin.qq.com/s?... link, or an mp.weixin.qq.com collection link."
+].join(" ");
+/** Model-facing routing rule: when to make a call, which a schema cannot carry. */
+const SECTION_TEXT = [
+	"When the reader needs the text of WeChat official-account articles (an mp.weixin.qq.com link), answer with wechat_scrape:",
+	"it saves each article as a Markdown file named after its title and returns the title, account, author, publish time, body text, and image links.",
+	"Give it a collection or list page link to scrape every article that page lists."
+].join(" ");
+/** The error text for one WeChat block page. */
+function blockedError(marker, url) {
+	return /* @__PURE__ */ new Error("wechat: WeChat refused " + url + " (page said \"" + marker + "\"); set a logged-in cookie on the plugin row and raise minIntervalMs");
+}
+/** The error text for one page whose article is gone rather than withheld. */
+function unavailableError(reason, url) {
+	return /* @__PURE__ */ new Error("wechat: " + url + " carries no article (page said \"" + reason + "\"); the publisher withdrew it or WeChat removed it, so nothing was saved");
+}
+/** The text one failed link is reported with. */
+function failureText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Validate the model-supplied link before any request is made.
+* @param raw - the link as the model supplied it.
+* @returns the trimmed link.
+* @throws Error when the link is empty or names another host.
+*/
+function normalizeUrl(raw) {
+	const trimmed = raw.trim();
+	if (trimmed === "") throw new Error("invalid wechat: url must be a non-empty string");
+	if (!isMpArticleUrl(trimmed)) throw new Error("invalid wechat: url must be an mp.weixin.qq.com link");
+	return trimmed;
+}
+/**
+* Collect the links one call asked for.
+* @param args - the model-supplied call arguments.
+* @param maxArticles - most links one call may start from.
+* @returns the distinct links, in request order.
+* @throws Error when the call names no link, a foreign link, or more links than the ceiling.
+*/
+function requestUrls(args, maxArticles) {
+	const requested = [...args.url === void 0 ? [] : [args.url], ...args.urls ?? []];
+	if (requested.length === 0) throw new Error("invalid wechat: give url or urls with at least one link");
+	const urls = [];
+	for (const raw of requested) {
+		const url = normalizeUrl(raw);
+		if (!urls.includes(url)) urls.push(url);
+	}
+	if (urls.length > maxArticles) throw new Error("invalid wechat: one call starts from at most " + maxArticles + " links");
+	return urls;
+}
+/**
+* Resolve the deployment's output directory.
+*
+* A relative value resolves against the workspace the calling session runs in.
+* Under a confining filesystem that workspace is the per-call sandbox policy's
+* root, not merely the session header's cwd: the policy is what the backend
+* fences the write by, so a relative outputDir resolved against anything else
+* would land outside the fence and be refused.
+* @param configured - the row's outputDir value.
+* @param cwd - the workspace this call resolves against, absent for a call without a session.
+* @returns the absolute directory article files are written to.
+*/
+function resolveOutputDir(configured, cwd) {
+	return isAbsolute(configured) ? configured : resolve(cwd ?? process.cwd(), configured);
+}
+/**
+* Cut text at the deployment ceiling, reporting whether anything was dropped.
+* @param text - the whole converted body.
+* @param maxChars - the deployment's excerpt ceiling.
+* @returns the head within the ceiling and whether anything was dropped.
+*/
+function clip(text, maxChars) {
+	if (text.length <= maxChars) return {
+		text,
+		truncated: false
+	};
+	return {
+		text: text.slice(0, maxChars).replace(/\s+$/, ""),
+		truncated: true
+	};
+}
+/**
+* Retrieve one link and refuse a verification redirect.
+* @param deps - the instance's fetcher and deployment values.
+* @param url - the link to retrieve.
+* @param signal - caller cancellation.
+* @returns the page's HTML and its final link.
+* @throws Error when WeChat answered with a verification redirect.
+*/
+async function fetchPage(deps, url, signal) {
+	const response = await deps.fetcher.get(url, signal);
+	const resolvedUrl = response.url === "" ? url : response.url;
+	const verification = detectBlockUrl(resolvedUrl);
+	if (verification !== "") {
+		deps.fetcher.coolDown(deps.config.blockCooldownMs);
+		throw blockedError(verification, resolvedUrl);
+	}
+	return {
+		html: response.body,
+		resolvedUrl
+	};
+}
+/**
+* Read one page's HTML as an article, a list, a refusal, or none of those. A
+* page with an article body is the article; a page with an article title but no
+* body is an article shell a browser render must fill; a page reporting a
+* withdrawn article is neither; anything else that links to articles is a list
+* page.
+* @param html - the page's HTML.
+* @param requestedUrl - the link the page was fetched from.
+* @param forced - whether the call declared the link a list page.
+* @returns what the page carried.
+*/
+function interpret(html, requestedUrl, forced) {
+	const extraction = forced ? void 0 : extractArticle(html);
+	if (extraction?.kind === "article") {
+		const article = extraction.article;
+		if (article.bodyHtml.trim() !== "" || article.title !== "") return {
+			kind: "article",
+			article
+		};
+	}
+	if (extraction?.kind === "unavailable") return {
+		kind: "unavailable",
+		reason: extraction.reason
+	};
+	const list = parseListPage(html, requestedUrl);
+	if (list.items.length > 0) return {
+		kind: "list",
+		list
+	};
+	if (extraction?.kind === "blocked") return {
+		kind: "blocked",
+		marker: extraction.marker
+	};
+	return { kind: "none" };
+}
+/**
+* The promotion rules one instance filters with.
+* @param config - the deployment's filtering values.
+* @returns the length ceiling and the compiled extra rules.
+* @throws Error when an extra rule is not a valid regular expression.
+*/
+function cleanPolicy(config) {
+	return {
+		maxPromoChars: config.promoMaxChars,
+		patterns: config.promoPatterns.map((source) => {
+			try {
+				return new RegExp(source, "iu");
+			} catch (error) {
+				throw new Error("invalid wechat: promoPatterns entry " + JSON.stringify(source) + " is not a regular expression: " + failureText(error));
+			}
+		})
+	};
+}
+/**
+* Turn one parsed article into the drafted value, body included.
+* @param article - the parsed page facts.
+* @param args - the model-supplied call arguments.
+* @param deps - the instance's deployment values.
+* @param url - the link the model supplied.
+* @param resolvedUrl - the article link after redirects.
+* @param rendered - whether a browser render supplied the HTML.
+* @returns the drafted article, before its body is written and dropped.
+*/
+function buildArticle(article, args, deps, url, resolvedUrl, rendered) {
+	const bodyHtml = deps.config.filterAds ? filterAds(article.bodyHtml, cleanPolicy(deps.config)) : article.bodyHtml;
+	const body = args.format === "text" ? htmlToText(bodyHtml) : htmlToMarkdown(bodyHtml);
+	const excerpt = clip(body, deps.config.maxChars);
+	return {
+		url,
+		resolvedUrl,
+		title: article.title,
+		account: article.account,
+		author: article.author,
+		publishTime: article.publishTime,
+		digest: article.digest,
+		cover: article.cover,
+		body,
+		chars: body.length,
+		excerpt: excerpt.text,
+		excerptClipped: excerpt.truncated,
+		images: args.includeImages === false ? [] : extractImages(bodyHtml).slice(0, deps.config.maxImages),
+		rendered
+	};
+}
+/**
+* Read one requested link as an article page or as a list of article links. The
+* short-link interstitial is resolved from its own inline script before any
+* browser render, and a page that carries neither an article body nor a list is
+* rendered once before the call fails. Only a page that is still an article
+* with a usable body after filtering leaves this function; every other outcome
+* is an error, so no caller can turn one into a file.
+* @param url - the link to read.
+* @param args - the model-supplied call arguments.
+* @param deps - the instance's fetcher, optional renderer, and bounds.
+* @param signal - caller cancellation.
+* @returns the article this link is, or the list page it is.
+* @throws Error for a block page, a withdrawn article, a failed request, a body
+* the filtering rule left too short to be an article, or a page carrying neither.
+*/
+async function loadPage(url, args, deps, signal) {
+	const forced = args.list === true;
+	let page = await fetchPage(deps, url, signal);
+	let reading = interpret(page.html, page.resolvedUrl, forced);
+	if (reading.kind === "none") {
+		const redirect = findRedirectUrl(page.html);
+		if (redirect !== "" && redirect !== page.resolvedUrl) {
+			page = await fetchPage(deps, redirect, signal);
+			reading = interpret(page.html, page.resolvedUrl, forced);
+		}
+	}
+	const articleMissing = reading.kind === "none" || reading.kind === "article" && reading.article.bodyHtml.trim() === "";
+	let rendered = false;
+	if (deps.renderer !== void 0 && (deps.config.renderer === "always" || articleMissing || reading.kind === "blocked")) {
+		const resolvedUrl = page.resolvedUrl;
+		page = {
+			html: await deps.renderer.render(resolvedUrl, signal),
+			resolvedUrl
+		};
+		reading = interpret(page.html, resolvedUrl, forced);
+		rendered = true;
+	}
+	if (reading.kind === "list") return {
+		kind: "list",
+		list: reading.list
+	};
+	if (reading.kind === "blocked") {
+		deps.fetcher.coolDown(deps.config.blockCooldownMs);
+		throw blockedError(reading.marker, page.resolvedUrl);
+	}
+	if (reading.kind === "unavailable") throw unavailableError(reading.reason, page.resolvedUrl);
+	if (reading.kind === "article" && reading.article.bodyHtml.trim() !== "") {
+		const article = buildArticle(reading.article, args, deps, url, page.resolvedUrl, rendered);
+		if (article.body.trim().length < deps.config.minBodyChars) throw new Error("wechat: " + page.resolvedUrl + " left no usable article body after filtering (" + String(article.body.trim().length) + " of " + String(deps.config.minBodyChars) + " characters); lower minBodyChars or set filterAds false to keep it");
+		return {
+			kind: "article",
+			article
+		};
+	}
+	if (forced) throw new Error("wechat: " + page.resolvedUrl + " listed no article links");
+	throw new Error("wechat: " + page.resolvedUrl + " served no article body; check the link or enable the browser renderer");
+}
+/**
+* Walk one list page and, while it addresses a next page, the list pages after
+* it. Every page read here is paced by the same fetcher as an article, so a walk
+* costs the same interval as any other request.
+* @param first - the list page the seed produced.
+* @param seed - the link that page was fetched from, which addresses its continuation.
+* @param deps - the instance's fetcher and bounds.
+* @param signal - caller cancellation.
+* @returns the article links the walk produced and whether it stopped early.
+* @throws Error when a page in the walk answers with a verification redirect.
+*/
+async function walkList(first, seed, deps, signal) {
+	const links = [];
+	const visited = /* @__PURE__ */ new Set([seed]);
+	const add = (items) => {
+		for (const item of items) if (!links.includes(item.url)) links.push(item.url);
+	};
+	const continuation = (page, pageUrl) => {
+		if (page.next !== void 0) {
+			const album = albumPageUrl(pageUrl, page.next);
+			if (album !== "") return album;
+		}
+		return deps.config.maxListPages > 0 ? page.nextUrl : "";
+	};
+	let page = first;
+	let pageUrl = seed;
+	let pages = 1;
+	for (;;) {
+		add(page.items);
+		const nextUrl = continuation(page, pageUrl);
+		if (nextUrl === "" || visited.has(nextUrl)) return {
+			links,
+			truncated: false
+		};
+		if (deps.config.maxListPages > 0 && pages >= deps.config.maxListPages || links.length >= deps.config.maxArticles) return {
+			links,
+			truncated: true
+		};
+		const response = await deps.fetcher.get(nextUrl, signal);
+		const resolvedUrl = response.url === "" ? nextUrl : response.url;
+		const verification = detectBlockUrl(resolvedUrl);
+		if (verification !== "") {
+			deps.fetcher.coolDown(deps.config.blockCooldownMs);
+			throw blockedError(verification, resolvedUrl);
+		}
+		visited.add(nextUrl);
+		visited.add(resolvedUrl);
+		page = parseListPage(response.body, resolvedUrl);
+		if (page.items.length === 0) return {
+			links,
+			truncated: false
+		};
+		pageUrl = resolvedUrl;
+		pages += 1;
+	}
+}
+/**
+* Retrieve and parse one article.
+* @param args - the model-supplied call arguments.
+* @param deps - the instance's fetcher, optional renderer, and bounds.
+* @param signal - caller cancellation.
+* @returns the drafted article, before it is saved.
+* @throws Error for an invalid link, a block page, a failed request, or a link that is a list page.
+*/
+async function collectArticle(args, deps, signal) {
+	const url = normalizeUrl(args.url ?? "");
+	const outcome = await loadPage(url, args, deps, signal);
+	if (outcome.kind !== "article") throw new Error("wechat: " + url + " is a list page; scrape it with list set, or scrape the articles it links to");
+	return outcome.article;
+}
+/**
+* Scrape every link one call named, saving each article to its own file. A link
+* may be an article or a list page; a list page's article links are scraped the
+* same way as a named article. One failing link or article does not discard
+* what the other links produced.
+* @param args - the model-supplied call arguments.
+* @param deps - the instance's fetcher, renderer, bounds, and output directory.
+* @param signal - caller cancellation.
+* @returns the saved articles, the list pages walked, and the links that failed.
+* @throws Error when the call names no usable link, or when the caller cancels.
+*/
+async function scrape(args, deps, signal) {
+	const seeds = requestUrls(args, deps.config.maxArticles);
+	const articles = [];
+	const lists = [];
+	const failures = [];
+	const scraped = /* @__PURE__ */ new Set();
+	const remaining = () => deps.config.maxArticles - articles.length;
+	const save = async (drafted) => {
+		const saved = await saveArticle(drafted, {
+			dir: deps.outputDir,
+			fileNameMaxChars: deps.config.fileNameMaxChars,
+			sandboxPolicy: deps.sandboxPolicy
+		}, deps.fs, signal);
+		articles.push({
+			...saved.article,
+			file: saved.file
+		});
+	};
+	for (const seed of seeds) {
+		if (remaining() <= 0) break;
+		let outcome;
+		try {
+			outcome = await loadPage(seed, args, deps, signal);
+		} catch (error) {
+			if (signal?.aborted === true) throw error;
+			failures.push({
+				url: seed,
+				error: failureText(error)
+			});
+			continue;
+		}
+		if (outcome.kind === "article") {
+			scraped.add(outcome.article.resolvedUrl);
+			try {
+				await save(outcome.article);
+			} catch (error) {
+				failures.push({
+					url: seed,
+					error: failureText(error)
+				});
+			}
+			continue;
+		}
+		let links = [];
+		let truncated = false;
+		try {
+			const walked = await walkList(outcome.list, seed, deps, signal);
+			links = walked.links;
+			truncated = walked.truncated;
+		} catch (error) {
+			if (signal?.aborted === true) throw error;
+			failures.push({
+				url: seed,
+				error: failureText(error)
+			});
+			continue;
+		}
+		lists.push({
+			url: seed,
+			title: outcome.list.title,
+			links,
+			truncated
+		});
+		for (const link of links) {
+			if (remaining() <= 0) break;
+			if (scraped.has(link)) continue;
+			scraped.add(link);
+			try {
+				await save(await collectArticle({
+					...args,
+					url: link,
+					list: false
+				}, deps, signal));
+			} catch (error) {
+				if (signal?.aborted === true) throw error;
+				failures.push({
+					url: link,
+					error: failureText(error)
+				});
+			}
+		}
+	}
+	return {
+		articles,
+		lists,
+		failures
+	};
+}
+/**
+* Compose the model-facing text of one call's result.
+* @param value - the canonical scrape value.
+* @returns every list page walked, every saved article, then every failure.
+*/
+function renderScrape(value) {
+	const blocks = [];
+	for (const list of value.lists) blocks.push([
+		"列表页：" + (list.title === "" ? list.url : list.title),
+		"链接：" + list.url,
+		"文章数：" + list.links.length + (list.truncated ? "（合集还有更多，已按本次上限截断）" : ""),
+		...list.links.map((link, index) => String(index + 1) + ". " + link)
+	].join("\n"));
+	for (const article of value.articles) blocks.push(renderArticle(article));
+	for (const failure of value.failures) blocks.push("抓取失败：" + failure.url + "\n" + failure.error);
+	return blocks.join("\n\n---\n\n");
+}
+/**
+* Contribute the routing section, own the renderer's lifetime, and register the
+* wechat_scrape tool. The section is empty wherever the tool is not visible in
+* that scope, so a restricted composition is not told to call a hidden tool.
+* @param ctx - registrant context carrying the tool, system-prompt, and filesystem registries.
+* @param config - the deployment's retrieval, list, filtering, output, and renderer values.
+* @throws Error when a confining filesystem is mounted with no sandbox-policy service,
+* because no per-call workspace root could then be resolved for the article writes.
+*/
+function apply(ctx, config) {
+	cleanPolicy(config);
+	const sandboxPolicy = ctx.get("sandboxPolicy");
+	if (ctx.fs.sandboxMode !== void 0 && sandboxPolicy === void 0) throw new Error("dsh-ab-wechat-scrape: the mounted filesystem confines but ctx.sandboxPolicy is missing");
+	const fetcher = createFetcher({
+		userAgent: config.userAgent,
+		referer: config.referer,
+		cookie: config.cookie,
+		cookieJar: config.cookieJar,
+		minIntervalMs: config.minIntervalMs,
+		minIntervalJitterMs: config.minIntervalJitterMs,
+		timeoutMs: config.timeoutMs,
+		maxRetries: config.maxRetries,
+		backoffBaseMs: config.backoffBaseMs,
+		maxRetryAfterMs: config.maxRetryAfterMs
+	});
+	const renderer = config.renderer === "never" ? void 0 : createRenderer({
+		driver: config.rendererDriver,
+		url: config.rendererUrl,
+		channel: config.browserChannel,
+		executablePath: config.browserExecutablePath,
+		headless: config.headless,
+		idleMs: config.browserIdleMs,
+		settleMs: config.renderSettleMs,
+		readySelector: config.renderReadySelector,
+		waitMs: config.renderWaitMs,
+		timeoutMs: config.timeoutMs,
+		userAgent: config.userAgent,
+		referer: config.referer,
+		cookie: config.cookie,
+		pace: fetcher.pace
+	});
+	if (renderer !== void 0) ctx.effect(() => () => {
+		renderer.dispose();
+	}, "wechat: browser renderer");
+	ctx.systemPrompt.section({
+		name: SECTION_NAME,
+		order: SECTION_ORDER,
+		text: ({ scope }) => ctx.tools.get("wechat_scrape", scope) === void 0 ? "" : SECTION_TEXT
+	});
+	ctx.tools.register(defineTool({
+		name: TOOL_NAME,
+		description: DESCRIPTION,
+		parameters: {
+			url: {
+				type: "string",
+				description: "One mp.weixin.qq.com link: an article (/s/<id> or /s?...), or a list or collection page."
+			},
+			urls: {
+				type: "array",
+				items: { type: "string" },
+				description: "Several links to scrape in one call; each article found is saved as its own file."
+			},
+			list: {
+				type: "boolean",
+				description: "Whether every link is a list or collection page whose articles are scraped instead of the page itself (default false). A page that carries no article body is read as a list page either way."
+			},
+			format: {
+				type: "string",
+				enum: [...BODY_FORMATS],
+				description: "Body format: markdown (default) keeps headings, lists, and links; text is plain prose."
+			},
+			includeImages: {
+				type: "boolean",
+				description: "Whether the result lists the article image URLs (default true)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					articles: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								url: {
+									type: "string",
+									required: true
+								},
+								resolvedUrl: {
+									type: "string",
+									required: true
+								},
+								title: {
+									type: "string",
+									required: true
+								},
+								account: {
+									type: "string",
+									required: true
+								},
+								author: {
+									type: "string",
+									required: true
+								},
+								publishTime: {
+									type: "string",
+									required: true
+								},
+								digest: {
+									type: "string",
+									required: true
+								},
+								cover: {
+									type: "string",
+									required: true
+								},
+								chars: {
+									type: "number",
+									required: true
+								},
+								excerpt: {
+									type: "string",
+									required: true
+								},
+								excerptClipped: {
+									type: "boolean",
+									required: true
+								},
+								images: {
+									type: "array",
+									required: true,
+									items: { type: "string" }
+								},
+								rendered: {
+									type: "boolean",
+									required: true
+								},
+								file: {
+									type: "string",
+									required: true
+								}
+							}
+						}
+					},
+					lists: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								url: {
+									type: "string",
+									required: true
+								},
+								title: {
+									type: "string",
+									required: true
+								},
+								links: {
+									type: "array",
+									required: true,
+									items: { type: "string" }
+								},
+								truncated: {
+									type: "boolean",
+									required: true
+								}
+							}
+						}
+					},
+					failures: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								url: {
+									type: "string",
+									required: true
+								},
+								error: {
+									type: "string",
+									required: true
+								}
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: renderScrape(value)
+			}]
+		},
+		execute(args, exec) {
+			const policy = sandboxPolicy?.resolve(exec.agent === void 0 ? {} : { session: exec.agent.session });
+			return scrape(args, {
+				fetcher,
+				renderer,
+				config,
+				fs: ctx.fs,
+				outputDir: resolveOutputDir(config.outputDir, policy?.workspaceRoot ?? exec.agent?.session.header.cwd),
+				sandboxPolicy: policy
+			}, exec.signal);
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: args.list === true ? "Scrape WeChat collection" : "Scrape WeChat articles",
+			kind: "fetch",
+			rawInput: args.url ?? (args.urls ?? []).join(", ")
+		})
+	}));
+}
+//#endregion
+export { BODY_FORMATS, Config, SECTION_NAME, SECTION_ORDER, SECTION_TEXT, TOOL_NAME, albumPageUrl, apply, articleDocument, cleanPolicy, clip, collectArticle, inject, name, normalizeUrl, parseListPage, recordedArticle, renderArticle, renderScrape, requestUrls, resolveOutputDir, scrape };