@xiaoso/dsh-tool-plus 0.1.0-beta.3 → 0.1.0-beta.4

package/lib/turndown-DN7ByzEI.mjs

@@ -0,0 +1,667 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-Bx0fpxuk.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/turndown/gfm.ts
+function descendantElements(node, name) {
+	const matches = [];
+	for (const child of Array.from(node.children)) {
+		if (child.nodeName === name) matches.push(child);
+		if (child.nodeName !== "TABLE") matches.push(...descendantElements(child, name));
+	}
+	return matches;
+}
+function isHeadingTable(node) {
+	if (node.nodeName !== "TABLE") return false;
+	const firstRow = descendantElements(node, "TR")[0];
+	if (!firstRow) return false;
+	const cells = Array.from(firstRow.children);
+	return cells.length > 0 && cells.every((cell) => cell.nodeName === "TH");
+}
+function cellAlignment(cell) {
+	const explicit = cell.getAttribute("align")?.toLowerCase();
+	if (explicit === "left" || explicit === "center" || explicit === "right") return explicit;
+	const style = cell.getAttribute("style") ?? "";
+	const styled = /(?:^|;)\s*text-align\s*:\s*(left|center|right)\s*(?:;|$)/i.exec(style)?.[1]?.toLowerCase();
+	return styled === "left" || styled === "center" || styled === "right" ? styled : void 0;
+}
+function alignmentMarker(cell) {
+	const alignment = cellAlignment(cell);
+	if (alignment === "left") return ":--";
+	if (alignment === "center") return ":-:";
+	if (alignment === "right") return "--:";
+	return "---";
+}
+function renderTable(service, table) {
+	const rows = descendantElements(table, "TR");
+	const rendered = [];
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		const cells = Array.from(row.children).filter((cell) => cell.nodeName === "TH" || cell.nodeName === "TD");
+		const values = cells.map((cell) => service.convertChildren(cell).trim());
+		rendered.push(`| ${values.join(" | ")} |`);
+		if (rowIndex === 0) rendered.push(`| ${cells.map(alignmentMarker).join(" | ")} |`);
+	}
+	return `\n\n${rendered.join("\n")}\n\n`;
+}
+/** Install GitHub fenced code blocks selected by `highlight-source-*` wrappers. */
+const highlightedCodeBlock = (service) => {
+	service.addRule("highlightedCodeBlock", {
+		filter(node) {
+			return node.nodeName === "DIV" && /(?:^|\s)highlight-source-([^\s]+)/.test(node.getAttribute("class") ?? "");
+		},
+		replacement(_content, node, options) {
+			const language = /(?:^|\s)highlight-source-([^\s]+)/.exec(node.getAttribute("class") ?? "")?.[1] ?? "";
+			const text = descendantElements(node, "PRE")[0]?.textContent ?? "";
+			return `\n\n${options.fence}${language}\n${text}\n${options.fence}\n\n`;
+		}
+	});
+};
+/** Install GFM strikethrough conversion. */
+const strikethrough = (service) => {
+	service.addRule("strikethrough", {
+		filter: [
+			"del",
+			"s",
+			"strike"
+		],
+		replacement(content) {
+			return `~${content}~`;
+		}
+	});
+};
+/** Install GFM task-list checkbox conversion. */
+const taskListItems = (service) => {
+	service.addRule("taskListItems", {
+		filter(node) {
+			return node.nodeName === "INPUT" && node.parentNode?.nodeName === "LI" && (node.getAttribute("type") ?? "").toLowerCase() === "checkbox";
+		},
+		replacement(_content, node) {
+			return node.hasAttribute("checked") ? "[x] " : "[ ] ";
+		}
+	});
+};
+/** Install GFM table conversion for tables with a heading row. */
+const tables = (service) => {
+	service.addRule("table", {
+		filter: isHeadingTable,
+		replacement(_content, node) {
+			return renderTable(service, node);
+		}
+	});
+};
+/** Install every GFM rule used by the coding agent. */
+const gfm = (service) => {
+	highlightedCodeBlock(service);
+	strikethrough(service);
+	tables(service);
+	taskListItems(service);
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/turndown/html.ts
+const VOID_ELEMENTS = {
+	AREA: true,
+	BASE: true,
+	BR: true,
+	COL: true,
+	EMBED: true,
+	HR: true,
+	IMG: true,
+	INPUT: true,
+	LINK: true,
+	META: true,
+	PARAM: true,
+	SOURCE: true,
+	TRACK: true,
+	WBR: true
+};
+const NAMED_ENTITIES = {
+	amp: "&",
+	apos: "'",
+	copy: "©",
+	gt: ">",
+	hellip: "…",
+	laquo: "«",
+	lt: "<",
+	mdash: "—",
+	nbsp: "\xA0",
+	ndash: "–",
+	quot: "\"",
+	raquo: "»",
+	reg: "®"
+};
+function decodeEntities(value) {
+	return value.replace(/&(#(?:x[\da-f]+|\d+)|[a-z][\da-z]+);?/gi, (entity, name) => {
+		if (name.charAt(0) === "#") {
+			const hexadecimal = name.charAt(1).toLowerCase() === "x";
+			const number = Number.parseInt(name.slice(hexadecimal ? 2 : 1), hexadecimal ? 16 : 10);
+			if (!Number.isFinite(number) || number <= 0 || number > 1114111) return entity;
+			try {
+				return String.fromCodePoint(number);
+			} catch {
+				return "�";
+			}
+		}
+		return NAMED_ENTITIES[name.toLowerCase()] ?? entity;
+	});
+}
+function escapeAttribute(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+var HtmlNode = class {
+	parentNode = null;
+	childNodes = [];
+	get children() {
+		return this.childNodes.filter((child) => child.nodeType === 1);
+	}
+	get firstChild() {
+		return this.childNodes[0] ?? null;
+	}
+	get lastChild() {
+		return this.childNodes[this.childNodes.length - 1] ?? null;
+	}
+	get previousSibling() {
+		if (!this.parentNode) return null;
+		const index = this.parentNode.childNodes.indexOf(this);
+		return index > 0 ? this.parentNode.childNodes[index - 1] ?? null : null;
+	}
+	get nextSibling() {
+		if (!this.parentNode) return null;
+		const index = this.parentNode.childNodes.indexOf(this);
+		return index >= 0 ? this.parentNode.childNodes[index + 1] ?? null : null;
+	}
+	get textContent() {
+		return this.childNodes.map((child) => child.textContent).join("");
+	}
+	getAttribute(_name) {
+		return null;
+	}
+	hasAttribute(_name) {
+		return false;
+	}
+	append(child) {
+		child.parentNode = this;
+		this.childNodes.push(child);
+	}
+};
+var HtmlText = class extends HtmlNode {
+	nodeType = 3;
+	nodeName = "#text";
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	get textContent() {
+		return this.value;
+	}
+	get outerHTML() {
+		return this.value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	}
+};
+var HtmlElement = class extends HtmlNode {
+	nodeType = 1;
+	nodeName;
+	#attributes;
+	constructor(name, attributes) {
+		super();
+		this.nodeName = name.toUpperCase();
+		this.#attributes = attributes;
+	}
+	getAttribute(name) {
+		return this.#attributes.get(name.toLowerCase()) ?? null;
+	}
+	hasAttribute(name) {
+		return this.#attributes.has(name.toLowerCase());
+	}
+	get outerHTML() {
+		const tag = this.nodeName.toLowerCase();
+		const attributes = [...this.#attributes].map(([name, value]) => value === "" ? name : `${name}="${escapeAttribute(value)}"`).join(" ");
+		const opening = `<${tag}${attributes ? ` ${attributes}` : ""}>`;
+		if (VOID_ELEMENTS[this.nodeName]) return opening;
+		return `${opening}${this.childNodes.map((child) => child.outerHTML).join("")}</${tag}>`;
+	}
+};
+var HtmlFragment = class extends HtmlNode {
+	nodeType = 11;
+	nodeName = "#document-fragment";
+	get outerHTML() {
+		return this.childNodes.map((child) => child.outerHTML).join("");
+	}
+};
+function parseAttributes(source) {
+	const attributes = /* @__PURE__ */ new Map();
+	for (const match of source.matchAll(/([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g)) {
+		const name = match[1]?.toLowerCase();
+		if (!name) continue;
+		attributes.set(name, decodeEntities(match[2] ?? match[3] ?? match[4] ?? ""));
+	}
+	return attributes;
+}
+function* htmlTokens(html) {
+	let cursor = 0;
+	while (cursor < html.length) {
+		if (html.charAt(cursor) !== "<") {
+			const nextTag = html.indexOf("<", cursor);
+			const end = nextTag < 0 ? html.length : nextTag;
+			yield html.slice(cursor, end);
+			cursor = end;
+			continue;
+		}
+		if (!/[/!a-z]/i.test(html.charAt(cursor + 1))) {
+			yield "<";
+			cursor++;
+			continue;
+		}
+		if (html.startsWith("<!--", cursor)) {
+			const commentEnd = html.indexOf("-->", cursor + 4);
+			const end = commentEnd < 0 ? html.length : commentEnd + 3;
+			yield html.slice(cursor, end);
+			cursor = end;
+			continue;
+		}
+		let quote;
+		let tagEnd = cursor + 1;
+		for (; tagEnd < html.length; tagEnd++) {
+			const character = html.charAt(tagEnd);
+			if (quote) {
+				if (character === quote) quote = void 0;
+			} else if (character === "\"" || character === "'") quote = character;
+			else if (character === ">") break;
+		}
+		if (tagEnd >= html.length) {
+			yield "<";
+			cursor++;
+			continue;
+		}
+		yield html.slice(cursor, tagEnd + 1);
+		cursor = tagEnd + 1;
+	}
+}
+/** Parse an HTML fragment into the small DOM subset needed by Turndown. */
+function parseHtmlFragment(html) {
+	const root = new HtmlFragment();
+	const stack = [root];
+	for (const token of htmlTokens(html)) {
+		const parent = stack[stack.length - 1] ?? root;
+		if (token.startsWith("<!--") || /^<!/i.test(token)) continue;
+		if (!token.startsWith("<")) {
+			parent.append(new HtmlText(decodeEntities(token)));
+			continue;
+		}
+		const closing = /^<\/\s*([a-z][\w:-]*)[^>]*>$/i.exec(token);
+		if (closing) {
+			const name = closing[1]?.toUpperCase();
+			for (let index = stack.length - 1; index > 0; index--) {
+				if (stack[index]?.nodeName !== name) continue;
+				stack.length = index;
+				break;
+			}
+			continue;
+		}
+		const opening = /^<\s*([a-z][\w:-]*)([\s\S]*?)\/?\s*>$/i.exec(token);
+		if (!opening?.[1]) {
+			parent.append(new HtmlText("<"));
+			continue;
+		}
+		const element = new HtmlElement(opening[1], parseAttributes(opening[2] ?? ""));
+		parent.append(element);
+		if (!VOID_ELEMENTS[element.nodeName] && !/\/\s*>$/.test(token)) stack.push(element);
+	}
+	return root;
+}
+/** Serialize a standards-shaped or internal HTML node. */
+function serializeNode(node) {
+	if (typeof node.outerHTML === "string") return node.outerHTML;
+	if (node.nodeType === 3) return node.textContent ?? "";
+	return Array.from(node.childNodes).map(serializeNode).join("");
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/turndown/service.ts
+const BLOCK_ELEMENTS = {
+	ADDRESS: true,
+	ARTICLE: true,
+	ASIDE: true,
+	BLOCKQUOTE: true,
+	BODY: true,
+	CANVAS: true,
+	CENTER: true,
+	DD: true,
+	DETAILS: true,
+	DIR: true,
+	DIV: true,
+	DL: true,
+	DT: true,
+	FIELDSET: true,
+	FIGCAPTION: true,
+	FIGURE: true,
+	FOOTER: true,
+	FORM: true,
+	FRAMESET: true,
+	H1: true,
+	H2: true,
+	H3: true,
+	H4: true,
+	H5: true,
+	H6: true,
+	HEADER: true,
+	HGROUP: true,
+	HR: true,
+	HTML: true,
+	ISINDEX: true,
+	LI: true,
+	MAIN: true,
+	MENU: true,
+	NAV: true,
+	NOFRAMES: true,
+	NOSCRIPT: true,
+	OL: true,
+	OUTPUT: true,
+	P: true,
+	PRE: true,
+	SECTION: true,
+	SUMMARY: true,
+	TABLE: true,
+	TBODY: true,
+	TD: true,
+	TFOOT: true,
+	TH: true,
+	THEAD: true,
+	TR: true,
+	UL: true
+};
+const NONBLANK_EMPTY_ELEMENTS = {
+	A: true,
+	AUDIO: true,
+	BR: true,
+	HR: true,
+	IFRAME: true,
+	IMG: true,
+	INPUT: true,
+	SCRIPT: true,
+	SOURCE: true,
+	TD: true,
+	TH: true,
+	VIDEO: true
+};
+const DEFAULT_OPTIONS = {
+	headingStyle: "setext",
+	hr: "* * *",
+	bulletListMarker: "*",
+	codeBlockStyle: "indented",
+	fence: "```",
+	emDelimiter: "_",
+	strongDelimiter: "**",
+	linkStyle: "inlined",
+	linkReferenceStyle: "full",
+	preformattedCode: false
+};
+function matchesFilter(filter, node, options) {
+	if (typeof filter === "function") return filter(node, options);
+	const name = node.nodeName.toLowerCase();
+	if (typeof filter === "string") return name === filter.toLowerCase();
+	return filter.some((tag) => name === tag.toLowerCase());
+}
+function contentWithFlankingWhitespace(content, delimiter) {
+	const leading = content.match(/^\s+/)?.[0] ?? "";
+	const trailing = content.match(/\s+$/)?.[0] ?? "";
+	const body = content.slice(leading.length, trailing ? -trailing.length : void 0);
+	return body ? `${leading}${delimiter}${body}${delimiter}${trailing}` : "";
+}
+function languageFromCode(node) {
+	const className = Array.from(node.children).find((child) => child.nodeName === "CODE")?.getAttribute("class") ?? "";
+	return /(?:^|\s)language-([^\s]+)/.exec(className)?.[1] ?? "";
+}
+function listItemPrefix(node, options) {
+	const parent = node.parentNode;
+	if (parent?.nodeName !== "OL") return `${options.bulletListMarker}   `;
+	const start = Number(parent.getAttribute("start") ?? "1");
+	const siblings = Array.from(parent.children);
+	return `${(Number.isFinite(start) ? start : 1) + siblings.indexOf(node)}.  `;
+}
+function hasNonblankDescendant(node) {
+	for (const child of Array.from(node.children)) if (NONBLANK_EMPTY_ELEMENTS[child.nodeName] || hasNonblankDescendant(child)) return true;
+	return false;
+}
+/** Convert HTML fragments to Markdown with extensible Turndown-compatible rules. */
+var TurndownService = class {
+	options;
+	#rules = [];
+	#keepFilters = [];
+	#removeFilters = [];
+	#references = [];
+	#previousSourceWhitespace = false;
+	constructor(options = {}) {
+		this.options = {
+			...DEFAULT_OPTIONS,
+			...options
+		};
+	}
+	/** Install a highest-priority named conversion rule. */
+	addRule(key, rule) {
+		const previous = this.#rules.findIndex((entry) => entry.key === key);
+		if (previous >= 0) this.#rules.splice(previous, 1);
+		this.#rules.unshift({
+			key,
+			rule
+		});
+		return this;
+	}
+	/** Preserve matching elements as HTML when no custom rule handles them. */
+	keep(filter) {
+		this.#keepFilters.unshift(filter);
+		return this;
+	}
+	/** Drop matching elements and all of their converted content. */
+	remove(filter) {
+		this.#removeFilters.unshift(filter);
+		return this;
+	}
+	/** Install one plugin or an ordered list of plugins. */
+	use(plugin) {
+		if (typeof plugin === "function") plugin(this);
+		else for (const install of plugin) install(this);
+		return this;
+	}
+	/** Escape Markdown punctuation using Turndown's public escaping rules. */
+	escape(text) {
+		return text.replace(/\\/g, "\\\\").replace(/([*_[\]])/g, "\\$1").replace(/^(\s*)(#{1,6}|[+>])(?=\s)/gm, "$1\\$2").replace(/^(\s*)-(?=\s)/gm, "$1\\-").replace(/^(\s*\d+)\.(?=\s)/gm, "$1\\.");
+	}
+	/** Convert an HTML string or standards-shaped DOM node to Markdown. */
+	turndown(input) {
+		const root = typeof input === "string" ? parseHtmlFragment(input) : input;
+		this.#references = [];
+		this.#previousSourceWhitespace = false;
+		let markdown = root.nodeType === 9 || root.nodeType === 11 ? this.#convertChildren(root) : this.#convertNode(root);
+		markdown = markdown.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n ]+$/, "").replace(/\n{3,}/g, "\n\n");
+		if (this.#references.length > 0) markdown += `\n\n${this.#references.map((reference) => reference.destination).join("\n")}`;
+		return markdown;
+	}
+	/** Convert only a node's children within the active conversion. */
+	convertChildren(node) {
+		return this.#convertChildren(node);
+	}
+	#convertChildren(node) {
+		let content = "";
+		for (const child of Array.from(node.childNodes)) content += this.#convertNode(child);
+		return content;
+	}
+	#convertNode(node) {
+		if (node.nodeType === 3) {
+			const text = node.textContent ?? "";
+			if (node.parentNode?.nodeName === "PRE") return text;
+			let collapsed = text.replace(/[\t\r\n\f ]+/g, " ");
+			if (this.#previousSourceWhitespace && collapsed.startsWith(" ")) collapsed = collapsed.slice(1);
+			this.#previousSourceWhitespace = collapsed.endsWith(" ");
+			return node.parentNode?.nodeName === "CODE" ? collapsed : this.escape(collapsed);
+		}
+		if (node.nodeType !== 1) return this.#convertChildren(node);
+		if (!(node.textContent ?? "").trim() && !NONBLANK_EMPTY_ELEMENTS[node.nodeName] && !hasNonblankDescendant(node)) return this.options.blankReplacement?.("", node, this.options) ?? (BLOCK_ELEMENTS[node.nodeName] ? "\n\n" : "");
+		const block = Boolean(BLOCK_ELEMENTS[node.nodeName]);
+		if (block) this.#previousSourceWhitespace = false;
+		const content = this.#convertChildren(node);
+		if (block) this.#previousSourceWhitespace = false;
+		if (node.nodeName === "CODE") this.#previousSourceWhitespace = false;
+		const custom = this.#rules.find((entry) => matchesFilter(entry.rule.filter, node, this.options));
+		if (custom) return custom.rule.replacement(content, node, this.options);
+		if (this.#keepFilters.some((filter) => matchesFilter(filter, node, this.options))) return this.options.keepReplacement?.(content, node, this.options) ?? serializeNode(node);
+		if (this.#removeFilters.some((filter) => matchesFilter(filter, node, this.options))) return "";
+		return this.#defaultReplacement(content, node);
+	}
+	#defaultReplacement(content, node) {
+		const name = node.nodeName;
+		if (name === "P") return content.trim() ? `\n\n${content.trim()}\n\n` : "";
+		if (/^H[1-6]$/.test(name)) {
+			const level = Number(name.charAt(1));
+			const body = content.trim();
+			if (this.options.headingStyle === "setext" && level < 3) return `\n\n${body}\n${(level === 1 ? "=" : "-").repeat(body.length)}\n\n`;
+			return `\n\n${"#".repeat(level)} ${body}\n\n`;
+		}
+		if (name === "BR") return "  \n";
+		if (name === "HR") return `\n\n${this.options.hr}\n\n`;
+		if (name === "BLOCKQUOTE") {
+			const body = content.trim().replace(/\n{3,}/g, "\n\n").replace(/^/gm, "> ");
+			return body ? `\n\n${body}\n\n` : "";
+		}
+		if (name === "UL" || name === "OL") {
+			const body = content.replace(/^\n+|\n+$/g, "");
+			return node.parentNode?.nodeName === "LI" ? `\n${body}` : `\n\n${body}\n\n`;
+		}
+		if (name === "LI") {
+			const body = content.replace(/^\n+/, "").replace(/\n+$/, "\n").replace(/\n/gm, "\n    ");
+			return `${listItemPrefix(node, this.options)}${body}${node.nextSibling ? "\n" : ""}`;
+		}
+		if (name === "PRE" && Array.from(node.children).some((child) => child.nodeName === "CODE")) return this.#replacePre(node);
+		if (name === "EM" || name === "I") return contentWithFlankingWhitespace(content, this.options.emDelimiter);
+		if (name === "STRONG" || name === "B") return contentWithFlankingWhitespace(content, this.options.strongDelimiter);
+		if (name === "CODE") return this.#replaceInlineCode(content);
+		if (name === "A") return this.#replaceLink(content, node);
+		if (name === "IMG") return this.#replaceImage(node);
+		if (this.options.defaultReplacement) return this.options.defaultReplacement(content, node, this.options);
+		if (BLOCK_ELEMENTS[name]) return content.trim() ? `\n\n${content.trim()}\n\n` : "";
+		return content;
+	}
+	#replacePre(node) {
+		const text = node.textContent ?? "";
+		if (this.options.codeBlockStyle === "indented") return `\n\n${text.replace(/^/gm, "    ")}\n\n`;
+		const fenceCharacter = this.options.fence.charAt(0);
+		let longestFence = this.options.fence.length;
+		let run = 0;
+		for (const character of text) {
+			run = character === fenceCharacter ? run + 1 : 0;
+			longestFence = Math.max(longestFence, run + 1);
+		}
+		const fence = fenceCharacter.repeat(longestFence);
+		const body = text.replace(/\n$/, "");
+		return `\n\n${fence}${languageFromCode(node)}\n${body}\n${fence}\n\n`;
+	}
+	#replaceInlineCode(text) {
+		const body = text.trim();
+		if (!body) return "";
+		let longestRun = 0;
+		let run = 0;
+		for (const character of body) {
+			run = character === "`" ? run + 1 : 0;
+			longestRun = Math.max(longestRun, run);
+		}
+		const delimiter = "`".repeat(longestRun + 1);
+		const padding = /^`|`$/.test(body) ? " " : "";
+		return `${delimiter}${padding}${body}${padding}${delimiter}`;
+	}
+	#replaceLink(content, node) {
+		const href = (node.getAttribute("href") ?? "").replace(/([()<>])/g, "\\$1");
+		const title = node.getAttribute("title");
+		const destination = `${href}${title ? ` "${title.replace(/"/g, "\\\"")}"` : ""}`;
+		if (this.options.linkStyle !== "referenced") return `[${content}](${destination})`;
+		const referenceNumber = this.#references.length + 1;
+		let label = String(referenceNumber);
+		if (this.options.linkReferenceStyle === "collapsed") label = "";
+		if (this.options.linkReferenceStyle === "shortcut") label = content;
+		const marker = this.options.linkReferenceStyle === "shortcut" ? `[${content}]` : `[${content}][${label}]`;
+		this.#references.push({ destination: `[${label || content}]: ${destination}` });
+		return marker;
+	}
+	#replaceImage(node) {
+		const source = (node.getAttribute("src") ?? "").replace(/([()<>])/g, "\\$1");
+		if (!source) return "";
+		const alternative = this.escape(node.getAttribute("alt") ?? "");
+		const title = node.getAttribute("title");
+		return `![${alternative}](${source}${title ? ` "${title.replace(/"/g, "\\\"")}"` : ""})`;
+	}
+};
+//#endregion
+//#region src/tools/omp/utils/turndown.ts
+var turndown_exports = /* @__PURE__ */ __exportAll({
+	createTurndown: () => createTurndown,
+	normalizeTablesHtml: () => normalizeTablesHtml
+});
+/**
+* Build a Turndown instance configured for GFM with the fixes omp relies on:
+* `~~strikethrough~~`, unescaped heading periods, and single-space list markers.
+*
+* Shared by the web scrapers (HTML → markdown) and the markit document engine
+* (`src/markit`). The rule set must stay identical across both call sites.
+*/
+function createTurndown() {
+	const turndown = new TurndownService({
+		headingStyle: "atx",
+		codeBlockStyle: "fenced",
+		bulletListMarker: "-"
+	});
+	turndown.use(gfm);
+	turndown.addRule("strikethrough", {
+		filter: [
+			"del",
+			"s",
+			"strike"
+		],
+		replacement(content) {
+			return `~~${content}~~`;
+		}
+	});
+	turndown.addRule("heading", {
+		filter: [
+			"h1",
+			"h2",
+			"h3",
+			"h4",
+			"h5",
+			"h6"
+		],
+		replacement(content, node) {
+			const level = Number(node.nodeName.charAt(1));
+			return `\n\n${"#".repeat(level)} ${content.replace(/\\([.])/g, "$1").trim()}\n\n`;
+		}
+	});
+	turndown.addRule("listItem", {
+		filter: "li",
+		replacement(content, node, options) {
+			const body = content.replace(/^\n+/, "").replace(/\n+$/, "\n").replace(/\n/gm, "\n  ");
+			const parent = node.parentNode;
+			let prefix = `${options.bulletListMarker} `;
+			if (parent?.nodeName === "OL") {
+				const start = parent.getAttribute("start");
+				const index = Array.prototype.indexOf.call(parent.children, node);
+				prefix = `${(start ? Number(start) : 1) + index}. `;
+			}
+			return prefix + body + (node.nextSibling ? "\n" : "");
+		}
+	});
+	return turndown;
+}
+/**
+* Normalize HTML tables so turndown-plugin-gfm can render them:
+* - strip `<p>` tags inside `<td>`/`<th>` cells (joining paragraphs with a space)
+* - wrap the first row in `<thead>` when missing
+*/
+function normalizeTablesHtml(html) {
+	let result = html.replace(/<(td|th)([^>]*)>([\s\S]*?)<\/(td|th)>/gi, (_match, tag, attrs, inner, closeTag) => {
+		return `<${tag}${attrs}>${inner.replace(/^\s*<p>/i, "").replace(/<\/p>\s*$/i, "").replace(/<\/p>\s*<p>/gi, " ")}</${closeTag}>`;
+	});
+	result = result.replace(/<table([^>]*)>\s*(?:<tbody>\s*)?(<tr[\s\S]*?<\/tr>)([\s\S]*?)<\/(?:tbody>\s*<\/)?table>/gi, (_match, attrs, firstRow, rest) => {
+		return `<table${attrs}><thead>${firstRow.replace(/<td/gi, "<th").replace(/<\/td>/gi, "</th>")}</thead><tbody>${rest}</tbody></table>`;
+	});
+	return result;
+}
+//#endregion
+export { normalizeTablesHtml as n, turndown_exports as r, createTurndown as t };

package/lib/types/config/settings.d.ts

@@ -95,7 +95,15 @@ export interface RuntimeConfig {
 export declare const BASH_PLUS_SETTINGS_NS: import("@deepseek-ai/dsh-settings").SettingsNamespace;
 /** OMP-parity defaults for the completion-message truncation policy. */
 export declare const DEFAULT_OUTPUT_TRUNCATE: OutputTruncateConfig;
-/** OMP-parity defaults for the timing knobs (timeouts in ms; OMP uses seconds). */
+/**
+ * Timing knobs (ms). DEFAULT_MAX_TIMEOUT_MS is OMP-parity (= upstream bash
+ * per-tool max 3600s); DEFAULT_TIMEOUT_MS was deliberately relaxed from
+ * 300_000 to 3_600_000 with the bash-plus settings card (763023e,
+ * 2026-08-19) — NOT OMP-parity (OMP bash default is 300s), compensated by
+ * auto-backgrounding after DEFAULT_AUTO_BACKGROUND_MS. By design there is no
+ * upstream `tools.maxTimeout` global-cap equivalent: maxTimeoutMs always
+ * applies. (second-impl-audit.md S-11 终局, 2026-08-29.)
+ */
 export declare const DEFAULT_TIMEOUT_MS = 3600000;
 export declare const DEFAULT_MAX_TIMEOUT_MS = 3600000;
 export declare const DEFAULT_AUTO_BACKGROUND_MS = 60000;