dsh-hs-classify 0.0.0-stage → 0.2.1

package/lib/index.mjs

@@ -0,0 +1,2705 @@
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import Schema from "@deepseek-ai/schemastery";
+//#region src/config.ts
+const Config = Schema.object({
+	rulesFile: Schema.string().default("rules/hs-classify.yaml").description("规则库文件路径（相对插件包根目录）。替换该文件即可切换规则集版本。"),
+	disabledRules: Schema.array(Schema.string()).default([]).description("要停用的规则 id 列表；停用的规则会出现在报告的 skipped 中。"),
+	onlyRules: Schema.array(Schema.string()).default([]).description("只执行这些规则 id；留空表示执行全部规则。"),
+	skipNotes: Schema.string().default("").description("附加到每条 skipped 说明后的备注，例如标注本机构实施细则。"),
+	timeoutMs: Schema.number().default(12e4).description("工具协作式超时预算（毫秒）。")
+});
+//#endregion
+//#region src/shared/yaml.ts
+/**
+* Minimal, dependency-free YAML reader for rule packs and check material.
+*
+* Rule packs are authored by hand and shipped inside each plugin, so the
+* supported surface is deliberately small and strictly block-structured:
+*
+* ```yaml
+* version: "2026.1"
+* rules:
+*   - id: R-001
+*     severity: error
+*     basis:
+*       document: 《病历书写基本规范》
+*       clause: 第二十二条（八）
+*     params:
+*       maxHours: 6
+*     note: >-
+*       Folded scalars join their lines with single spaces.
+* ```
+*
+* Supported: nested block mappings, block sequences, `- key: value` items,
+* plain / single- / double-quoted scalars, the empty collections `[]` and `{}`,
+* literal `|` and folded `>` block scalars, `#` comments and blank lines.
+*
+* Rejected loudly rather than guessed: flow collections, anchors, aliases, tags
+* and multi-document streams.
+*/
+/** Raised when a document uses syntax outside the supported subset. */
+var YamlSubsetError = class extends Error {
+	constructor(message, line) {
+		super(line === void 0 ? message : `${message} (line ${line})`);
+		this.name = "YamlSubsetError";
+	}
+};
+function stripComment(raw, lineNum) {
+	let quote = null;
+	for (let index = 0; index < raw.length; index++) {
+		const char = raw[index];
+		if (quote !== null) {
+			if (quote === "\"" && char === "\\") {
+				index += 1;
+				continue;
+			}
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "#" && (index === 0 || /\s/.test(raw[index - 1]))) return raw.slice(0, index);
+	}
+	if (quote !== null) throw new YamlSubsetError("unterminated quoted scalar", lineNum);
+	return raw;
+}
+function unescapeDouble(body, lineNum) {
+	let out = "";
+	for (let index = 0; index < body.length; index++) {
+		const char = body[index];
+		if (char !== "\\") {
+			out += char;
+			continue;
+		}
+		const next = body[index + 1];
+		if (next === void 0) throw new YamlSubsetError("dangling escape in double-quoted scalar", lineNum);
+		index += 1;
+		switch (next) {
+			case "n":
+				out += "\n";
+				break;
+			case "t":
+				out += "	";
+				break;
+			case "r":
+				out += "\r";
+				break;
+			case "\"":
+				out += "\"";
+				break;
+			case "\\":
+				out += "\\";
+				break;
+			case "0":
+				out += "\0";
+				break;
+			default: throw new YamlSubsetError(`unsupported escape "\\${next}"`, lineNum);
+		}
+	}
+	return out;
+}
+/** Index of the `:` separating key from value, or -1 when the text is a scalar. */
+function findKeySeparator(text) {
+	let quote = null;
+	for (let index = 0; index < text.length; index++) {
+		const char = text[index];
+		if (quote !== null) {
+			if (quote === "\"" && char === "\\") {
+				index += 1;
+				continue;
+			}
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === ":" && (index + 1 === text.length || /\s/.test(text[index + 1]))) return index;
+	}
+	return -1;
+}
+function isSequenceItem(text) {
+	return text === "-" || text.startsWith("- ");
+}
+function parseScalar(raw, lineNum) {
+	const text = raw.trim();
+	if (text === "") return null;
+	if (text.startsWith("[") || text.startsWith("{")) return parseFlow(text, lineNum);
+	if (text.startsWith("&") || text.startsWith("*") || text.startsWith("!")) throw new YamlSubsetError("anchors, aliases and tags are not supported by this reader", lineNum);
+	if (text.startsWith("\"")) {
+		if (text.length < 2 || !text.endsWith("\"")) throw new YamlSubsetError("bad double-quoted scalar", lineNum);
+		return unescapeDouble(text.slice(1, -1), lineNum);
+	}
+	if (text.startsWith("'")) {
+		if (text.length < 2 || !text.endsWith("'")) throw new YamlSubsetError("bad single-quoted scalar", lineNum);
+		return text.slice(1, -1).replace(/''/g, "'");
+	}
+	if (text === "null" || text === "~") return null;
+	if (text === "true") return true;
+	if (text === "false") return false;
+	if (/^[+-]?\d+$/.test(text)) return Number.parseInt(text, 10);
+	if (/^[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)?$/.test(text)) return Number.parseFloat(text);
+	return text;
+}
+/**
+* Parse a flow collection (`[a, b]` or `{k: v}`), including nesting.
+*
+* Hand-written packs use flow style for short lists — a rule's `aliases`, for
+* example — so supporting it keeps those packs readable. Only the JSON-compatible
+* subset is accepted: no anchors, no tags, no multi-line flow.
+*/
+function parseFlow(text, lineNum) {
+	let index = 0;
+	const skipSpace = () => {
+		while (index < text.length && /\s/.test(text[index])) index += 1;
+	};
+	const readToken = (stopAtColon) => {
+		skipSpace();
+		const char = text[index];
+		if (char === void 0) throw new YamlSubsetError("unexpected end of flow collection", lineNum);
+		if (char === "[" || char === "{") return readCollection();
+		if (char === "\"" || char === "'") {
+			const quote = char;
+			let body = "";
+			index += 1;
+			while (index < text.length) {
+				const current = text[index];
+				if (quote === "\"" && current === "\\") {
+					body += current + (text[index + 1] ?? "");
+					index += 2;
+					continue;
+				}
+				if (current === quote) {
+					if (quote === "'" && text[index + 1] === "'") {
+						body += "'";
+						index += 2;
+						continue;
+					}
+					index += 1;
+					return quote === "\"" ? unescapeDouble(body, lineNum) : body;
+				}
+				body += current;
+				index += 1;
+			}
+			throw new YamlSubsetError("unterminated quoted scalar in flow collection", lineNum);
+		}
+		let plain = "";
+		while (index < text.length) {
+			const current = text[index];
+			if (current === "," || current === "]" || current === "}") break;
+			if (stopAtColon && current === ":") break;
+			plain += current;
+			index += 1;
+		}
+		return parseScalar(plain, lineNum);
+	};
+	const readCollection = () => {
+		const open = text[index];
+		const close = open === "[" ? "]" : "}";
+		index += 1;
+		if (open === "[") {
+			const items = [];
+			skipSpace();
+			if (text[index] === close) {
+				index += 1;
+				return items;
+			}
+			for (;;) {
+				items.push(readToken(false));
+				skipSpace();
+				const separator = text[index];
+				if (separator === ",") {
+					index += 1;
+					continue;
+				}
+				if (separator === close) {
+					index += 1;
+					return items;
+				}
+				throw new YamlSubsetError(`expected "," or "${close}" in flow sequence`, lineNum);
+			}
+		}
+		const out = {};
+		skipSpace();
+		if (text[index] === close) {
+			index += 1;
+			return out;
+		}
+		for (;;) {
+			const key = readToken(true);
+			skipSpace();
+			if (text[index] !== ":") throw new YamlSubsetError("expected \":\" in flow mapping", lineNum);
+			index += 1;
+			const value = readToken(false);
+			out[String(key)] = value;
+			skipSpace();
+			const separator = text[index];
+			if (separator === ",") {
+				index += 1;
+				continue;
+			}
+			if (separator === close) {
+				index += 1;
+				return out;
+			}
+			throw new YamlSubsetError(`expected "," or "${close}" in flow mapping`, lineNum);
+		}
+	};
+	const value = readCollection();
+	skipSpace();
+	if (index !== text.length) throw new YamlSubsetError(`trailing characters after flow collection: "${text.slice(index)}"`, lineNum);
+	return value;
+}
+/**
+* Recursive-descent reader over pre-tokenized content lines.
+*
+* The single invariant: every `parse*` method consumes only lines whose indent
+* is at least the indent it was given for that collection, and stops at the
+* first line that is shallower. A child may be indented by any amount deeper
+* than its parent entry, because hand-written packs do not agree on a step.
+*/
+var Reader = class {
+	index = 0;
+	/** Content lines, in document order. */
+	lines;
+	constructor(lines) {
+		this.lines = lines;
+	}
+	/** Current line, or undefined at end of document. */
+	peek() {
+		return this.lines[this.index];
+	}
+	/** Consume and return the current line. */
+	take() {
+		const line = this.lines[this.index];
+		if (line === void 0) throw new YamlSubsetError("unexpected end of document");
+		this.index += 1;
+		return line;
+	}
+	/** Body of a `|` or `>` block scalar, stopping at the first line at or above `parentIndent`. */
+	readBlockScalar(parentIndent, kind, startLine) {
+		const collected = [];
+		let blockIndent = null;
+		while (true) {
+			const next = this.peek();
+			if (next === void 0 || next.indent <= parentIndent) break;
+			this.index += 1;
+			if (blockIndent === null) blockIndent = next.indent;
+			collected.push(" ".repeat(Math.max(0, next.indent - blockIndent)) + next.text);
+		}
+		if (blockIndent === null) throw new YamlSubsetError("empty block scalar", startLine);
+		if (kind === "|") return collected.join("\n");
+		return collected.map((entry) => entry.trim()).filter((entry) => entry !== "").join(" ");
+	}
+	/**
+	* Read the value of `key:` whose scalar part was empty.
+	* @param keyIndent - column of the key, so a shallower sibling ends the value.
+	*/
+	readNested(keyIndent) {
+		const next = this.peek();
+		if (next === void 0 || next.indent <= keyIndent) return null;
+		return this.readCollection(next.indent);
+	}
+	/**
+	* Read a mapping or sequence starting at the current line.
+	* @param indent - column at which the collection's entries must start.
+	*/
+	readCollection(indent) {
+		const line = this.peek();
+		if (line === void 0 || line.indent < indent) return null;
+		return isSequenceItem(line.text) ? this.readSequence(line.indent) : this.readMapping(line.indent);
+	}
+	/**
+	* Read a block mapping whose entries sit at `indent`.
+	* @param indent - column the mapping entries occupy.
+	* @param seed - first entry that shares a `- ` line and was already consumed.
+	*/
+	readMapping(indent, seed) {
+		const out = {};
+		let pending = seed;
+		for (;;) {
+			if (pending === void 0) {
+				const line = this.peek();
+				if (line === void 0 || line.indent < indent) break;
+				if (line.indent > indent) throw new YamlSubsetError("unexpected indentation in block mapping", line.num);
+				if (isSequenceItem(line.text)) break;
+				this.index += 1;
+				pending = {
+					text: line.text,
+					line: line.num
+				};
+			}
+			const separator = findKeySeparator(pending.text);
+			if (separator < 0) throw new YamlSubsetError(`expected "key: value", got "${pending.text}"`, pending.line);
+			const key = pending.text.slice(0, separator).trim();
+			if (key === "") throw new YamlSubsetError("empty mapping key", pending.line);
+			if (Object.hasOwn(out, key)) throw new YamlSubsetError(`duplicate mapping key "${key}"`, pending.line);
+			out[key] = this.readEntryValue(pending.text.slice(separator + 1).trim(), indent, pending.line);
+			pending = void 0;
+		}
+		return out;
+	}
+	/** Value that follows `key:` on the same line, or the nested collection below it. */
+	readEntryValue(rawValue, keyIndent, lineNum) {
+		if (rawValue === "|" || rawValue === "|-" || rawValue === ">" || rawValue === ">-") return this.readBlockScalar(keyIndent, rawValue.startsWith("|") ? "|" : ">", lineNum);
+		if (rawValue !== "") return parseScalar(rawValue, lineNum);
+		return this.readNested(keyIndent);
+	}
+	/**
+	* Read a block sequence whose dashes sit at `indent`. A `- key: value` line
+	* opens a mapping whose first entry shares the dash line; the remaining entries
+	* follow at the key column, which is two past the dash.
+	*/
+	readSequence(indent) {
+		const items = [];
+		for (;;) {
+			const line = this.peek();
+			if (line === void 0 || line.indent < indent) break;
+			if (line.indent > indent) throw new YamlSubsetError("unexpected indentation in block sequence", line.num);
+			if (!isSequenceItem(line.text)) break;
+			this.index += 1;
+			const rest = line.text === "-" ? "" : line.text.slice(2).trim();
+			if ((rest === "" ? -1 : findKeySeparator(rest)) >= 0) {
+				items.push(this.readMapping(indent + 2, {
+					text: rest,
+					line: line.num
+				}));
+				continue;
+			}
+			items.push(rest === "" ? this.readNested(indent) : parseScalar(rest, line.num));
+		}
+		return items;
+	}
+};
+/**
+* Turn raw YAML text into content lines, dropping comments and blank lines.
+*
+* Inside a `|` or `>` block scalar nothing is YAML syntax any more — quotes,
+* hashes and colons are content — so the reader tracks the block's indentation
+* and passes those lines through verbatim. Without this, a procurement clause
+* quoted inside a rule's `note` would be read as an unterminated string.
+*/
+function tokenize(source) {
+	const rawLines = source.split(/\r?\n/);
+	const lines = [];
+	let blockIndent = null;
+	let blockParentIndent = -1;
+	for (let index = 0; index < rawLines.length; index++) {
+		const num = index + 1;
+		const raw = rawLines[index];
+		const expanded = raw.replace(/\t/g, "  ");
+		const indent = expanded.length - expanded.trimStart().length;
+		const body = expanded.trim();
+		if (blockIndent !== null) {
+			if (body === "") continue;
+			if (indent <= blockParentIndent) blockIndent = null;
+			else {
+				lines.push({
+					indent,
+					text: body,
+					num
+				});
+				continue;
+			}
+		}
+		const withoutComment = stripComment(raw, num);
+		if (withoutComment.trim() === "") continue;
+		const text = withoutComment.replace(/\t/g, "  ").trim();
+		const effectiveIndent = withoutComment.replace(/\t/g, "  ").length - withoutComment.replace(/\t/g, "  ").trimStart().length;
+		lines.push({
+			indent: effectiveIndent,
+			text,
+			num
+		});
+		if (/:\s*[|>][+-]?\s*$/.test(text)) {
+			blockIndent = effectiveIndent + 1;
+			blockParentIndent = effectiveIndent;
+		}
+	}
+	return lines;
+}
+/**
+* Parse one block-structured YAML document.
+* @param source - YAML text.
+* @returns the parsed value; an empty document yields `null`.
+*/
+function parseYaml(source) {
+	const lines = tokenize(source);
+	if (lines.length === 0) return null;
+	const reader = new Reader(lines);
+	const value = reader.readCollection(lines[0].indent);
+	const leftover = reader.peek();
+	if (leftover !== void 0) throw new YamlSubsetError("trailing content after document", leftover.num);
+	return value;
+}
+/** Read a required string field, failing loudly when absent. */
+function requireString(source, key, where) {
+	const value = source[key];
+	if (typeof value !== "string" || value.trim() === "") throw new YamlSubsetError(`${where}: missing required string field "${key}"`);
+	return value;
+}
+//#endregion
+//#region src/shared/table.ts
+/**
+* Generic reader for table-shaped check plugins.
+*
+* Pairs with `rows.ts`: that module runs the checks, this one builds the table it
+* runs them on. A plugin supplies a column alias map and gets back a `TableInput`,
+* so the twenty-odd table plugins share one reader instead of each re-implementing
+* JSON/YAML detection, numeric coercion and the "which columns did I actually
+* see" diagnostic.
+*
+* The reader is deliberately strict about one thing: when the material carries
+* **none** of the aliases it was given, it refuses rather than guessing. A reader
+* that silently picks a column produces findings about the wrong data, which is
+* worse than an error message that names the columns it saw.
+*/
+/** Raised when the material cannot be read at all. */
+var MaterialError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "MaterialError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Render a scalar cell as text, dropping values that carry nothing. */
+function cellText(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "string") return value.trim() === "" ? void 0 : value.trim();
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "boolean") return String(value);
+}
+/** The comparison key for a column or field name. */
+function normaliseName(value) {
+	return value.toLowerCase().replace(/[\s\u3000_-]/g, "");
+}
+/** Find a cell by any of its aliases, exact name first, then normalised. */
+function pick(fields, aliases) {
+	for (const alias of aliases) {
+		const direct = fields[alias];
+		if (direct !== void 0 && direct !== "") return direct;
+	}
+	const normalised = new Map(Object.keys(fields).map((key) => [normaliseName(key), key]));
+	for (const alias of aliases) {
+		const key = normalised.get(normaliseName(alias));
+		if (key === void 0) continue;
+		const value = fields[key];
+		if (value !== void 0 && value !== "") return value;
+	}
+}
+/**
+* Parse one material into a table.
+*
+* @param source - JSON or YAML text.
+* @param target - description of where the material came from.
+* @param spec - the plugin's table shape.
+* @returns the normalized table.
+*/
+function parseTable(source, target, spec) {
+	const trimmed = source.trim();
+	if (trimmed === "") throw new MaterialError("材料为空");
+	let document;
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) try {
+		document = JSON.parse(trimmed);
+	} catch (error) {
+		throw new MaterialError(`JSON 无法解析：${error instanceof Error ? error.message : String(error)}`);
+	}
+	else try {
+		document = parseYaml(trimmed);
+	} catch (error) {
+		if (error instanceof YamlSubsetError) throw new MaterialError(`YAML 无法解析：${error.message}`);
+		throw error;
+	}
+	const warnings = [];
+	let list;
+	const header = {};
+	if (Array.isArray(document)) list = document;
+	else if (isRecord(document)) {
+		for (const key of spec.rowKeys) {
+			const candidate = document[key];
+			if (candidate !== void 0 && candidate !== null) {
+				list = candidate;
+				break;
+			}
+		}
+		const scalars = {};
+		for (const [key, value] of Object.entries(document)) {
+			const rendered = cellText(value);
+			if (rendered !== void 0) scalars[key] = rendered;
+		}
+		for (const [field, aliases] of Object.entries(spec.header ?? {})) {
+			const value = pick(scalars, aliases);
+			if (value !== void 0) header[field] = value;
+		}
+		for (const [key, value] of Object.entries(scalars)) if (header[key] === void 0) header[key] = value;
+	} else throw new MaterialError("材料根节点必须是映射或列表");
+	if (list === void 0 || list === null) throw new MaterialError(`材料缺少 ${spec.rowKeys.join(" / ")} 任一列表，无法执行检查`);
+	if (!Array.isArray(list)) throw new MaterialError(`${spec.rowKeys[0] ?? "rows"} 必须是列表`);
+	if (list.length === 0) throw new MaterialError(`${spec.rowKeys[0] ?? "rows"} 为空列表，无法执行检查`);
+	const rowNumberColumns = spec.rowNumberColumns ?? [
+		"row",
+		"序号",
+		"行号"
+	];
+	const rows = list.map((entry, index) => {
+		if (!isRecord(entry)) throw new MaterialError(`${spec.rowKeys[0] ?? "rows"}[${index}] 必须是映射`);
+		const fields = {};
+		for (const [key, value] of Object.entries(entry)) {
+			if (value === void 0 || value === null) continue;
+			if (isRecord(value) || Array.isArray(value)) continue;
+			fields[key] = typeof value === "string" ? value.trim() : cellText(value) ?? "";
+		}
+		const row = {
+			row: index + 1,
+			fields
+		};
+		const declared = cellText(entry[rowNumberColumns[0]]) ?? pick(fields, rowNumberColumns);
+		if (declared !== void 0 && /^\d+$/.test(declared)) row.row = Number.parseInt(declared, 10);
+		return row;
+	});
+	const columns = [...new Set(rows.flatMap((row) => Object.keys(row.fields)))];
+	const expected = spec.requireAnyOf ?? [...new Set(Object.values(spec.columns).flat())];
+	const known = new Set(expected.map(normaliseName));
+	if (!columns.some((column) => known.has(normaliseName(column)))) throw new MaterialError(`材料中没有可识别的字段，已识别的列名为：${columns.join(" / ") || "（无）"}；已按以下名称查找：${expected.join(" / ")}`);
+	return {
+		target,
+		header,
+		rows,
+		columns,
+		warnings
+	};
+}
+/**
+* Copy a material's recognized column values onto canonical field keys, and record
+* which canonical fields the material actually carried.
+*
+* Row-level checks read `row.fields[field]`, so a plugin calls this once per row to
+* make the aliases available under their canonical names. The original keys stay in
+* place, which keeps a finding able to name the column it actually read.
+*
+* A field whose cell is blank is still **marked as provided** — with an empty value —
+* because the difference between "this column is missing" and "this column is present
+* but unchecked" is exactly what a presence check has to report. Assigning nothing
+* would make an empty column indistinguishable from an absent one, and the check would
+* silently pass.
+*
+* @param row - the row to extend, in place.
+* @param spec - the same spec the reader was given.
+* @returns the same row, for chaining.
+*/
+function canonicaliseRow(row, spec) {
+	for (const [field, aliases] of Object.entries(spec.columns)) {
+		const existing = row.fields[field];
+		if (existing !== void 0 && existing !== "") continue;
+		const value = pick(row.fields, aliases);
+		if (value !== void 0) {
+			row.fields[field] = value;
+			continue;
+		}
+		const normalised = new Set(Object.keys(row.fields).map(normaliseName));
+		if (aliases.some((alias) => normalised.has(normaliseName(alias)))) row.fields[field] = "";
+	}
+	return row;
+}
+//#endregion
+//#region src/shared/datetime.ts
+const DATE_PATTERN = /^(\d{4})[-/.](\d{1,2})[-/.](\d{1,2})$/;
+const TIME_PATTERN = /^(\d{1,2}):(\d{2})(?::(\d{2}))?$/;
+function pad(value, width = 2) {
+	return String(value).padStart(width, "0");
+}
+/** True when the three components form a real calendar date. */
+function isRealDate(year, month, day) {
+	if (month < 1 || month > 12) return false;
+	if (day < 1 || day > 31) return false;
+	const probe = new Date(Date.UTC(year, month - 1, day));
+	return probe.getUTCFullYear() === year && probe.getUTCMonth() === month - 1 && probe.getUTCDate() === day;
+}
+/**
+* Parse a wall-clock timestamp.
+* @param raw - text such as `2026-03-15 08:30`, `2026-03-15T08:30:00` or `2026/3/5`.
+* @returns the parsed value, or `undefined` when the text is not a date.
+*/
+function parseWallClock(raw) {
+	const text = raw.trim().replace(/[T\s]+/, " ");
+	if (text === "") return void 0;
+	const [datePart, timePart] = text.split(" ", 2);
+	const dateMatch = DATE_PATTERN.exec(datePart ?? "");
+	if (dateMatch === null) return void 0;
+	const year = Number.parseInt(dateMatch[1], 10);
+	const month = Number.parseInt(dateMatch[2], 10);
+	const day = Number.parseInt(dateMatch[3], 10);
+	if (!isRealDate(year, month, day)) return void 0;
+	const date = `${pad(year, 4)}-${pad(month)}-${pad(day)}`;
+	if (timePart === void 0 || timePart === "") return {
+		date,
+		time: "00:00",
+		hasTime: false,
+		minutes: 0
+	};
+	const timeMatch = TIME_PATTERN.exec(timePart);
+	if (timeMatch === null) return void 0;
+	const hour = Number.parseInt(timeMatch[1], 10);
+	const minute = Number.parseInt(timeMatch[2], 10);
+	if (hour > 23 || minute > 59) return void 0;
+	return {
+		date,
+		time: `${pad(hour)}:${pad(minute)}`,
+		hasTime: true,
+		minutes: hour * 60 + minute
+	};
+}
+/** Day number for a `YYYY-MM-DD` string (days since the Unix epoch). */
+function dayNumber(date) {
+	const match = DATE_PATTERN.exec(date);
+	if (match === null) throw new Error(`dayNumber: bad date "${date}"`);
+	const year = Number.parseInt(match[1], 10);
+	const month = Number.parseInt(match[2], 10);
+	const day = Number.parseInt(match[3], 10);
+	return Math.round(Date.UTC(year, month - 1, day) / 864e5);
+}
+/** Whole calendar days from `from` to `to` (negative when `to` is earlier). */
+function diffDays(from, to) {
+	return dayNumber(to) - dayNumber(from);
+}
+/** Minute-precision instant for a parsed wall clock. */
+function instant(wall) {
+	return dayNumber(wall.date) * 1440 + wall.minutes;
+}
+/** Difference in minutes between two parsed wall clocks. */
+function diffMinutes(from, to) {
+	return instant(to) - instant(from);
+}
+//#endregion
+//#region src/shared/report.ts
+/** Locator fields that participate in the stable issue id, in fixed order. */
+const LOCATOR_ID_KEYS = [
+	"file",
+	"page",
+	"para",
+	"line",
+	"row",
+	"cell",
+	"column"
+];
+/** FNV-1a 32-bit hash, rendered as 8 lowercase hex characters. */
+function hashLocator(locator) {
+	let hash = 2166136261;
+	for (const key of LOCATOR_ID_KEYS) {
+		const value = locator[key];
+		if (value === void 0) continue;
+		const chunk = `${key}=${String(value)};`;
+		for (let index = 0; index < chunk.length; index++) {
+			hash ^= chunk.charCodeAt(index);
+			hash = Math.imul(hash, 16777619) >>> 0;
+		}
+	}
+	return hash.toString(16).padStart(8, "0");
+}
+/** Build an issue id that is stable for the same plugin, rule and location. */
+function issueId(plugin, ruleId, locator) {
+	return `${plugin}.${ruleId}.${hashLocator(locator)}`;
+}
+/** Canonical JSON with object keys sorted at every level (stable hashing). */
+function canonicalJson(value) {
+	return JSON.stringify(sortValue(value), null, 2);
+}
+function sortValue(value) {
+	if (Array.isArray(value)) return value.map(sortValue);
+	if (value === null || typeof value !== "object") return value;
+	const source = value;
+	const target = {};
+	for (const key of Object.keys(source).sort()) {
+		if (source[key] === void 0) continue;
+		target[key] = sortValue(source[key]);
+	}
+	return target;
+}
+//#endregion
+//#region src/shared/rules.ts
+/**
+* Compose the one-line `basis` string rendered into reports.
+* @param basis - the rule's normative basis.
+* @param alsoBasis - additional clauses reinforcing the same check.
+* @returns document, number, clause and verbatim excerpt, plus provenance qualifiers.
+*/
+function formatBasis(basis, alsoBasis = []) {
+	const render = (entry) => {
+		const head = entry.number === "" ? entry.document : `${entry.document}（${entry.number}）`;
+		const qualifier = entry.kind === "derived-from-principle" ? "［原则性条款推论，非针对本项的明文要求］" : entry.kind === "institutional-configuration" ? "［阈值为本机构配置，非国家标准］" : "";
+		return `${head} ${entry.clause}：「${entry.excerpt}」${qualifier}`;
+	};
+	const parts = [render(basis), ...alsoBasis.map(render)];
+	return parts.length === 1 ? parts[0] : `${parts[0]}；另见 ${parts.slice(1).join("；另见 ")}`;
+}
+//#endregion
+//#region src/shared/rows.ts
+/**
+* The generic table-check engine.
+*
+* One engine serves every table-shaped plugin in this family. A plugin declares its
+* columns and its rule pack; the rule pack declares, per rule, a `check.kind` and the
+* parameters that kind needs. Adding a check that fits an existing kind is therefore a
+* rule-pack edit rather than a code change, which is what keeps these plugins small
+* enough to review.
+*
+* Three conventions hold everywhere:
+*
+*  1. **A rule that cannot run says so.** Every handler calls `ctx.skip(reason)` when
+*     its configuration or its material is missing, and the reason reaches the report.
+*     Silence is never read as "no problem".
+*  2. **Findings describe cells, not conclusions.** Messages say which column and which
+*     row, and what was expected; they never assert that a document is invalid, a bid
+*     should be rejected or a process is out of control.
+*  3. **A field is looked up in the row first and then in the material's header**,
+*     because a register often states a figure once for the whole set (an FOB value, a
+*     reference document's revision) rather than repeating it on every row.
+*/
+/** Read a string rule parameter. */
+function str(params, key, fallback = "") {
+	const value = params[key];
+	return typeof value === "string" ? value : fallback;
+}
+/**
+* Read a string-list rule parameter.
+*
+* A pack may name the key twice (`stringList(params, 'fields', 'fields')`) as a
+* readability habit; when the second name is the same as the first, or when it
+* resolves to nothing, an empty list is the honest fallback.
+*/
+function stringList(params, key, fallback) {
+	const value = params[key];
+	if (Array.isArray(value)) {
+		const out = value.filter((entry) => typeof entry === "string");
+		if (out.length > 0) return out;
+	}
+	if (Array.isArray(fallback)) return [...fallback];
+	return [];
+}
+/** Read a number from a cell, tolerating the shapes a spreadsheet export produces. */
+function numberOf(raw) {
+	if (raw === void 0) return void 0;
+	const normalised = raw.replace(/[\uff10-\uff19]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 65248)).replace(/[,\s\u3000]/g, "");
+	const match = /-?\d+(?:\.\d+)?/.exec(normalised);
+	if (match === null) return void 0;
+	const value = Number(match[0]);
+	return Number.isFinite(value) ? value : void 0;
+}
+/**
+* Read a field for a row, falling back to the material's header.
+*
+* A register often states a figure once for the whole set — an FOB value, a reference
+* document's revision, a contract total — rather than repeating it on every row.
+* Arithmetic that divides a row value by such a figure must find it, so every field
+* lookup goes through here.
+*/
+function valueOf(input, row, field) {
+	const fromRow = row.fields[field];
+	if (fromRow !== void 0 && fromRow.trim() !== "") return fromRow;
+	const fromHeader = input.header[field];
+	if (fromHeader !== void 0 && fromHeader.trim() !== "") return fromHeader;
+}
+/** True when the cell is present and not blank. */
+function filled(value) {
+	return value !== void 0 && value.trim() !== "";
+}
+/**
+* True when the material gave this row the column at all, even with a blank cell.
+*
+* Presence checks need this distinction: "the column is not in this material" means the
+* check does not apply, while "the column is here and this cell is blank" is precisely
+* the finding to report. The reader marks a blank cell as an empty string, so the test is
+* whether the key exists — not whether `valueOf` returns text, which would fall through
+* to the header and report the wrong thing.
+*/
+function provided(input, row, field) {
+	return row.fields[field] !== void 0 || input.header[field] !== void 0;
+}
+/** Read a numeric parameter without inventing a default. */
+function optionalNumber(params, key) {
+	const value = params[key];
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	return value;
+}
+/** A finding's location: a row when known, plus the field it concerns. */
+function locatorOf(row, field) {
+	const out = {};
+	if (row !== void 0) out.row = row;
+	if (field !== "") out.field = field;
+	return out;
+}
+/**
+* Whether the material carries the named column at all.
+*
+* Presence of the key, not presence of text: the reader marks a blank cell as an empty
+* string, so "the column is not in this material" (the check does not apply) and "the
+* column is here and its cells are blank" (exactly the finding to report) stay distinct.
+* Testing for text here would make an all-blank column look absent and let the check
+* pass silently — the one failure mode this engine family exists to prevent.
+*/
+function columnExists(input, field) {
+	if (input.header[field] !== void 0) return true;
+	return input.rows.some((row) => row.fields[field] !== void 0);
+}
+/** `presence` — the named field must be filled on every row. */
+function presence(ctx) {
+	const field = str(ctx.params, "field");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	const covered = ctx.input.rows.filter((row) => provided(ctx.input, row, field));
+	if (covered.length === 0) {
+		ctx.skip(`材料没有携带「${field}」列的行，本条不适用`);
+		return;
+	}
+	for (const row of covered) {
+		if (filled(valueOf(ctx.input, row, field))) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为空`, `「${field}」应填写`, str(ctx.params, "fix", "补填该栏；本条只核对是否填写，不判断内容是否恰当"));
+	}
+}
+/** `presenceAny` — at least one of the named fields must be filled on every row. */
+function presenceAny(ctx) {
+	const fields = stringList(ctx.params, "fields", "fields");
+	if (fields.length === 0) {
+		ctx.skip("规则库未配置 fields，本条不执行");
+		return;
+	}
+	if (!fields.some((field) => columnExists(ctx.input, field))) {
+		ctx.skip(`材料没有 ${fields.join("、")} 中的任何一列，本条不适用`);
+		return;
+	}
+	const covered = ctx.input.rows.filter((row) => fields.some((field) => provided(ctx.input, row, field)));
+	if (covered.length === 0) {
+		ctx.skip(`材料没有携带 ${fields.join("、")} 任一列的行，本条不适用`);
+		return;
+	}
+	for (const row of covered) {
+		if (fields.some((field) => filled(valueOf(ctx.input, row, field)))) continue;
+		ctx.add(locatorOf(row.row, fields[0]), `第 ${row.row} 行 ${fields.join("、")} 都为空`, `${fields.join("、")} 至少应填写一项`, str(ctx.params, "fix", "至少补填一项；本条只核对是否填写，不判断内容是否恰当"));
+	}
+}
+/** `enum` — the cell must hold one of the configured values. */
+function enumCheck(ctx) {
+	const field = str(ctx.params, "field");
+	const allowed = stringList(ctx.params, "values", "values");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (allowed.length === 0) {
+		ctx.skip(`规则库未配置 values：「${field}」的取值口径由本机构规定，本引擎不硬编码`);
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const value = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (value === "") continue;
+		if (allowed.includes(value)) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」的值为「${value}」`, `「${field}」应为 ${allowed.join(" / ")} 之一`, str(ctx.params, "fix", "核对取值来源；本条只核对是否在册，不判断取值本身是否恰当"));
+	}
+}
+/** `pattern` — the cell must match the configured regular expression. */
+function patternCheck(ctx) {
+	const field = str(ctx.params, "field");
+	const pattern = str(ctx.params, "pattern");
+	if (field === "" || pattern === "") {
+		ctx.skip("规则库未配置 field 或 pattern，本条不执行");
+		return;
+	}
+	let matcher;
+	try {
+		matcher = new RegExp(pattern);
+	} catch (error) {
+		ctx.skip(`规则库配置的 pattern 不是合法正则：${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const value = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (value === "") continue;
+		if (matcher.test(value)) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」的值「${value}」不符合配置的形式`, `「${field}」应匹配 ${pattern}`, str(ctx.params, "fix", "核对填写形式；本条只核对形式，不判断内容是否正确"));
+	}
+}
+/** `date` — the field must parse, and may be bounded by another field or a literal. */
+function dateCheck(ctx) {
+	const field = str(ctx.params, "field");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	const notBeforeField = str(ctx.params, "notBeforeField");
+	const notAfterField = str(ctx.params, "notAfterField");
+	const notBefore = str(ctx.params, "notBefore");
+	const notAfter = str(ctx.params, "notAfter");
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	const today = ctx.options.checkedAt.slice(0, 10);
+	for (const row of ctx.input.rows) {
+		const raw = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (raw === "") continue;
+		const parsed = parseWallClock(raw);
+		if (parsed === void 0) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」的值「${raw}」无法解析为日期`, `「${field}」应为 2026-03-15 或 2026-03-15 09:30 这样的可解析日期`, "核对日期写法；本条不会因为无法解析而跳过该行");
+			continue;
+		}
+		const lowerRaw = notBeforeField !== "" ? valueOf(ctx.input, row, notBeforeField) ?? "" : notBefore === "today" ? today : notBefore;
+		const upperRaw = notAfterField !== "" ? valueOf(ctx.input, row, notAfterField) ?? "" : notAfter === "today" ? today : notAfter;
+		if (lowerRaw !== "") {
+			const lower = parseWallClock(lowerRaw);
+			if (lower === void 0) ctx.add(locatorOf(row.row, field), `第 ${row.row} 行的下限日期「${lowerRaw}」无法解析，无法与「${field}」比较`, "用于比较的日期应可解析", "核对日期写法");
+			else if (parsed.date < lower.date) ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${parsed.date}，早于 ${notBeforeField !== "" ? `「${notBeforeField}」的 ` : ""}${lower.date}`, `「${field}」不应早于 ${lower.date}`, str(ctx.params, "fix", "核对两个日期的填写；本条只比较先后"));
+		}
+		if (upperRaw === "") continue;
+		const upper = parseWallClock(upperRaw);
+		if (upper === void 0) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行的上限日期「${upperRaw}」无法解析，无法与「${field}」比较`, "用于比较的日期应可解析", "核对日期写法");
+			continue;
+		}
+		if (parsed.date <= upper.date) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${parsed.date}，晚于 ${notAfterField !== "" ? `「${notAfterField}」的 ` : ""}${upper.date}`, `「${field}」不应晚于 ${upper.date}`, str(ctx.params, "fix", "核对两个日期的填写；本条只比较先后"));
+	}
+}
+/** `noFutureDate` — a date must not be later than the check date. */
+function noFutureDate(ctx) {
+	const field = str(ctx.params, "field");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	const today = ctx.options.checkedAt.slice(0, 10);
+	for (const row of ctx.input.rows) {
+		const raw = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (raw === "") continue;
+		const parsed = parseWallClock(raw);
+		if (parsed === void 0) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为「${raw}」，无法解析为日期`, `「${field}」应为 ${today} 之前的可解析日期`, "核对日期写法；本条识别 2026-03-15 与 2026-03-15 09:30 两种形式");
+			continue;
+		}
+		if (parsed.date <= today) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${parsed.date}，晚于核对日 ${today}`, `「${field}」应不晚于核对日`, "核对日期是否填错；本条只核对先后，不判断数据是否可靠");
+	}
+}
+/** `dataAge` — a dated cell must be recent enough under a configured window. */
+function dataAge(ctx) {
+	const field = str(ctx.params, "field");
+	const maxDays = optionalNumber(ctx.params, "maxDays");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (maxDays === void 0 || maxDays <= 0) {
+		ctx.skip(`规则库未配置 maxDays：「${field}」的数据新鲜度要求由本机构编辑口径规定，本引擎不硬编码`);
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	const today = ctx.options.checkedAt.slice(0, 10);
+	for (const row of ctx.input.rows) {
+		const raw = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (raw === "") continue;
+		const parsed = parseWallClock(raw);
+		if (parsed === void 0) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为「${raw}」，无法解析为日期`, `「${field}」应为可解析日期，且距核对日不超过 ${maxDays} 天`, "核对日期写法");
+			continue;
+		}
+		const age = diffDays(parsed.date, today);
+		if (age <= maxDays) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${parsed.date}，距核对日 ${age} 天，超过配置的 ${maxDays} 天`, `「${field}」的数据不应早于核对日前 ${maxDays} 天`, str(ctx.params, "fix", "更新数据或说明引用旧数据的原因；本条的天数来自本机构配置，不是标准数值"));
+	}
+}
+/** `number` — the cell must parse as a number, optionally positive or bounded. */
+function numberCheck(ctx) {
+	const field = str(ctx.params, "field");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	const min = optionalNumber(ctx.params, "min");
+	const max = optionalNumber(ctx.params, "max");
+	const positive = ctx.params.positive === true;
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const raw = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (raw === "") continue;
+		const value = numberOf(raw);
+		if (value === void 0) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」的值「${raw}」无法解析为数字`, `「${field}」应填写数字`, str(ctx.params, "fix", "核对填写形式；本条只核对可解析性，不判断数值是否合理"));
+			continue;
+		}
+		if (positive && value <= 0) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${value}，不是正数`, `「${field}」应为大于零的数值`, str(ctx.params, "fix", "核对取值；本条只核对是否为正数"));
+			continue;
+		}
+		if (min !== void 0 && value < min) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${value}，小于配置下限 ${min}`, `「${field}」应不小于 ${min}`, str(ctx.params, "fix", "核对取值；本条的上下限来自本机构配置"));
+			continue;
+		}
+		if (max === void 0 || value <= max) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${value}，大于配置上限 ${max}`, `「${field}」应不大于 ${max}`, str(ctx.params, "fix", "核对取值；本条的上下限来自本机构配置"));
+	}
+}
+/** `unique` — no two rows may share the same value, ignoring whitespace. */
+function uniqueCheck(ctx) {
+	const field = str(ctx.params, "field");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	const seen = /* @__PURE__ */ new Map();
+	let considered = 0;
+	for (const row of ctx.input.rows) {
+		const value = (valueOf(ctx.input, row, field) ?? "").replace(/[\s\u3000]/g, "");
+		if (value === "") continue;
+		considered += 1;
+		const first = seen.get(value);
+		if (first === void 0) {
+			seen.set(value, row);
+			continue;
+		}
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」的值「${valueOf(ctx.input, row, field)}」与第 ${first.row} 行重复`, `「${field}」在材料内应唯一`, str(ctx.params, "fix", "核对是否重复登记或抄错；本条只核对唯一性"));
+	}
+	if (considered === 0) ctx.skip(`材料没有「${field}」列，本条不适用`);
+}
+/** `sequence` — numbers in the field should be continuous over their own range. */
+function sequenceCheck(ctx) {
+	const field = str(ctx.params, "field");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	const numbers = ctx.input.rows.map((row) => ({
+		row,
+		value: numberOf(valueOf(ctx.input, row, field))
+	})).filter((entry) => entry.value !== void 0);
+	if (numbers.length < 2) {
+		ctx.skip(`材料中「${field}」可解析为数字的行不足两行，无法核对连续性`);
+		return;
+	}
+	const values = numbers.map((entry) => Math.round(entry.value));
+	const min = Math.min(...values);
+	const max = Math.max(...values);
+	if (max - min + 1 > 5e3) {
+		ctx.skip(`「${field}」的取值跨度过大（${min}~${max}），本条不执行`);
+		return;
+	}
+	const present = new Set(values);
+	const missing = [];
+	for (let value = min; value <= max; value += 1) if (!present.has(value)) missing.push(value);
+	if (missing.length === 0) return;
+	ctx.add(locatorOf(numbers[0]?.row.row, field), `${field} 范围 ${min}~${max} 中缺 ${missing.length} 个号：${missing.slice(0, 20).join("、")}${missing.length > 20 ? " 等" : ""}`, `「${field}」应在同一范围内连续`, "核对是否漏登记；缺号本身不构成问题，需人工确认");
+}
+/** `sum` — a column of numbers must total a header field. */
+function sumCheck(ctx) {
+	const field = str(ctx.params, "field");
+	const headerField = str(ctx.params, "headerField");
+	if (field === "" || headerField === "") {
+		ctx.skip("规则库未配置 field 或 headerField，本条不执行");
+		return;
+	}
+	const parsed = ctx.input.rows.map((row) => numberOf(valueOf(ctx.input, row, field))).filter((value) => value !== void 0);
+	if (parsed.length === 0) {
+		ctx.skip(`材料没有可解析为数字的「${field}」值，无法核对合计`);
+		return;
+	}
+	const declared = numberOf(ctx.input.header[headerField]);
+	if (declared === void 0) {
+		ctx.skip(`材料未提供可解析的「${headerField}」，无法与「${field}」的合计核对`);
+		return;
+	}
+	const total = parsed.reduce((sum, value) => sum + value, 0);
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	const gap = Math.abs(total - declared);
+	if (gap <= tolerance) return;
+	ctx.add(locatorOf(void 0, field), `${parsed.length} 行的「${field}」合计 ${Number(total.toFixed(4))}，与「${headerField}」${declared} 相差 ${Number(gap.toFixed(4))}`, `「${field}」的合计应与「${headerField}」一致，允许偏差 ${tolerance}`, "核对是否有行遗漏、重复计入或口径不一致；本条只做加法核对");
+}
+/** `sumToConstant` — a column of numbers must total a configured constant. */
+function sumToConstant(ctx) {
+	const field = str(ctx.params, "field");
+	const target = optionalNumber(ctx.params, "target");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (target === void 0 || target <= 0) {
+		ctx.skip(`规则库未配置 target：「${field}」的合计目标由招标文件或本机构口径规定，本引擎不硬编码`);
+		return;
+	}
+	const parsed = ctx.input.rows.map((row) => numberOf(valueOf(ctx.input, row, field))).filter((value) => value !== void 0);
+	if (parsed.length === 0) {
+		ctx.skip(`材料没有可解析为数字的「${field}」值，无法核对合计`);
+		return;
+	}
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	const total = parsed.reduce((sum, value) => sum + value, 0);
+	const gap = Math.abs(total - target);
+	if (gap <= tolerance) return;
+	ctx.add(locatorOf(void 0, field), `${parsed.length} 行的「${field}」合计 ${Number(total.toFixed(4))}，与配置的目标值 ${target} 相差 ${Number(gap.toFixed(4))}`, `「${field}」的合计应为 ${target}，允许偏差 ${tolerance}`, str(ctx.params, "fix", "核对是否有行遗漏或数值抄错；本条只做加法核对，不判断设置是否合规"));
+}
+/** `countPerGroup` — each group value must appear at least N times. */
+function countPerGroup(ctx) {
+	const field = str(ctx.params, "field");
+	const minRows = optionalNumber(ctx.params, "minRows") ?? 1;
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of ctx.input.rows) {
+		const value = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (value === "") continue;
+		const bucket = groups.get(value);
+		if (bucket === void 0) groups.set(value, [row]);
+		else bucket.push(row);
+	}
+	if (groups.size === 0) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const [value, rows] of groups) {
+		if (rows.length >= minRows) continue;
+		ctx.add(locatorOf(rows[0]?.row, field), `「${field}」为「${value}」的只有 ${rows.length} 行，少于配置的 ${minRows} 行`, `每个「${field}」应至少出现 ${minRows} 行`, str(ctx.params, "fix", "核对是否漏登记；本条只核对行数，不判断内容是否完整"));
+	}
+}
+/** `textContains` — the cell should contain all the configured terms. */
+function textContains(ctx) {
+	const field = str(ctx.params, "field");
+	const terms = stringList(ctx.params, "terms", "terms");
+	if (field === "" || terms.length === 0) {
+		ctx.skip("规则库未配置 field 或 terms，本条不执行");
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const text = valueOf(ctx.input, row, field) ?? "";
+		if (text === "") continue;
+		const missing = terms.filter((term) => !text.includes(term));
+		if (missing.length === 0) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」中未见 ${missing.join("、")}`, `「${field}」应包含 ${terms.join("、")}`, str(ctx.params, "fix", "核对是否遗漏；本条只核对字面是否出现，不判断表述是否恰当"));
+	}
+}
+/** `containsAny` — the cell must not contain any of the configured terms. */
+function containsAny(ctx) {
+	const field = str(ctx.params, "field");
+	const terms = stringList(ctx.params, "terms", "terms");
+	if (field === "" || terms.length === 0) {
+		ctx.skip("规则库未配置 field 或 terms，本条不执行");
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const text = valueOf(ctx.input, row, field) ?? "";
+		if (text === "") continue;
+		const hit = terms.find((term) => text.includes(term));
+		if (hit === void 0) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」中残留占位符「${hit}」`, `「${field}」应填写实际内容，不含未替换的占位符`, str(ctx.params, "fix", "核对是否直接照抄了模板"));
+	}
+}
+/** `length` — the cell's length must sit inside a configured range. */
+function lengthCheck(ctx) {
+	const field = str(ctx.params, "field");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	const max = optionalNumber(ctx.params, "maxLength");
+	const min = optionalNumber(ctx.params, "minLength");
+	if (max === void 0 && min === void 0) {
+		ctx.skip(`规则库未配置 maxLength 或 minLength：「${field}」的长度限制属本机构口径，本条不执行`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const value = valueOf(ctx.input, row, field) ?? "";
+		if (value === "") continue;
+		const count = [...value].length;
+		if (max !== void 0 && count > max) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」共 ${count} 字，超过配置上限 ${max} 字`, `「${field}」应不超过 ${max} 字`, str(ctx.params, "fix", "核对长度限制来源；本条的上下限来自本机构配置"));
+			continue;
+		}
+		if (min === void 0 || count >= min) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」共 ${count} 字，少于配置下限 ${min} 字`, `「${field}」应不少于 ${min} 字`, str(ctx.params, "fix", "核对是否漏填；本条的上下限来自本机构配置"));
+	}
+}
+/** `minLength` — the cell must hold at least N characters. */
+function minLength(ctx) {
+	const field = str(ctx.params, "field");
+	const min = optionalNumber(ctx.params, "minLength");
+	if (field === "" || min === void 0 || min <= 0) {
+		ctx.skip("规则库未配置 field 或 minLength，本条不执行");
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const value = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (value === "") continue;
+		const count = [...value].length;
+		if (count >= min) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」只有 ${count} 字，短于配置下限 ${min} 字`, `「${field}」应至少有 ${min} 字`, str(ctx.params, "fix", "核对是否真的是摘录；本条只核对长度，不判断内容是否忠实于原文"));
+	}
+}
+/** `headerPresence` — the material's header must carry the named fields. */
+function headerPresence(ctx) {
+	const fields = stringList(ctx.params, "fields", "fields");
+	if (fields.length === 0) {
+		ctx.skip("规则库未配置 fields，本条不执行");
+		return;
+	}
+	const missing = fields.filter((field) => !filled(ctx.input.header[field]));
+	if (missing.length === 0) return;
+	ctx.add(locatorOf(void 0, missing[0]), `材料表头缺少 ${missing.join("、")}`, `表头应提供 ${fields.join("、")}`, str(ctx.params, "fix", "补齐表头字段；本条只核对表头是否声明，不判断内容是否恰当"));
+}
+/** `headerEnum` — a header value must come from the configured vocabulary. */
+function headerEnum(ctx) {
+	const field = str(ctx.params, "field");
+	const values = stringList(ctx.params, "values", "values");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	const actual = (ctx.input.header[field] ?? "").trim();
+	if (actual === "") {
+		ctx.skip(`材料表头未提供「${field}」，本条不适用`);
+		return;
+	}
+	if (values.length === 0) {
+		ctx.skip(`规则库未配置 values：「${field}」的取值口径由顾客或本机构规定，本引擎不硬编码`);
+		return;
+	}
+	if (values.includes(actual)) return;
+	ctx.add(locatorOf(void 0, field), `材料表头「${field}」的值为「${actual}」`, `「${field}」应为 ${values.join(" / ")} 之一`, "核对取值来源；本条只核对是否在册，不判断该取值本身是否恰当");
+}
+/**
+* `conditionalPresence` — when the condition field is met, the listed fields must be
+* filled. The condition can be "not blank" (the default), "one of these values", or
+* "matches this pattern".
+*/
+function conditionalPresence(ctx) {
+	const conditionField = str(ctx.params, "conditionField");
+	const required = stringList(ctx.params, "requiredFields", "requiredFields");
+	if (conditionField === "" || required.length === 0) {
+		ctx.skip("规则库未配置 conditionField 或 requiredFields，本条不执行");
+		return;
+	}
+	const values = stringList(ctx.params, "conditionValues", "conditionValues");
+	const pattern = str(ctx.params, "conditionPattern");
+	let matcher;
+	if (pattern !== "") try {
+		matcher = new RegExp(pattern);
+	} catch (error) {
+		ctx.skip(`规则库配置的 conditionPattern 不是合法正则：${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+	const triggered = ctx.input.rows.filter((row) => {
+		const value = (valueOf(ctx.input, row, conditionField) ?? "").trim();
+		if (value === "") return false;
+		if (values.length > 0) return values.some((candidate) => candidate === value);
+		if (matcher !== void 0) return matcher.test(value);
+		return true;
+	});
+	if (triggered.length === 0) {
+		ctx.skip(`材料中没有满足「${conditionField}」条件的行，本条不适用`);
+		return;
+	}
+	for (const row of triggered) {
+		const missing = required.filter((field) => !filled(valueOf(ctx.input, row, field)));
+		if (missing.length === 0) continue;
+		ctx.add(locatorOf(row.row, conditionField), `第 ${row.row} 行「${conditionField}」为「${valueOf(ctx.input, row, conditionField)}」，但缺 ${missing.join("、")}`, `满足该条件的行应同时填写 ${required.join("、")}`, str(ctx.params, "fix", "补齐；本条只核对字段是否存在，不判断内容是否恰当"));
+	}
+}
+/** `highRiskEvidence` — a row whose requirement matches a keyword must carry evidence. */
+function highRiskEvidence(ctx) {
+	const keywords = stringList(ctx.params, "highRiskKeywords", "highRiskKeywords");
+	if (keywords.length === 0) {
+		ctx.skip("规则库未配置 highRiskKeywords：哪些条款属于高风险取决于招标文件本身，本引擎不硬编码");
+		return;
+	}
+	const evidenceField = str(ctx.params, "evidenceField", "evidence");
+	const requirementField = str(ctx.params, "requirementField", "requirement");
+	const matching = ctx.input.rows.filter((row) => {
+		const text = valueOf(ctx.input, row, requirementField) ?? "";
+		return text !== "" && keywords.some((keyword) => text.includes(keyword));
+	});
+	if (matching.length === 0) {
+		ctx.skip(`材料中没有命中高风险关键词（${keywords.join("、")}）的条款，本条不适用`);
+		return;
+	}
+	for (const row of matching) {
+		if (filled(valueOf(ctx.input, row, evidenceField))) continue;
+		const text = valueOf(ctx.input, row, requirementField) ?? "";
+		const hit = keywords.find((keyword) => text.includes(keyword));
+		ctx.add(locatorOf(row.row, evidenceField), `第 ${row.row} 行的要求命中高风险关键词「${hit}」，但未填写证明材料`, `命中 ${keywords.join(" / ")} 的条款应填写证明材料`, "补填证明材料或页码；本条只核对是否填写，不判断证明材料是否有效");
+	}
+}
+/** `thresholdPresence` — a row crossing the threshold must carry the named field. */
+function thresholdPresence(ctx) {
+	const triggerField = str(ctx.params, "triggerField");
+	const requiredField = str(ctx.params, "requiredField");
+	const threshold = optionalNumber(ctx.params, "threshold");
+	if (triggerField === "" || requiredField === "") {
+		ctx.skip("规则库未配置 triggerField 或 requiredField，本条不执行");
+		return;
+	}
+	if (threshold === void 0 || threshold <= 0) {
+		ctx.skip("规则库未配置 threshold：「多高算高风险、多高必须提措施」取决于本机构风险准则，本引擎不硬编码");
+		return;
+	}
+	const triggered = ctx.input.rows.filter((row) => {
+		const value = numberOf(valueOf(ctx.input, row, triggerField));
+		return value !== void 0 && value >= threshold;
+	});
+	if (triggered.length === 0) {
+		ctx.skip(`材料中没有「${triggerField}」达到 ${threshold} 的行，本条不适用`);
+		return;
+	}
+	for (const row of triggered) {
+		if (filled(valueOf(ctx.input, row, requiredField))) continue;
+		ctx.add(locatorOf(row.row, requiredField), `第 ${row.row} 行「${triggerField}」为 ${valueOf(ctx.input, row, triggerField)}，达到配置阈值 ${threshold}，但未填写「${requiredField}」`, `「${triggerField}」达到 ${threshold} 的行应填写「${requiredField}」`, "补填；本条的阈值来自本机构配置，不是标准数值");
+	}
+}
+/** `thresholdBelow` — a value must not fall below the configured criterion. */
+function thresholdBelow(ctx) {
+	const field = str(ctx.params, "field");
+	const threshold = optionalNumber(ctx.params, "threshold");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (threshold === void 0 || threshold <= 0) {
+		ctx.skip("规则库未配置 threshold：接收准则因行业、顾客与特性重要度而异，本引擎不硬编码任何准则");
+		return;
+	}
+	if (!columnExists(ctx.input, field)) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of ctx.input.rows) {
+		const value = numberOf(valueOf(ctx.input, row, field));
+		if (value === void 0) continue;
+		if (value >= threshold) continue;
+		ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为 ${value}，低于本机构配置的准则 ${threshold}`, `「${field}」应不低于 ${threshold}`, str(ctx.params, "fix", "核对取值；本条的准则来自本机构或顾客配置，不是标准数值"));
+	}
+}
+/** `fieldComparison` — two fields must satisfy a stated relation. */
+function fieldComparison(ctx) {
+	const leftField = str(ctx.params, "leftField");
+	const rightField = str(ctx.params, "rightField");
+	const relation = str(ctx.params, "relation", "gte");
+	if (leftField === "" || rightField === "") {
+		ctx.skip("规则库未配置 leftField 或 rightField，本条不执行");
+		return;
+	}
+	const label = {
+		gte: "不小于",
+		gt: "大于",
+		lte: "不大于",
+		lt: "小于",
+		eq: "等于"
+	};
+	const comparable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, leftField)) && filled(valueOf(ctx.input, row, rightField)));
+	if (comparable.length === 0) {
+		ctx.skip(`材料没有同时填写「${leftField}」与「${rightField}」的行，本条不适用`);
+		return;
+	}
+	for (const row of comparable) {
+		const leftRaw = valueOf(ctx.input, row, leftField) ?? "";
+		const rightRaw = valueOf(ctx.input, row, rightField) ?? "";
+		const left = numberOf(leftRaw);
+		const right = numberOf(rightRaw);
+		const leftDate = left === void 0 ? parseWallClock(leftRaw) : void 0;
+		const rightDate = right === void 0 ? parseWallClock(rightRaw) : void 0;
+		let ok;
+		if (left !== void 0 && right !== void 0) ok = relation === "gte" ? left >= right : relation === "gt" ? left > right : relation === "lte" ? left <= right : relation === "lt" ? left < right : relation === "eq" ? left === right : void 0;
+		else if (leftDate !== void 0 && rightDate !== void 0) ok = relation === "gte" ? leftDate.date >= rightDate.date : relation === "gt" ? leftDate.date > rightDate.date : relation === "lte" ? leftDate.date <= rightDate.date : relation === "lt" ? leftDate.date < rightDate.date : relation === "eq" ? leftDate.date === rightDate.date : void 0;
+		if (ok === void 0) {
+			ctx.add(locatorOf(row.row, leftField), `第 ${row.row} 行「${leftField}」${leftRaw} 与「${rightField}」${rightRaw} 无法作为可比数值或日期比较`, `「${leftField}」应${label[relation] ?? relation}「${rightField}」`, "核对两栏的填写形式；本条只做比较，不判断数值是否真实");
+			continue;
+		}
+		if (ok) continue;
+		ctx.add(locatorOf(row.row, leftField), `第 ${row.row} 行「${leftField}」为 ${leftRaw}，「${rightField}」为 ${rightRaw}，不满足${label[relation] ?? relation}关系`, `「${leftField}」应${label[relation] ?? relation}「${rightField}」`, str(ctx.params, "fix", "核对两栏是否填反或抄错；本条只做比较，不判断数值是否真实"));
+	}
+}
+/** `intervalOrder` — three values must be ordered low ≤ middle ≤ high. */
+function intervalOrder(ctx) {
+	const lowerField = str(ctx.params, "lowerField");
+	const middleField = str(ctx.params, "middleField");
+	const upperField = str(ctx.params, "upperField");
+	if (lowerField === "" || middleField === "" || upperField === "") {
+		ctx.skip("规则库未配置 lowerField、middleField 或 upperField，本条不执行");
+		return;
+	}
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, lowerField)) && filled(valueOf(ctx.input, row, middleField)) && filled(valueOf(ctx.input, row, upperField)));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${lowerField}」「${middleField}」「${upperField}」的行，本条不适用`);
+		return;
+	}
+	for (const row of usable) {
+		const lower = numberOf(valueOf(ctx.input, row, lowerField));
+		const middle = numberOf(valueOf(ctx.input, row, middleField));
+		const upper = numberOf(valueOf(ctx.input, row, upperField));
+		if (lower === void 0 || middle === void 0 || upper === void 0) {
+			ctx.add(locatorOf(row.row, middleField), `第 ${row.row} 行的「${lowerField}」「${middleField}」「${upperField}」中有无法解析为数值的值`, `三个值应可比较，且满足 ${lowerField} ≤ ${middleField} ≤ ${upperField}`, "核对填写形式");
+			continue;
+		}
+		if (lower <= middle && middle <= upper) continue;
+		ctx.add(locatorOf(row.row, middleField), `第 ${row.row} 行「${middleField}」为 ${middle}，而「${lowerField}」为 ${lower}、「${upperField}」为 ${upper}`, `应满足 ${lowerField} ≤ ${middleField} ≤ ${upperField}`, "核对三个数值的填写；本条只核对次序，不判断数值是否正确");
+	}
+}
+/** `productOf` — the result must equal the product of the named factors. */
+function productOf(ctx) {
+	const resultField = str(ctx.params, "resultField");
+	const factors = stringList(ctx.params, "factorFields", "factorFields");
+	if (resultField === "" || factors.length === 0) {
+		ctx.skip("规则库未配置 resultField 或 factorFields，本条不执行");
+		return;
+	}
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, resultField)) && factors.every((factor) => filled(valueOf(ctx.input, row, factor))));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${resultField}」与 ${factors.join("、")} 的行，无法核对乘积`);
+		return;
+	}
+	const round = (value) => Number(value.toFixed(6));
+	for (const row of usable) {
+		const declared = numberOf(valueOf(ctx.input, row, resultField));
+		const values = factors.map((factor) => numberOf(valueOf(ctx.input, row, factor)));
+		if (declared === void 0 || values.some((value) => value === void 0)) {
+			ctx.add(locatorOf(row.row, resultField), `第 ${row.row} 行的「${resultField}」或 ${factors.join("、")} 中有无法解析为数值的值`, `「${resultField}」应等于 ${factors.join(" × ")}`, "核对填写形式；本条只做算术核对，不判断各因子是否正确");
+			continue;
+		}
+		const numbers = values;
+		const product = numbers.reduce((total, value) => total * value, 1);
+		if (Math.abs(product - declared) <= tolerance) continue;
+		ctx.add(locatorOf(row.row, resultField), `第 ${row.row} 行「${resultField}」填报 ${declared}，而 ${numbers.join(" × ")} = ${round(product)}`, `「${resultField}」应等于 ${factors.join(" × ")}`, "核对是否抄错或漏改；本条只做算术核对，不判断各因子是否正确");
+	}
+}
+/** `formula` — the result must equal an arithmetic expression over other fields. */
+function formula(ctx) {
+	const resultField = str(ctx.params, "resultField");
+	const expression = ctx.params.expression;
+	if (resultField === "" || typeof expression !== "object" || expression === null || Array.isArray(expression)) {
+		ctx.skip("规则库未配置 resultField 或 expression，本条不执行");
+		return;
+	}
+	const spec = expression;
+	const op = typeof spec.op === "string" ? spec.op : "";
+	const fields = Array.isArray(spec.fields) ? spec.fields.filter((entry) => typeof entry === "string") : [];
+	const scale = typeof spec.scale === "number" && Number.isFinite(spec.scale) ? spec.scale : 1;
+	/**
+	* Per-term signs for `sum`.
+	*
+	* A composed total is naturally written as some terms added and others subtracted —
+	* `配件费 + 工时费 − 折扣`. Expressing that as signs keeps it a single addition, so the
+	* message reads like the arithmetic a person would write down, and a negative overall
+	* scale is never needed (which would invert every term, not just the last).
+	*/
+	const signs = Array.isArray(spec.signs) ? spec.signs.map((entry) => entry === -1 || entry === "-1" || entry === "-" ? -1 : 1) : [];
+	if (fields.length === 0 || ![
+		"divide",
+		"product",
+		"sum",
+		"subtract",
+		"percent"
+	].includes(op)) {
+		ctx.skip("规则库配置的 expression 不完整：op 应为 divide/product/sum/subtract/percent，且需给出 fields");
+		return;
+	}
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, resultField)) && fields.every((field) => filled(valueOf(ctx.input, row, field))));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${resultField}」与 ${fields.join("、")} 的行，无法核对表达式`);
+		return;
+	}
+	const headerUsable = fields.every((field) => filled(ctx.input.header[field]));
+	if (usable.length === 0 && !headerUsable) {
+		ctx.skip(`材料没有同时填写「${resultField}」与 ${fields.join("、")} 的行，无法核对表达式`);
+		return;
+	}
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	const label = {
+		divide: fields.join(" ÷ "),
+		product: fields.join(" × "),
+		sum: fields.map((field, index) => `${signs[index] === -1 ? "−" : index === 0 ? "" : "+"}${field}`).join(" "),
+		subtract: `${fields[0]} − ${fields.slice(1).join(" − ")}`,
+		percent: `${fields.join(" ÷ ")} × 100`
+	};
+	const round = (value) => Number(value.toFixed(6));
+	for (const row of usable) {
+		const declared = numberOf(valueOf(ctx.input, row, resultField));
+		const values = fields.map((field) => numberOf(valueOf(ctx.input, row, field)));
+		if (declared === void 0 || values.some((value) => value === void 0)) {
+			ctx.add(locatorOf(row.row, resultField), `第 ${row.row} 行的「${resultField}」或 ${fields.join("、")} 中有无法解析为数值的值`, `「${resultField}」应等于 ${label[op] ?? op}`, "核对填写形式；本条只做算术核对");
+			continue;
+		}
+		const numbers = values;
+		const first = numbers[0];
+		const rest = numbers.slice(1);
+		let expected;
+		switch (op) {
+			case "divide":
+				expected = rest.reduce((total, value) => total / value, first);
+				break;
+			case "product":
+				expected = numbers.reduce((total, value) => total * value, 1);
+				break;
+			case "sum":
+				expected = numbers.reduce((total, value, index) => total + (signs[index] ?? 1) * value, 0);
+				break;
+			case "subtract":
+				expected = rest.reduce((total, value) => total - value, first);
+				break;
+			default: expected = first / (rest[0] ?? 1) * 100;
+		}
+		expected *= scale;
+		if (Math.abs(declared - expected) <= tolerance) continue;
+		ctx.add(locatorOf(row.row, resultField), `第 ${row.row} 行「${resultField}」填报 ${declared}，按 ${label[op] ?? op} 应为 ${round(expected)}`, `「${resultField}」应等于 ${label[op] ?? op}`, str(ctx.params, "fix", "核对取数与计算口径；本条只做算术核对，不判断取数本身是否恰当"));
+	}
+	if (usable.length > 0 || !headerUsable) return;
+	const headerDeclared = numberOf(valueOf(ctx.input, {}, resultField)) ?? numberOf(ctx.input.header[resultField]);
+	const headerValues = fields.map((field) => numberOf(ctx.input.header[field]));
+	if (headerDeclared === void 0 || headerValues.some((value) => value === void 0)) {
+		ctx.skip(`材料表头的「${resultField}」或 ${fields.join("、")} 无法解析为数值，无法核对表达式`);
+		return;
+	}
+	const numbers = headerValues;
+	const first = numbers[0];
+	const rest = numbers.slice(1);
+	let expectedHeader;
+	switch (op) {
+		case "divide":
+			expectedHeader = rest.reduce((total, value) => total / value, first);
+			break;
+		case "product":
+			expectedHeader = numbers.reduce((total, value) => total * value, 1);
+			break;
+		case "sum":
+			expectedHeader = numbers.reduce((total, value, index) => total + (signs[index] ?? 1) * value, 0);
+			break;
+		case "subtract":
+			expectedHeader = rest.reduce((total, value) => total - value, first);
+			break;
+		default: expectedHeader = first / (rest[0] ?? 1) * 100;
+	}
+	expectedHeader *= scale;
+	if (Math.abs(headerDeclared - expectedHeader) <= tolerance) return;
+	ctx.add(locatorOf(void 0, resultField), `材料表头「${resultField}」为 ${headerDeclared}，按 ${label[op] ?? op} 应为 ${round(expectedHeader)}`, `表头「${resultField}」应等于 ${label[op] ?? op}`, str(ctx.params, "fix", "核对取数与计算口径；本条只做算术核对，不判断取数本身是否恰当"));
+}
+/** `capabilityIndex` — Cp and Cpk must follow from the limits, the mean and sigma. */
+function capabilityIndex(ctx) {
+	const cpField = str(ctx.params, "cpField");
+	const cpkField = str(ctx.params, "cpkField");
+	const uslField = str(ctx.params, "uslField");
+	const lslField = str(ctx.params, "lslField");
+	const stdDevField = str(ctx.params, "stdDevField");
+	const meanField = str(ctx.params, "meanField");
+	if ([
+		cpField,
+		cpkField,
+		uslField,
+		lslField,
+		stdDevField,
+		meanField
+	].some((field) => field === "")) {
+		ctx.skip("规则库未配置 Cp/Cpk 定义式所需的字段名，本条不执行");
+		return;
+	}
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	const usable = ctx.input.rows.filter((row) => (filled(valueOf(ctx.input, row, cpField)) || filled(valueOf(ctx.input, row, cpkField))) && filled(valueOf(ctx.input, row, uslField)) && filled(valueOf(ctx.input, row, lslField)) && filled(valueOf(ctx.input, row, stdDevField)) && filled(valueOf(ctx.input, row, meanField)));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${uslField}」「${lslField}」「${stdDevField}」「${meanField}」与能力指数的行，无法核对定义式`);
+		return;
+	}
+	const round = (value) => Number(value.toFixed(4));
+	for (const row of usable) {
+		const usl = numberOf(valueOf(ctx.input, row, uslField));
+		const lsl = numberOf(valueOf(ctx.input, row, lslField));
+		const sigma = numberOf(valueOf(ctx.input, row, stdDevField));
+		const mean = numberOf(valueOf(ctx.input, row, meanField));
+		if (usl === void 0 || lsl === void 0 || sigma === void 0 || mean === void 0 || sigma <= 0) {
+			ctx.add(locatorOf(row.row, cpkField), `第 ${row.row} 行的规格限、标准差或均值无法用于计算（标准差须大于零）`, `Cp 与 Cpk 应由规格限、均值与标准差按定义式算出`, "核对填写形式与标准差取值");
+			continue;
+		}
+		const expectedCp = (usl - lsl) / (6 * sigma);
+		const expectedCpk = Math.min(usl - mean, mean - lsl) / (3 * sigma);
+		const actualCp = numberOf(valueOf(ctx.input, row, cpField));
+		const actualCpk = numberOf(valueOf(ctx.input, row, cpkField));
+		if (actualCp !== void 0 && Math.abs(actualCp - expectedCp) > tolerance) {
+			ctx.add(locatorOf(row.row, cpField), `第 ${row.row} 行 Cp 填报 ${actualCp}，按 (${usl} − ${lsl}) / (6 × ${sigma}) 应为 ${round(expectedCp)}`, "Cp = (USL − LSL) / 6σ", "核对标准差口径：Cp/Cpk 用组内标准差，Pp/Ppk 用总体标准差；本条只做算术核对");
+			continue;
+		}
+		if (actualCpk === void 0 || Math.abs(actualCpk - expectedCpk) <= tolerance) continue;
+		ctx.add(locatorOf(row.row, cpkField), `第 ${row.row} 行 Cpk 填报 ${actualCpk}，按 min(USL − X̄, X̄ − LSL) / 3σ 应为 ${round(expectedCpk)}`, "Cpk = min(USL − X̄, X̄ − LSL) / 3σ", "核对标准差口径与均值；本条只做算术核对，不判断能力是否足够");
+	}
+}
+/**
+* `controlLimits` — the limits must follow from the centre line, the dispersion
+* statistic and the chart constants declared in the rule pack.
+*/
+function controlLimits(ctx) {
+	const centerField = str(ctx.params, "centerField");
+	const rangeField = str(ctx.params, "rangeField");
+	const uclField = str(ctx.params, "uclField");
+	const lclField = str(ctx.params, "lclField");
+	const sizeField = str(ctx.params, "sizeField");
+	const rawTable = ctx.params.coefficients;
+	if (uclField === "" || lclField === "" || centerField === "" && rangeField === "") {
+		ctx.skip("规则库未配置 centerField/rangeField 或控制限字段，本条不执行");
+		return;
+	}
+	if (typeof rawTable !== "object" || rawTable === null || Array.isArray(rawTable)) {
+		ctx.skip("规则库未配置 coefficients 常数表：控制图系数随图种变化，本引擎不硬编码");
+		return;
+	}
+	const table = rawTable;
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, uclField)) && filled(valueOf(ctx.input, row, lclField)));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有「${uclField}」与「${lclField}」，无法核对控制限`);
+		return;
+	}
+	let checked = 0;
+	for (const row of usable) {
+		const key = sizeField === "" ? "" : (valueOf(ctx.input, row, sizeField) ?? "").trim();
+		const entry = table[key];
+		const coefficients = typeof entry === "object" && entry !== null && !Array.isArray(entry) ? entry : void 0;
+		if (coefficients === void 0) {
+			ctx.add(locatorOf(row.row, uclField), `第 ${row.row} 行的子组大小「${key === "" ? "（未填）" : key}」在常数表中没有对应档位`, "子组大小应为常数表覆盖的档位之一", "补齐子组大小，或把该档位的系数加进规则的 coefficients；本条只核对档位是否在册");
+			continue;
+		}
+		const center = centerField === "" ? void 0 : numberOf(valueOf(ctx.input, row, centerField));
+		const dispersion = rangeField === "" ? void 0 : numberOf(valueOf(ctx.input, row, rangeField));
+		if (center === void 0 || dispersion === void 0) continue;
+		checked += 1;
+		const a2 = typeof coefficients.a2 === "number" ? coefficients.a2 : void 0;
+		const d3 = typeof coefficients.d3 === "number" ? coefficients.d3 : 0;
+		const d4 = typeof coefficients.d4 === "number" ? coefficients.d4 : 0;
+		const expectedUcl = a2 !== void 0 ? center + a2 * dispersion : d4 * dispersion;
+		const expectedLcl = a2 !== void 0 ? center - a2 * dispersion : d3 * dispersion;
+		const actualUcl = numberOf(valueOf(ctx.input, row, uclField));
+		const actualLcl = numberOf(valueOf(ctx.input, row, lclField));
+		if (actualUcl === void 0 || actualLcl === void 0) {
+			ctx.add(locatorOf(row.row, uclField), `第 ${row.row} 行的控制限不是可解析的数值`, "控制限应为数值", "核对填写形式");
+			continue;
+		}
+		const round = (value) => Number(value.toFixed(6));
+		if (Math.abs(actualUcl - expectedUcl) <= tolerance && Math.abs(actualLcl - expectedLcl) <= tolerance) continue;
+		ctx.add(locatorOf(row.row, uclField), `第 ${row.row} 行控制限为 [${round(actualLcl)}, ${round(actualUcl)}]，而按系数表应为 [${round(expectedLcl)}, ${round(expectedUcl)}]`, `控制限应等于中心线与系数、极差的组合（子组大小 ${key} 对应系数 ${JSON.stringify(coefficients)}）`, "核对子组大小、极差与控制限的取数；本条只按配置的系数表做算术核对，不判断过程是否受控");
+	}
+	if (checked === 0) ctx.skip(`材料缺少「${centerField}」或「${rangeField}」，无法核对控制限与系数的一致性`);
+}
+/** `derivedDays` — a day count must equal a date gap less a third value. */
+function derivedDays(ctx) {
+	const daysField = str(ctx.params, "daysField");
+	const fromField = str(ctx.params, "fromField");
+	const toField = str(ctx.params, "toField");
+	const subtractField = str(ctx.params, "subtractField");
+	if (daysField === "" || fromField === "" || toField === "") {
+		ctx.skip("规则库未配置 daysField、fromField 或 toField，本条不执行");
+		return;
+	}
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, daysField)) && filled(valueOf(ctx.input, row, fromField)) && filled(valueOf(ctx.input, row, toField)) && (subtractField === "" || filled(valueOf(ctx.input, row, subtractField))));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${daysField}」与起止日期的行，无法核对天数`);
+		return;
+	}
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	for (const row of usable) {
+		const declared = numberOf(valueOf(ctx.input, row, daysField));
+		const from = parseWallClock(valueOf(ctx.input, row, fromField) ?? "");
+		const to = parseWallClock(valueOf(ctx.input, row, toField) ?? "");
+		const free = subtractField === "" ? 0 : numberOf(valueOf(ctx.input, row, subtractField));
+		if (declared === void 0 || from === void 0 || to === void 0 || free === void 0) {
+			ctx.add(locatorOf(row.row, daysField), `第 ${row.row} 行的「${daysField}」或起止日期中有无法解析的值`, `「${daysField}」应等于起止日期之差${subtractField === "" ? "" : `减去「${subtractField}」`}`, "核对填写形式；本条只做算术核对");
+			continue;
+		}
+		const spanMinutes = diffMinutes(from, to);
+		const derived = Math.max(0, spanMinutes / 1440 - free);
+		const rounded = Number(derived.toFixed(6));
+		if (Math.abs(rounded - declared) <= tolerance) continue;
+		ctx.add(locatorOf(row.row, daysField), `第 ${row.row} 行「${daysField}」填报 ${declared}，按「${toField}」${to.date}${to.hasTime ? ` ${to.time}` : ""} 减「${fromField}」${from.date}${from.hasTime ? ` ${from.time}` : ""}${subtractField === "" ? "" : ` 再减「${subtractField}」`} 应为 ${rounded} 天`, `「${daysField}」应等于起止时刻之差${subtractField === "" ? "" : `减去「${subtractField}」`}，单位为天`, "核对是否抄错或口径不同；本条只做算术核对，不判断起算口径是否正确");
+	}
+}
+/**
+* `sharedTerms` — two cells should share at least N terms.
+*
+* The weakest useful content check, and deliberately so: it looks for shared keywords
+* between a source text and its paraphrase, and reports only when there are none.
+* Paraphrase legitimately changes wording, so a finding means "these two columns look
+* unrelated, worth a human look" and never "the paraphrase is wrong". It also cannot
+* catch a paraphrase that is wrong while sharing vocabulary — a limit its rule's own
+* note states.
+*/
+function sharedTerms(ctx) {
+	const leftField = str(ctx.params, "leftField");
+	const rightField = str(ctx.params, "rightField");
+	const minShared = optionalNumber(ctx.params, "minShared") ?? 1;
+	if (leftField === "" || rightField === "") {
+		ctx.skip("规则库未配置 leftField 或 rightField，本条不执行");
+		return;
+	}
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, leftField)) && filled(valueOf(ctx.input, row, rightField)));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${leftField}」与「${rightField}」的行，本条不适用`);
+		return;
+	}
+	/**
+	* Break text into comparable terms. CJK text has no spaces, so runs of Han
+	* characters become overlapping bigrams — which is what makes a shared keyword
+	* visible without a dictionary — while Latin words and digit runs compare whole.
+	*/
+	const terms = (text) => {
+		const out = /* @__PURE__ */ new Set();
+		for (const word of text.toLowerCase().match(/[a-z]+|\d+(?:\.\d+)?/g) ?? []) out.add(word);
+		for (const run of text.match(/[\u4e00-\u9fff]+/g) ?? []) {
+			if (run.length === 1) out.add(run);
+			for (let index = 0; index + 1 < run.length; index += 1) out.add(run.slice(index, index + 2));
+		}
+		return out;
+	};
+	for (const row of usable) {
+		const left = terms(valueOf(ctx.input, row, leftField) ?? "");
+		const right = terms(valueOf(ctx.input, row, rightField) ?? "");
+		if (left.size === 0 || right.size === 0) continue;
+		let shared = 0;
+		for (const term of right) if (left.has(term)) shared += 1;
+		if (shared >= minShared) continue;
+		ctx.add(locatorOf(row.row, rightField), `第 ${row.row} 行「${rightField}」与「${leftField}」没有共同词（共同词 ${shared} 个，配置下限 ${minShared} 个）`, `「${rightField}」应与「${leftField}」在字面上相关`, str(ctx.params, "fix", "本条只提示两栏看不出关系、值得人工复核，不断言提炼有误；同义改写会拉低共同词数，可调整 minShared"));
+	}
+}
+/** Find a version marker in text such as `PFMEA-001 V2` or `CP-003 版本B`. */
+function versionToken(raw) {
+	if (raw === void 0) return void 0;
+	return /(?:^|[\s(（[【])(?:版本|版次|rev(?:ision)?|ver(?:sion)?|v)\s*[:：]?\s*([A-Za-z]?\d+(?:\.\d+)?)\s*(?:版)?\s*$/i.exec(raw.trim())?.[1];
+}
+/** `referenceVersion` — a cited revision must match the document's current one. */
+function referenceVersion(ctx) {
+	const referenceField = str(ctx.params, "referenceField");
+	const sameVersionField = str(ctx.params, "sameVersionField");
+	const actualCandidates = stringList(ctx.params, "actualVersionField", "actualVersionField");
+	if (referenceField === "") {
+		ctx.skip("规则库未配置 referenceField，本条不执行");
+		return;
+	}
+	if (sameVersionField === "" && actualCandidates.length === 0) {
+		ctx.skip("规则库未配置 sameVersionField 或 actualVersionField，本条不执行");
+		return;
+	}
+	const usable = ctx.input.rows.filter((row) => filled(row.fields[referenceField]));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有「${referenceField}」列或该列全为空，无法核对引用版本`);
+		return;
+	}
+	const currentVersion = (row) => {
+		for (const candidate of actualCandidates) {
+			const value = (row.fields[candidate] ?? "").trim();
+			if (value !== "") return versionToken(value) ?? value;
+		}
+		for (const candidate of actualCandidates) {
+			const value = (ctx.input.header[candidate] ?? "").trim();
+			if (value !== "") return versionToken(value) ?? value;
+		}
+		return "";
+	};
+	const strip = (value) => value.replace(/^[vV]/, "").trim().toLowerCase();
+	let compared = 0;
+	for (const row of usable) {
+		const expected = currentVersion(row);
+		const declared = sameVersionField === "" ? versionToken(row.fields[referenceField]) : (row.fields[sameVersionField] ?? "").trim();
+		if (declared === void 0 || declared === "" || expected === "") {
+			ctx.add(locatorOf(row.row, referenceField), `第 ${row.row} 行引用了「${row.fields[referenceField]}」，但无法确定其版本或文件的现行版本`, "引用中应能看清版本，且文件应有可比的现行版本", "把引用版本单列一栏（sameVersionField），或在表头提供文件实际版本；本条只做版本串比对");
+			continue;
+		}
+		compared += 1;
+		if (strip(declared) === strip(expected)) continue;
+		ctx.add(locatorOf(row.row, referenceField), `第 ${row.row} 行引用的版本「${declared}」与文件现行版本「${expected}」不一致`, "引用的版本应与该文件的现行版本一致", "核对是否还停在上一版；本条只比对版本串，不判断该引用应当指向哪一版");
+	}
+	if (compared === 0) ctx.skip(`材料中的「${referenceField}」既没有单独的版本栏，也没有可识别的版本串，无法核对引用版本`);
+}
+/** `sameVersionWithinGroup` — rows naming one controlled document must agree on its revision. */
+function sameVersionWithinGroup(ctx) {
+	const groupField = str(ctx.params, "groupField");
+	const versionField = str(ctx.params, "versionField");
+	if (groupField === "" || versionField === "") {
+		ctx.skip("规则库未配置 groupField 或 versionField，本条不执行");
+		return;
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const row of ctx.input.rows) {
+		const group = (valueOf(ctx.input, row, groupField) ?? "").trim();
+		const version = (valueOf(ctx.input, row, versionField) ?? "").trim();
+		if (group === "" || version === "") continue;
+		const bucket = groups.get(group);
+		if (bucket === void 0) groups.set(group, [{
+			version,
+			row
+		}]);
+		else bucket.push({
+			version,
+			row
+		});
+	}
+	if (groups.size === 0) {
+		ctx.skip(`材料没有同时填写「${groupField}」与「${versionField}」的行，本条不适用`);
+		return;
+	}
+	const withSeveral = [...groups.entries()].filter(([, entries]) => entries.length > 1);
+	if (withSeveral.length === 0) {
+		ctx.skip(`材料中没有「${groupField}」出现多行的情况，无法核对版本是否一致`);
+		return;
+	}
+	for (const [group, entries] of withSeveral) {
+		const versions = [...new Set(entries.map((entry) => entry.version))];
+		if (versions.length <= 1) continue;
+		const first = entries[0];
+		ctx.add(locatorOf(first.row.row, versionField), `「${groupField}」为「${group}」的行声明了 ${versions.length} 个不同版本：${versions.join(" / ")}`, "同一份受控文件在同一台账内应只有一个版本", "核对是否该文件只被部分修订（版本未同步），或版本栏填写有误");
+	}
+}
+/** `monotonicSequence` — the configured order's items must appear in that order. */
+function monotonicSequence(ctx) {
+	const field = str(ctx.params, "field");
+	const order = stringList(ctx.params, "order", "order");
+	if (field === "") {
+		ctx.skip("规则库未配置 field，本条不执行");
+		return;
+	}
+	if (order.length === 0) {
+		ctx.skip("规则库未配置 order：环节清单与顺序由本机构管理办法规定，本引擎不硬编码");
+		return;
+	}
+	const rankOf = (value) => {
+		const trimmed = value.trim();
+		const exact = order.indexOf(trimmed);
+		if (exact >= 0) return exact;
+		return order.findIndex((candidate) => trimmed.startsWith(candidate));
+	};
+	const seen = [];
+	for (const row of ctx.input.rows) {
+		const value = (valueOf(ctx.input, row, field) ?? "").trim();
+		if (value === "") continue;
+		const rank = rankOf(value);
+		if (rank < 0) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为「${value}」，不在本机构配置的顺序表中`, `「${field}」应为顺序表中的环节之一：${order.join(" → ")}`, "核对该环节名称，或把本机构的环节补进顺序表；本条只按配置的顺序表核对");
+			continue;
+		}
+		seen.push({
+			row: row.row,
+			value,
+			rank
+		});
+	}
+	if (seen.length === 0) {
+		ctx.skip(`材料没有可识别的「${field}」值，本条不适用`);
+		return;
+	}
+	for (let index = 1; index < seen.length; index += 1) {
+		const previous = seen[index - 1];
+		const current = seen[index];
+		if (current.rank >= previous.rank) continue;
+		ctx.add(locatorOf(current.row, field), `第 ${current.row} 行「${field}」为「${current.value}」，出现在第 ${previous.row} 行的「${previous.value}」之后，与配置顺序相反`, `台账应按 ${order.join(" → ")} 的顺序登记`, "核对是否漏登记了中间环节，或两行的顺序填反；本条只按配置的顺序表核对");
+	}
+}
+/** `prefixOf` — a code's stated components must be its successive prefixes. */
+function prefixOf(ctx) {
+	const field = str(ctx.params, "field");
+	const components = stringList(ctx.params, "components", "components");
+	const digits = optionalNumber(ctx.params, "digits");
+	if (field === "" || components.length === 0) {
+		ctx.skip("规则库未配置 field 或 components，本条不执行");
+		return;
+	}
+	const usable = ctx.input.rows.filter((row) => filled(row.fields[field]));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有「${field}」列，本条不适用`);
+		return;
+	}
+	for (const row of usable) {
+		const code = (valueOf(ctx.input, row, field) ?? "").replace(/\s/g, "");
+		if (digits !== void 0 && digits > 0 && code.length !== digits) {
+			ctx.add(locatorOf(row.row, field), `第 ${row.row} 行「${field}」为「${code}」，共 ${code.length} 位，不是 ${digits} 位`, `「${field}」应为 ${digits} 位数字`, "核对位数；本条只核对层级结构，不判断归类是否正确");
+			continue;
+		}
+		let previousLength = 0;
+		let broken = false;
+		for (const component of components) {
+			const stated = (valueOf(ctx.input, row, component) ?? "").replace(/\s/g, "");
+			if (stated === "") continue;
+			if (!code.startsWith(stated)) {
+				ctx.add(locatorOf(row.row, component), `第 ${row.row} 行「${component}」为「${stated}」，不是「${field}」（${code}）的前缀`, `「${component}」应与「${field}」的前几位一致`, "核对层级填写；本条只核对前缀关系，不判断归类是否正确");
+				broken = true;
+				break;
+			}
+			if (stated.length <= previousLength) {
+				ctx.add(locatorOf(row.row, component), `第 ${row.row} 行「${component}」为「${stated}」，不比上一级更细（上一级 ${previousLength} 位）`, "层级应由粗到细、位数递增", "核对层级填写；本条只核对层级顺序，不判断归类是否正确");
+				broken = true;
+				break;
+			}
+			previousLength = stated.length;
+		}
+		if (broken) continue;
+	}
+}
+/**
+* `thresholdCompare` — a verdict must agree with how the value compares to its limit.
+*
+* Definitional: if a measured result exceeds the limit the register itself records, the
+* register's own verdict must say so. It never supplies a limit — the limit comes from the
+* material — so it cannot find a limit taken from the wrong standard, which is a substantive
+* question the plugin leaves to the reader.
+*/
+function thresholdCompare(ctx) {
+	const valueField = str(ctx.params, "valueField");
+	const limitField = str(ctx.params, "limitField");
+	const verdictField = str(ctx.params, "verdictField");
+	const overValues = stringList(ctx.params, "overValues", "overValues");
+	const atMostValues = stringList(ctx.params, "atMostValues", "atMostValues");
+	if (valueField === "" || limitField === "" || verdictField === "") {
+		ctx.skip("规则库未配置 valueField、limitField 或 verdictField，本条不执行");
+		return;
+	}
+	if (overValues.length === 0 || atMostValues.length === 0) {
+		ctx.skip("规则库未配置 overValues 或 atMostValues：判定取值由本机构口径决定，本引擎不硬编码");
+		return;
+	}
+	const tolerance = optionalNumber(ctx.params, "tolerance") ?? 0;
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, valueField)) && filled(valueOf(ctx.input, row, limitField)) && filled(valueOf(ctx.input, row, verdictField)));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${valueField}」「${limitField}」与「${verdictField}」的行，本条不适用`);
+		return;
+	}
+	for (const row of usable) {
+		const value = numberOf(valueOf(ctx.input, row, valueField));
+		const limit = numberOf(valueOf(ctx.input, row, limitField));
+		const verdict = (valueOf(ctx.input, row, verdictField) ?? "").trim();
+		if (value === void 0 || limit === void 0) {
+			ctx.add(locatorOf(row.row, valueField), `第 ${row.row} 行的「${valueField}」或「${limitField}」无法解析为数值，无法与判定比对`, "两个数应可解析，判定应与它们的大小关系相符", "核对填写形式；本条只比对台账自己写的限值");
+			continue;
+		}
+		const isOver = overValues.includes(verdict);
+		const isAtMost = atMostValues.includes(verdict);
+		if (!isOver && !isAtMost) {
+			ctx.add(locatorOf(row.row, verdictField), `第 ${row.row} 行「${verdictField}」的值为「${verdict}」，不在配置的判定取值内`, `「${verdictField}」应为 ${overValues.join(" / ")}（超标）或 ${atMostValues.join(" / ")}（未超标）之一`, "补齐 overValues 或 atMostValues，或修正该栏；本条只核对取值是否在册");
+			continue;
+		}
+		const actuallyOver = value > limit + tolerance;
+		if (actuallyOver === isOver) continue;
+		ctx.add(locatorOf(row.row, verdictField), `第 ${row.row} 行「${valueField}」为 ${value}、「${limitField}」为 ${limit}，而判定为「${verdict}」`, actuallyOver ? `${value} 超过限值 ${limit}，判定应表示超标` : `${value} 未超过限值 ${limit}，判定应表示未超标`, "核对三个数值与判定；本条只按台账自己写的限值比较，不判断该限值是否取对了标准");
+	}
+}
+/**
+* `dateGap` — a later date must be at least N days after an earlier one.
+*
+* Built for a waiting period between two events the register already records: an
+* application date and a harvest date with a withdrawal period between them. The N comes
+* from the material, so the check makes no claim about what the period *should* be.
+*/
+function dateGap(ctx) {
+	const earlierField = str(ctx.params, "earlierField");
+	const laterField = str(ctx.params, "laterField");
+	const minDaysField = str(ctx.params, "minDaysField");
+	const minDaysLiteral = optionalNumber(ctx.params, "minDays");
+	if (earlierField === "" || laterField === "" || minDaysField === "" && minDaysLiteral === void 0) {
+		ctx.skip("规则库未配置 earlierField、laterField 与 minDays/minDaysField，本条不执行");
+		return;
+	}
+	const usable = ctx.input.rows.filter((row) => filled(valueOf(ctx.input, row, earlierField)) && filled(valueOf(ctx.input, row, laterField)) && (minDaysField === "" || filled(valueOf(ctx.input, row, minDaysField))));
+	if (usable.length === 0) {
+		ctx.skip(`材料没有同时填写「${earlierField}」「${laterField}」${minDaysField === "" ? "" : `「${minDaysField}」`} 的行，本条不适用`);
+		return;
+	}
+	let checked = 0;
+	for (const row of usable) {
+		const earlier = parseWallClock(valueOf(ctx.input, row, earlierField) ?? "");
+		const later = parseWallClock(valueOf(ctx.input, row, laterField) ?? "");
+		const required = minDaysField === "" ? minDaysLiteral : numberOf(valueOf(ctx.input, row, minDaysField));
+		if (earlier === void 0 || later === void 0 || required === void 0) {
+			ctx.add(locatorOf(row.row, laterField), `第 ${row.row} 行的「${earlierField}」「${laterField}」或「${minDaysField}」中有无法解析的值`, "两个日期应可解析，间隔天数应为数值", "核对填写形式；本条只做日期间隔核对");
+			continue;
+		}
+		checked += 1;
+		const gap = diffMinutes(earlier, later) / 1440;
+		if (gap + 1e-9 >= required) continue;
+		ctx.add(locatorOf(row.row, laterField), `第 ${row.row} 行「${laterField}」为 ${later.date}，距「${earlierField}」${earlier.date} 只有 ${Number(gap.toFixed(4))} 天，少于${minDaysField === "" ? "配置的" : `「${minDaysField}」的`} ${required} 天`, `「${laterField}」应不早于「${earlierField}」之后 ${required} 天`, str(ctx.params, "fix", "核对三个字段的填写；本条只按台账自己写的间隔天数核对，不判断该天数是否恰当"));
+	}
+	if (checked === 0) ctx.skip(`材料中的「${earlierField}」「${laterField}」${minDaysField === "" ? "" : `「${minDaysField}」`} 没有可解析的组合，无法核对间隔`);
+}
+/** Run one check by its declared kind. */
+function runOneCheck(ctx) {
+	const kind = str(ctx.params, "kind");
+	switch (kind) {
+		case "presence": return presence(ctx);
+		case "presenceAny": return presenceAny(ctx);
+		case "enum": return enumCheck(ctx);
+		case "pattern": return patternCheck(ctx);
+		case "date": return dateCheck(ctx);
+		case "noFutureDate": return noFutureDate(ctx);
+		case "dataAge": return dataAge(ctx);
+		case "number": return numberCheck(ctx);
+		case "unique": return uniqueCheck(ctx);
+		case "sequence": return sequenceCheck(ctx);
+		case "sum": return sumCheck(ctx);
+		case "sumToConstant": return sumToConstant(ctx);
+		case "countPerGroup": return countPerGroup(ctx);
+		case "textContains": return textContains(ctx);
+		case "containsAny": return containsAny(ctx);
+		case "length": return lengthCheck(ctx);
+		case "minLength": return minLength(ctx);
+		case "headerPresence": return headerPresence(ctx);
+		case "headerEnum": return headerEnum(ctx);
+		case "conditionalPresence": return conditionalPresence(ctx);
+		case "highRiskEvidence": return highRiskEvidence(ctx);
+		case "thresholdPresence": return thresholdPresence(ctx);
+		case "thresholdBelow": return thresholdBelow(ctx);
+		case "fieldComparison": return fieldComparison(ctx);
+		case "intervalOrder": return intervalOrder(ctx);
+		case "productOf": return productOf(ctx);
+		case "formula": return formula(ctx);
+		case "capabilityIndex": return capabilityIndex(ctx);
+		case "controlLimits": return controlLimits(ctx);
+		case "derivedDays": return derivedDays(ctx);
+		case "sharedTerms": return sharedTerms(ctx);
+		case "referenceVersion": return referenceVersion(ctx);
+		case "sameVersionWithinGroup": return sameVersionWithinGroup(ctx);
+		case "monotonicSequence": return monotonicSequence(ctx);
+		case "prefixOf": return prefixOf(ctx);
+		case "thresholdCompare": return thresholdCompare(ctx);
+		case "dateGap": return dateGap(ctx);
+		default: ctx.skip(kind === "" ? "规则库未配置 check.kind，本条不执行" : `规则库配置的 check.kind「${kind}」不是本引擎支持的检查类型，本条不执行`);
+	}
+}
+/** Run every rule, collecting issues and the reasons rules did not run. */
+function runChecks(input, ruleset, options) {
+	const issues = [];
+	const reasons = /* @__PURE__ */ new Map();
+	const fired = /* @__PURE__ */ new Set();
+	for (const rule of ruleset.rules) {
+		const declaredCheck = typeof rule.params.check === "object" && rule.params.check !== null && !Array.isArray(rule.params.check) ? rule.params.check : {};
+		const check = {
+			...rule.params,
+			...declaredCheck
+		};
+		delete check.check;
+		const override = options.overrides?.[rule.id];
+		if (override !== void 0) Object.assign(check, override);
+		delete check.check;
+		runOneCheck({
+			input,
+			ruleId: rule.id,
+			params: check,
+			options,
+			add: (locator, found, expected, fix) => {
+				const issue = {
+					id: issueId(ruleset.plugin, rule.id, locator),
+					ruleId: rule.id,
+					severity: rule.severity,
+					locator,
+					found,
+					expected,
+					basis: formatBasis(rule.basis, rule.alsoBasis ?? [])
+				};
+				if (fix !== void 0) issue.fix = fix;
+				issues.push(issue);
+				fired.add(rule.id);
+			},
+			skip: (reason) => {
+				reasons.set(rule.id, reason);
+			}
+		});
+	}
+	return {
+		issues,
+		fired,
+		reasons
+	};
+}
+/** One skipped entry per disabled rule, whether or not the pack declares it. */
+function disabledAsSkipped(ruleset, disabled, note) {
+	const byId = new Map(ruleset.rules.map((rule) => [rule.id, rule]));
+	const out = [];
+	for (const ruleId of disabled) {
+		const rule = byId.get(ruleId);
+		out.push({
+			rule: rule === void 0 ? ruleId : rule.id,
+			reason: note(rule === void 0 ? "配置中禁用了该规则，但规则库中没有这一条" : "该规则在当前配置中被禁用")
+		});
+	}
+	return out;
+}
+/**
+* Run a rule pack against a normalized table.
+* @param input - the table, with canonical field names attached.
+* @param ruleset - the validated rule pack.
+* @param options - plugin identity, clock value, rule selection and overrides.
+* @returns the report, with `skipped` listing every check that did not run.
+*/
+function runTableCheck(input, ruleset, options) {
+	const disabled = /* @__PURE__ */ new Set([...ruleset.disabled, ...options.disabledRules]);
+	const only = new Set(options.onlyRules);
+	const { issues, fired, reasons } = runChecks(input, ruleset, options);
+	const withNote = (reason) => options.skipNotes === void 0 || options.skipNotes === "" ? reason : `${reason}；${options.skipNotes}`;
+	const skipped = disabledAsSkipped(ruleset, [...disabled], withNote);
+	const already = new Set(skipped.map((entry) => entry.rule));
+	for (const [ruleId, reason] of reasons) {
+		if (already.has(ruleId)) continue;
+		if (disabled.has(ruleId) || only.size > 0 && !only.has(ruleId)) continue;
+		skipped.push({
+			rule: ruleId,
+			reason: withNote(reason)
+		});
+		already.add(ruleId);
+	}
+	for (const rule of ruleset.rules) {
+		if (disabled.has(rule.id) || fired.has(rule.id) || already.has(rule.id)) continue;
+		if (only.size > 0 && !only.has(rule.id)) continue;
+		skipped.push({
+			rule: rule.id,
+			reason: withNote("材料满足该检查的前置条件且未发现差异条目")
+		});
+	}
+	if (only.size > 0) {
+		const notSelected = ruleset.rules.filter((rule) => !only.has(rule.id) && !disabled.has(rule.id));
+		if (notSelected.length > 0) skipped.push({
+			rule: notSelected.map((rule) => rule.id).join(","),
+			reason: withNote(`本次调用通过 only 参数把执行范围限制为 ${[...only].join(", ")}，上列规则未执行`)
+		});
+	}
+	const summary = {
+		error: 0,
+		warn: 0,
+		info: 0
+	};
+	for (const issue of issues) summary[issue.severity] += 1;
+	return {
+		plugin: options.plugin,
+		target: input.target,
+		checkedAt: options.checkedAt,
+		rulesetVersion: ruleset.version,
+		summary,
+		issues,
+		skipped
+	};
+}
+/** How the material declares its table. */
+const SPEC = {
+	rowKeys: [
+		"rows",
+		"items",
+		"classifications",
+		"归类"
+	],
+	columns: {
+		itemNo: [
+			"序号",
+			"项号",
+			"编号",
+			"itemNo"
+		],
+		description: [
+			"品名",
+			"商品名称",
+			"货物名称",
+			"description"
+		],
+		material: [
+			"材质",
+			"材料",
+			"成分",
+			"material"
+		],
+		function: [
+			"功能",
+			"用途",
+			"工作原理",
+			"function"
+		],
+		chapter: [
+			"章",
+			"章号",
+			"第几章",
+			"chapter"
+		],
+		heading: [
+			"品目",
+			"四位品目",
+			"品目号",
+			"heading"
+		],
+		subheading: [
+			"子目",
+			"六位子目",
+			"子目号",
+			"subheading"
+		],
+		hsCode: [
+			"商品编号",
+			"HS编码",
+			"税则号列",
+			"hsCode"
+		],
+		declaredAt: [
+			"申报日期",
+			"归类日期",
+			"declaredAt"
+		],
+		basis: [
+			"归类依据",
+			"归类理由",
+			"依据",
+			"basis"
+		],
+		note: [
+			"备注",
+			"说明",
+			"note",
+			"remark"
+		]
+	},
+	header: {
+		declarant: [
+			"declarant",
+			"申报人",
+			"归类人"
+		],
+		tariffVersion: [
+			"tariffVersion",
+			"税则版本",
+			"适用年度税则"
+		],
+		checkedAt: ["checkedAt", "核对日期"]
+	}
+};
+/** Fields the material must carry somewhere for the reader to accept it. */
+const REQUIRE_ANY_OF = [
+	"商品编号",
+	"hsCode",
+	"品名",
+	"description",
+	"章",
+	"chapter",
+	"品目",
+	"heading"
+];
+/**
+* Parse the material and attach its canonical field names.
+* @param source - JSON or YAML text.
+* @param target - description of where the material came from.
+* @returns the normalized table, with each row's aliases resolved to field names.
+*/
+function parseMaterial(source, target) {
+	const table = parseTable(source, target, {
+		...SPEC,
+		...REQUIRE_ANY_OF === void 0 ? {} : { requireAnyOf: REQUIRE_ANY_OF }
+	});
+	for (const row of table.rows) canonicaliseRow(row, SPEC);
+	return table;
+}
+/**
+* Run the rule pack against the material.
+* @param input - normalized table.
+* @param ruleset - validated rule pack.
+* @param options - plugin identity, clock value, rule selection and overrides.
+* @returns the report.
+*/
+function runCheck(input, ruleset, options) {
+	return runTableCheck(input, ruleset, options);
+}
+//#endregion
+//#region src/shared/wording.ts
+/** Footer appended to every rendered report. */
+const DISCLAIMER = "免责声明：本报告由程序按声明的规则集自动生成，仅列出与所引条款之间的字面差异，供人工复核线索使用；不构成对任何事实、行为或文件的定性意见，也不替代主管人员、评审专家或监管机构的判断。规则集的时效性与适用范围以引用文件的最新有效版本为准。";
+//#endregion
+//#region src/view.ts
+/**
+* Model-facing projection of a {@link Report}.
+*
+* `buildView` is pure and covers the whole canonical output shape, so both the
+* tool's `output.render` and the test suite exercise exactly what the model
+* reads. `output.schema` in `index.ts` mirrors these keys.
+*/
+const SEVERITY_ORDER = [
+	"error",
+	"warn",
+	"info"
+];
+function issueLines(issues) {
+	const lines = [];
+	for (const severity of SEVERITY_ORDER) {
+		const group = issues.filter((issue) => issue.severity === severity);
+		if (group.length === 0) continue;
+		lines.push(`### ${severity}（${group.length} 条）`);
+		lines.push("");
+		for (const issue of group) {
+			const where = [];
+			if (issue.locator.file !== void 0) where.push(issue.locator.file);
+			if (issue.locator.row !== void 0) where.push(`第${issue.locator.row}行`);
+			if (issue.locator.page !== void 0) where.push(`第${issue.locator.page}页`);
+			if (issue.locator.cell !== void 0) where.push(issue.locator.cell);
+			if (issue.locator.column !== void 0) where.push(`字段 ${issue.locator.column}`);
+			lines.push(`- \`${issue.ruleId}\` ${where.length === 0 ? "" : `[${where.join(" · ")}] `}${issue.found}`);
+			lines.push(`  - 依据：${issue.expected}`);
+			lines.push(`  - 条款：${issue.basis}`);
+			if (issue.fix !== void 0) lines.push(`  - 建议核对：${issue.fix}`);
+		}
+		lines.push("");
+	}
+	return lines;
+}
+/**
+* Build the model-facing view of a report.
+* @param report - canonical report value.
+* @returns the structured view consumed by `output.render` and by tests.
+*/
+function buildView(report) {
+	const lines = [];
+	lines.push(`# ${report.plugin} 检查结果`);
+	lines.push("");
+	lines.push(`- 检查对象：${report.target}`);
+	lines.push(`- 检查时间：${report.checkedAt}`);
+	lines.push(`- 规则集版本：${report.rulesetVersion}`);
+	lines.push(`- 统计：错误 ${report.summary.error} · 提示 ${report.summary.warn} · 参考 ${report.summary.info}`);
+	lines.push("");
+	lines.push("## 差异明细");
+	lines.push("");
+	if (report.issues.length === 0) {
+		lines.push("本次执行的检查项未产生差异条目。");
+		lines.push("");
+	} else lines.push(...issueLines(report.issues));
+	lines.push("## 未执行的检查");
+	lines.push("");
+	if (report.skipped.length === 0) lines.push("规则集声明的全部检查项均已执行。");
+	else {
+		lines.push(`以下 ${report.skipped.length} 项检查未执行，其结论不包含在本报告中：`);
+		lines.push("");
+		for (const entry of report.skipped) lines.push(`- \`${entry.rule}\`：${entry.reason}`);
+	}
+	lines.push("");
+	lines.push("---");
+	lines.push("");
+	lines.push(DISCLAIMER);
+	return {
+		plugin: report.plugin,
+		target: report.target,
+		checkedAt: report.checkedAt,
+		rulesetVersion: report.rulesetVersion,
+		summary: report.summary,
+		issueCount: report.issues.length,
+		skippedCount: report.skipped.length,
+		markdown: lines.join("\n"),
+		reportJson: canonicalJson(report)
+	};
+}
+//#endregion
+//#region src/shared/ruleset.ts
+/**
+* Rule-pack loading and validation.
+*
+* `loadRuleset` is the only entry point. It fails loudly rather than producing a
+* short report, and it enforces three rules that keep the family honest:
+*
+*  1. every rule carries an id, a severity and a complete citable basis;
+*  2. rule ids are unique and every requested disable names a real rule;
+*  3. a check whose basis is a general principle, or a locally configured
+*     threshold, may not be declared `error` — those are leads for human review,
+*     not statements about a violated requirement.
+*/
+const SEVERITIES = [
+	"error",
+	"warn",
+	"info"
+];
+const BASIS_KINDS = [
+	"direct",
+	"derived-from-principle",
+	"institutional-configuration"
+];
+const MAX_SEVERITY_BY_KIND = {
+	direct: "error",
+	"derived-from-principle": "warn",
+	"institutional-configuration": "info"
+};
+const SEVERITY_RANK = {
+	error: 2,
+	warn: 1,
+	info: 0
+};
+function asRecord(value, where) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new YamlSubsetError(`${where}: expected a mapping`);
+	return value;
+}
+function asStringArray(value, where) {
+	if (value === void 0 || value === null) return [];
+	if (!Array.isArray(value)) throw new YamlSubsetError(`${where}: expected a sequence`);
+	return value.map((entry) => {
+		if (typeof entry !== "string") throw new YamlSubsetError(`${where}: expected string entries`);
+		return entry;
+	});
+}
+function parseBasis(value, where) {
+	const source = asRecord(value, where);
+	const kindRaw = requireString(source, "kind", where);
+	if (!BASIS_KINDS.includes(kindRaw)) throw new YamlSubsetError(`${where}: kind must be one of ${BASIS_KINDS.join(" / ")}`);
+	const basis = {
+		document: requireString(source, "document", where),
+		number: typeof source.number === "string" ? source.number : "",
+		clause: requireString(source, "clause", where),
+		excerpt: requireString(source, "excerpt", where),
+		kind: kindRaw,
+		source: requireString(source, "source", where)
+	};
+	if (basis.excerpt.trim().length < 8) throw new YamlSubsetError(`${where}: excerpt is too short to be a verbatim quotation`);
+	return basis;
+}
+function parseRule(value, index) {
+	const where = `rules[${index}]`;
+	const source = asRecord(value, where);
+	const id = requireString(source, "id", where);
+	const severityRaw = requireString(source, "severity", where);
+	if (!SEVERITIES.includes(severityRaw)) throw new YamlSubsetError(`${where}: severity must be one of ${SEVERITIES.join(" / ")}`);
+	const basis = parseBasis(source.basis, `${where}.basis`);
+	const severity = severityRaw;
+	const ceiling = MAX_SEVERITY_BY_KIND[basis.kind];
+	if (SEVERITY_RANK[severity] > SEVERITY_RANK[ceiling]) throw new YamlSubsetError(`${where} (${id}): severity "${severity}" is not allowed for a "${basis.kind}" basis; the strongest permitted severity is "${ceiling}"`);
+	const rule = {
+		id,
+		title: requireString(source, "title", where),
+		severity,
+		basis,
+		params: source.params === void 0 || source.params === null ? {} : asRecord(source.params, `${where}.params`)
+	};
+	if (source.alsoBasis !== void 0 && source.alsoBasis !== null) {
+		if (!Array.isArray(source.alsoBasis)) throw new YamlSubsetError(`${where}.alsoBasis: expected a sequence`);
+		rule.alsoBasis = source.alsoBasis.map((entry, offset) => parseBasis(entry, `${where}.alsoBasis[${offset}]`));
+	}
+	if (typeof source.note === "string") rule.note = source.note;
+	return rule;
+}
+/**
+* Parse and validate a rule pack.
+* @param source - YAML text of the rule pack.
+* @returns the validated ruleset.
+*/
+function loadRuleset(source) {
+	const root = asRecord(parseYaml(source), "ruleset");
+	const plugin = requireString(root, "plugin", "ruleset");
+	const version = requireString(root, "version", "ruleset");
+	const rulesRaw = root.rules;
+	if (!Array.isArray(rulesRaw) || rulesRaw.length === 0) throw new YamlSubsetError("ruleset: \"rules\" must be a non-empty sequence");
+	const rules = rulesRaw.map((entry, index) => parseRule(entry, index));
+	const seen = /* @__PURE__ */ new Set();
+	for (const rule of rules) {
+		if (seen.has(rule.id)) throw new YamlSubsetError(`ruleset: duplicate rule id "${rule.id}"`);
+		seen.add(rule.id);
+	}
+	const disabled = asStringArray(root.disabled, "ruleset.disabled");
+	for (const id of disabled) if (!seen.has(id)) throw new YamlSubsetError(`ruleset.disabled: unknown rule id "${id}"`);
+	return {
+		version,
+		plugin,
+		rules,
+		disabled
+	};
+}
+//#endregion
+//#region src/shared/memo.ts
+/**
+* Memoized loading of package-owned rule packs.
+*
+* Rule packs ship with the plugin, are read-only at runtime and are small, so
+* they are parsed once per process and reused. Keeping the reads here means the
+* pure check core still receives a plain `Ruleset` value and stays testable
+* without a plugin context.
+*/
+const cache = /* @__PURE__ */ new Map();
+/**
+* Load and cache a rule pack by absolute path.
+* @param path - absolute path to the rule-pack YAML.
+* @returns the validated ruleset.
+*/
+function loadRulesetFile(path) {
+	const cached = cache.get(path);
+	if (cached !== void 0) return cached;
+	const pending = readFile(path, "utf8").then((text) => loadRuleset(text));
+	cache.set(path, pending);
+	pending.catch(() => cache.delete(path));
+	return pending;
+}
+//#endregion
+//#region src/index.ts
+const name = "dsh-hs-classify";
+const inject = ["tools"];
+/** Tool id exposed to the model, and the row id in `cordis.patch.yml`. */
+const TOOL_NAME = "hs_classify";
+/**
+* Locate a package-owned file such as the rule pack.
+*
+* Resolution order: absolute path, then every ancestor of the module directory,
+* then the process working directory. A wrong silent fallback would build a
+* report from the wrong rule pack, so a miss throws with the paths tried.
+*
+* @param relative - configured path, relative to the plugin package root.
+* @returns the resolved absolute path.
+* @throws Error naming every location tried, when the file is absent.
+*/
+function resolvePackageFile(relative) {
+	if (isAbsolute(relative)) {
+		if (existsSync(relative)) return relative;
+		throw new Error(`规则库文件不存在：${relative}`);
+	}
+	const tried = [];
+	let current = import.meta.dirname ?? process.cwd();
+	for (;;) {
+		const candidate = resolve(current, relative);
+		tried.push(candidate);
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	const fromCwd = resolve(process.cwd(), relative);
+	if (!tried.includes(fromCwd)) {
+		tried.push(fromCwd);
+		if (existsSync(fromCwd)) return fromCwd;
+	}
+	throw new Error(`规则库文件未找到：${relative}；已尝试 ${tried.length} 个位置，最近一处为 ${tried[0] ?? ""}`);
+}
+/** Read material from a file path or use the inline text as-is. */
+async function readMaterial(file, material, signal) {
+	if (file !== void 0 && file.trim() !== "") {
+		const path = resolve(file);
+		signal.throwIfAborted();
+		return {
+			text: await readFile(path, {
+				encoding: "utf8",
+				signal
+			}),
+			target: path
+		};
+	}
+	if (material !== void 0 && material.trim() !== "") return {
+		text: material,
+		target: "(内联材料)"
+	};
+	throw new MaterialError("必须提供 file 或 material 之一");
+}
+/**
+* Register the checker tool.
+*
+* Registration is an effect: `ctx.tools.register` returns the disposer that
+* removes the tool when this plugin unloads, which is what keeps the plugin
+* hot-reloadable.
+*
+* @param ctx - plugin context, with `tools` already available.
+* @param config - validated configuration.
+*/
+function apply(ctx, config) {
+	return ctx.tools.register(defineTool({
+		name: TOOL_NAME,
+		description: "商品归类层级一致性核对（按章、品目、子目与商品编号的层级关系核对自洽，仅提示差异，不作出定性结论）本工具只列出材料与所引条款之间的字面差异，供人工复核，不作出任何定性结论。材料为 JSON 或 YAML；无法执行的检查会列在 skipped 中。",
+		parameters: {
+			file: {
+				type: "string",
+				description: "材料文件绝对路径（JSON 或 YAML）。与 material 二选一。"
+			},
+			material: {
+				type: "string",
+				description: "内联材料文本（JSON 或 YAML）。与 file 二选一。"
+			},
+			rulesFile: {
+				type: "string",
+				description: "覆盖配置中的规则库路径（相对插件包根或绝对路径）。"
+			},
+			only: {
+				type: "array",
+				items: { type: "string" },
+				description: "只执行这些规则 id；留空表示执行全部规则。"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					plugin: { type: "string" },
+					target: { type: "string" },
+					checkedAt: { type: "string" },
+					rulesetVersion: { type: "string" },
+					summary: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							error: { type: "integer" },
+							warn: { type: "integer" },
+							info: { type: "integer" }
+						}
+					},
+					issueCount: { type: "integer" },
+					skippedCount: { type: "integer" },
+					markdown: { type: "string" },
+					reportJson: { type: "string" }
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.markdown
+			}]
+		},
+		timeoutMs: config.timeoutMs,
+		isConcurrencySafe: () => true,
+		async execute(args, exec) {
+			const relative = args.rulesFile !== void 0 && args.rulesFile.trim() !== "" ? args.rulesFile : config.rulesFile;
+			const [material, ruleset] = await Promise.all([readMaterial(args.file, args.material, exec.signal), loadRulesetFile(resolvePackageFile(relative))]);
+			exec.signal.throwIfAborted();
+			const input = parseMaterial(material.text, material.target);
+			const only = (args.only ?? []).length > 0 ? args.only : config.onlyRules;
+			return buildView(runCheck(input, ruleset, {
+				plugin: name,
+				checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				disabledRules: config.disabledRules,
+				onlyRules: only,
+				skipNotes: config.skipNotes === "" ? void 0 : config.skipNotes
+			}));
+		}
+	}));
+}
+//#endregion
+export { Config, TOOL_NAME, apply, inject, name, resolvePackageFile };